]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Replace typedef by using in include
authorDaniel Arndt <daniel.arndt@iwr.uni-heidelberg.de>
Wed, 27 Jun 2018 13:13:01 +0000 (15:13 +0200)
committerDaniel Arndt <daniel.arndt@iwr.uni-heidelberg.de>
Wed, 27 Jun 2018 13:13:01 +0000 (15:13 +0200)
177 files changed:
include/deal.II/base/aligned_vector.h
include/deal.II/base/array_view.h
include/deal.II/base/complex_overloads.h
include/deal.II/base/data_out_base.h
include/deal.II/base/exceptions.h
include/deal.II/base/function_parser.h
include/deal.II/base/index_set.h
include/deal.II/base/iterator_range.h
include/deal.II/base/linear_index_iterator.h
include/deal.II/base/mg_level_object.h
include/deal.II/base/mpi.h
include/deal.II/base/numbers.h
include/deal.II/base/parallel.h
include/deal.II/base/parsed_function.h
include/deal.II/base/path_search.h
include/deal.II/base/patterns.h
include/deal.II/base/qprojector.h
include/deal.II/base/quadrature.h
include/deal.II/base/quadrature_point_data.h
include/deal.II/base/subscriptor.h
include/deal.II/base/symmetric_tensor.h
include/deal.II/base/symmetric_tensor.templates.h
include/deal.II/base/table.h
include/deal.II/base/table_handler.h
include/deal.II/base/template_constraints.h
include/deal.II/base/tensor.h
include/deal.II/base/tensor_accessors.h
include/deal.II/base/tensor_function.h
include/deal.II/base/thread_management.h
include/deal.II/base/timer.h
include/deal.II/base/types.h
include/deal.II/base/vectorization.h
include/deal.II/base/work_stream.h
include/deal.II/differentiation/ad/ad_number_traits.h
include/deal.II/differentiation/ad/adolc_number_types.h
include/deal.II/differentiation/ad/adolc_product_types.h
include/deal.II/differentiation/ad/sacado_number_types.h
include/deal.II/differentiation/ad/sacado_product_types.h
include/deal.II/distributed/p4est_wrappers.h
include/deal.II/distributed/shared_tria.h
include/deal.II/distributed/tria.h
include/deal.II/dofs/deprecated_function_map.h
include/deal.II/dofs/dof_accessor.h
include/deal.II/dofs/dof_handler.h
include/deal.II/dofs/dof_iterator_selector.h
include/deal.II/fe/fe_tools_extrapolate.templates.h
include/deal.II/fe/fe_update_flags.h
include/deal.II/fe/fe_values.h
include/deal.II/grid/cell_id.h
include/deal.II/grid/filtered_iterator.h
include/deal.II/grid/grid_generator.h
include/deal.II/grid/grid_tools.h
include/deal.II/grid/intergrid_map.h
include/deal.II/grid/manifold.h
include/deal.II/grid/tria.h
include/deal.II/grid/tria_accessor.h
include/deal.II/grid/tria_iterator.h
include/deal.II/grid/tria_iterator_selector.h
include/deal.II/hp/dof_handler.h
include/deal.II/hp/dof_level.h
include/deal.II/hp/fe_collection.h
include/deal.II/lac/affine_constraints.h
include/deal.II/lac/affine_constraints.templates.h
include/deal.II/lac/arpack_solver.h
include/deal.II/lac/block_indices.h
include/deal.II/lac/block_linear_operator.h
include/deal.II/lac/block_matrix_array.h
include/deal.II/lac/block_matrix_base.h
include/deal.II/lac/block_sparse_matrix.h
include/deal.II/lac/block_sparse_matrix_ez.h
include/deal.II/lac/block_sparsity_pattern.h
include/deal.II/lac/block_vector.h
include/deal.II/lac/block_vector_base.h
include/deal.II/lac/chunk_sparse_matrix.h
include/deal.II/lac/chunk_sparse_matrix.templates.h
include/deal.II/lac/chunk_sparsity_pattern.h
include/deal.II/lac/cuda_sparse_matrix.h
include/deal.II/lac/cuda_vector.h
include/deal.II/lac/diagonal_matrix.h
include/deal.II/lac/dynamic_sparsity_pattern.h
include/deal.II/lac/eigen.h
include/deal.II/lac/filtered_matrix.h
include/deal.II/lac/full_matrix.h
include/deal.II/lac/generic_linear_algebra.h
include/deal.II/lac/householder.h
include/deal.II/lac/identity_matrix.h
include/deal.II/lac/la_parallel_block_vector.h
include/deal.II/lac/la_parallel_vector.h
include/deal.II/lac/la_vector.h
include/deal.II/lac/la_vector.templates.h
include/deal.II/lac/lapack_full_matrix.h
include/deal.II/lac/lapack_support.h
include/deal.II/lac/linear_operator.h
include/deal.II/lac/matrix_block.h
include/deal.II/lac/matrix_iterator.h
include/deal.II/lac/matrix_lib.h
include/deal.II/lac/matrix_out.h
include/deal.II/lac/packaged_operation.h
include/deal.II/lac/parpack_solver.h
include/deal.II/lac/petsc_full_matrix.h
include/deal.II/lac/petsc_matrix_base.h
include/deal.II/lac/petsc_parallel_block_sparse_matrix.h
include/deal.II/lac/petsc_parallel_block_vector.h
include/deal.II/lac/petsc_parallel_sparse_matrix.h
include/deal.II/lac/petsc_parallel_vector.h
include/deal.II/lac/petsc_vector_base.h
include/deal.II/lac/pointer_matrix.h
include/deal.II/lac/precondition.h
include/deal.II/lac/precondition_block.h
include/deal.II/lac/precondition_block_base.h
include/deal.II/lac/precondition_selector.h
include/deal.II/lac/read_write_vector.h
include/deal.II/lac/relaxation_block.h
include/deal.II/lac/scalapack.h
include/deal.II/lac/solver.h
include/deal.II/lac/solver_cg.h
include/deal.II/lac/solver_minres.h
include/deal.II/lac/solver_selector.h
include/deal.II/lac/sparse_decomposition.h
include/deal.II/lac/sparse_direct.h
include/deal.II/lac/sparse_ilu.h
include/deal.II/lac/sparse_matrix.h
include/deal.II/lac/sparse_matrix.templates.h
include/deal.II/lac/sparse_matrix_ez.h
include/deal.II/lac/sparse_mic.h
include/deal.II/lac/sparse_vanka.h
include/deal.II/lac/sparse_vanka.templates.h
include/deal.II/lac/sparsity_pattern.h
include/deal.II/lac/tridiagonal_matrix.h
include/deal.II/lac/trilinos_block_sparse_matrix.h
include/deal.II/lac/trilinos_linear_operator.h
include/deal.II/lac/trilinos_parallel_block_vector.h
include/deal.II/lac/trilinos_precondition.h
include/deal.II/lac/trilinos_sparse_matrix.h
include/deal.II/lac/trilinos_sparsity_pattern.h
include/deal.II/lac/trilinos_vector.h
include/deal.II/lac/vector.h
include/deal.II/lac/vector_memory.h
include/deal.II/lac/vector_operations_internal.h
include/deal.II/lac/vector_space_vector.h
include/deal.II/lac/vector_view.h
include/deal.II/matrix_free/cuda_fe_evaluation.h
include/deal.II/matrix_free/cuda_matrix_free.h
include/deal.II/matrix_free/cuda_matrix_free.templates.h
include/deal.II/matrix_free/evaluation_kernels.h
include/deal.II/matrix_free/fe_evaluation.h
include/deal.II/matrix_free/mapping_info.templates.h
include/deal.II/matrix_free/matrix_free.h
include/deal.II/matrix_free/operators.h
include/deal.II/matrix_free/task_info.h
include/deal.II/meshworker/assembler.h
include/deal.II/meshworker/integration_info.h
include/deal.II/multigrid/mg_constrained_dofs.h
include/deal.II/multigrid/mg_transfer.h
include/deal.II/multigrid/mg_transfer.templates.h
include/deal.II/multigrid/mg_transfer_block.templates.h
include/deal.II/multigrid/mg_transfer_component.templates.h
include/deal.II/multigrid/multigrid.h
include/deal.II/numerics/data_out.h
include/deal.II/numerics/data_out_dof_data.h
include/deal.II/numerics/data_out_dof_data.templates.h
include/deal.II/numerics/data_out_faces.h
include/deal.II/numerics/data_out_rotation.h
include/deal.II/numerics/derivative_approximation.h
include/deal.II/numerics/fe_field_function.h
include/deal.II/numerics/fe_field_function.templates.h
include/deal.II/numerics/kdtree.h
include/deal.II/numerics/matrix_creator.templates.h
include/deal.II/numerics/time_dependent.h
include/deal.II/numerics/vector_tools.templates.h
include/deal.II/optimization/rol/vector_adaptor.h
include/deal.II/particles/particle.h
include/deal.II/particles/particle_handler.h
include/deal.II/particles/particle_iterator.h
include/deal.II/particles/property_pool.h
include/deal.II/sundials/arkode.h
include/deal.II/sundials/ida.h

index fc9583a558e84423162798b17fe794a4c84b7009..78184caec6f539da2dfb02f8d2f19552fe6a6d4d 100644 (file)
@@ -65,14 +65,14 @@ public:
    * Declare standard types used in all containers. These types parallel those
    * in the <tt>C++</tt> standard libraries <tt>vector<...></tt> class.
    */
-  typedef T                 value_type;
-  typedef value_type *      pointer;
-  typedef const value_type *const_pointer;
-  typedef value_type *      iterator;
-  typedef const value_type *const_iterator;
-  typedef value_type &      reference;
-  typedef const value_type &const_reference;
-  typedef std::size_t       size_type;
+  using value_type      = T;
+  using pointer         = value_type *;
+  using const_pointer   = const value_type *;
+  using iterator        = value_type *;
+  using const_iterator  = const value_type *;
+  using reference       = value_type &;
+  using const_reference = const value_type &;
+  using size_type       = std::size_t;
 
   /**
    * Empty constructor. Sets the vector size to zero.
index b50ee7854ef11a0789b53cf0b709c556cfacb3a1..4a0494c82bb15720ec6701149172f6f4fe64b37e 100644 (file)
@@ -80,20 +80,20 @@ class ArrayView
 {
 public:
   /**
-   * A typedef that denotes the "value_type" of this container-like class,
+   * An alias that denotes the "value_type" of this container-like class,
    * i.e., the type of the element it "stores" or points to.
    */
-  typedef ElementType value_type;
+  using value_type = ElementType;
 
   /**
-   * A typedef for iterators pointing into the array.
+   * An alias for iterators pointing into the array.
    */
-  typedef value_type *iterator;
+  using iterator = value_type *;
 
   /**
-   * A typedef for const iterators pointing into the array.
+   * An alias for const iterators pointing into the array.
    */
-  typedef const ElementType *const_iterator;
+  using const_iterator = const ElementType *;
 
   /**
    * Constructor.
index e648613cb685b2992b910982a5addcf19be8c8c4..e95bed9a951c59635d2e5735069b0b1c071aa9d7 100644 (file)
@@ -40,8 +40,8 @@ template <typename T, typename U>
 typename ProductType<std::complex<T>, std::complex<U>>::type inline
 operator*(const std::complex<T> &left, const std::complex<U> &right)
 {
-  typedef
-    typename ProductType<std::complex<T>, std::complex<U>>::type result_type;
+  using result_type =
+    typename ProductType<std::complex<T>, std::complex<U>>::type;
   return static_cast<result_type>(left) * static_cast<result_type>(right);
 }
 
@@ -59,7 +59,7 @@ typename ProductType<std::complex<T>,
                      typename EnableIfScalar<U>::type>::type inline
 operator*(const std::complex<T> &left, const U &right)
 {
-  typedef typename ProductType<std::complex<T>, U>::type result_type;
+  using result_type = typename ProductType<std::complex<T>, U>::type;
   return static_cast<result_type>(left) * static_cast<result_type>(right);
 }
 
@@ -77,7 +77,7 @@ typename ProductType<typename EnableIfScalar<T>::type,
                      std::complex<U>>::type inline
 operator*(const T &left, const std::complex<U> &right)
 {
-  typedef typename ProductType<std::complex<T>, U>::type result_type;
+  using result_type = typename ProductType<std::complex<T>, U>::type;
   return static_cast<result_type>(left) * static_cast<result_type>(right);
 }
 #endif /* DEAL_II_HAVE_COMPLEX_OPERATOR_OVERLOADS */
index 6db6b620be7b96b38f5ce382a06f63f4cbaa3343..43e7c88453b82835cfaa816824600636080128d4 100644 (file)
@@ -942,9 +942,9 @@ namespace DataOutBase
      * Besides the actual value by which the color is to be computed, min and
      * max values of the data to be colorized are given as well.
      */
-    typedef RgbValues (*ColorFunction)(const double value,
-                                       const double min_value,
-                                       const double max_value);
+    using ColorFunction = RgbValues (*)(const double value,
+                                        const double min_value,
+                                        const double max_value);
 
     /**
      * This is a pointer to the function which is used to colorize the cells.
@@ -1447,7 +1447,7 @@ namespace DataOutBase
       }
     };
 
-    typedef std::multimap<Point<3>, unsigned int, Point3Comp> Map3DPoint;
+    using Map3DPoint = std::multimap<Point<3>, unsigned int, Point3Comp>;
 
     /**
      * Flags used to specify filtering behavior.
index 88d73270a922adeed494fc7178b505273ea1e61d..6ff4068d00c62b693802d984544a6a50a84c6830 100644 (file)
@@ -1391,7 +1391,7 @@ namespace internal
   template <typename T, typename U>
   struct argument_type<T(U)>
   {
-    typedef U type;
+    using type = U;
   };
 } // namespace internal
 
index 49c8f2e2601b21699fb589ffc42fead01a155ed2..7efdedf006c16588a50355a3836bb6d04b31de65 100644 (file)
@@ -220,12 +220,12 @@ public:
   /**
    * Type for the constant map. Used by the initialize() method.
    */
-  typedef std::map<std::string, double> ConstMap;
+  using ConstMap = std::map<std::string, double>;
 
   /**
    * Iterator for the constants map. Used by the initialize() method.
    */
-  typedef ConstMap::iterator ConstMapIterator;
+  using ConstMapIterator = ConstMap::iterator;
 
   /**
    * Initialize the function.  This methods accepts the following parameters:
index 42dd03323e3b3281df989fefefc3b1aa94eddf6a..7246e0bfa26dca459ba6b6429002a37338b5b815 100644 (file)
@@ -36,7 +36,7 @@
 #if defined(DEAL_II_WITH_MPI) || defined(DEAL_II_WITH_PETSC)
 #  include <mpi.h>
 #else
-typedef int MPI_Comm;
+using MPI_Comm = int;
 #  ifndef MPI_COMM_WORLD
 #    define MPI_COMM_WORLD 0
 #  endif
@@ -79,14 +79,14 @@ public:
    * @p size_type is the type used for storing the size and the individual
    * entries in the IndexSet.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * One can see an IndexSet as a container of size size(), where the elements
    * of the containers are bool values that are either false or true,
    * depending on whether a particular index is an element of the IndexSet or
    * not. In other words, an IndexSet is a bit like a vector in which the
-   * elements we store are booleans. In this view, the correct local typedef
+   * elements we store are booleans. In this view, the correct local alias
    * indicating the type of the elements of the vector would then be @p bool.
    *
    * On the other hand, @p bool has the disadvantage that it is not a
@@ -98,7 +98,7 @@ public:
    * other words, declaring the type of the elements of the vector as a signed
    * integer is only a small lie, but it is a useful one.
    */
-  typedef signed int value_type;
+  using value_type = signed int;
 
 
   /**
@@ -650,15 +650,15 @@ public:
     operator-(const IntervalIterator &p) const;
 
     /**
-     * Mark the class as forward iterator and declare some typedefs which are
+     * Mark the class as forward iterator and declare some alias which are
      * standard for iterators and are used by algorithms to enquire about the
      * specifics of the iterators they work on.
      */
-    typedef std::forward_iterator_tag iterator_category;
-    typedef IntervalAccessor          value_type;
-    typedef std::ptrdiff_t            difference_type;
-    typedef IntervalAccessor *        pointer;
-    typedef IntervalAccessor &        reference;
+    using iterator_category = std::forward_iterator_tag;
+    using value_type        = IntervalAccessor;
+    using difference_type   = std::ptrdiff_t;
+    using pointer           = IntervalAccessor *;
+    using reference         = IntervalAccessor &;
 
   private:
     /**
@@ -741,15 +741,15 @@ public:
     operator-(const ElementIterator &p) const;
 
     /**
-     * Mark the class as forward iterator and declare some typedefs which are
+     * Mark the class as forward iterator and declare some alias which are
      * standard for iterators and are used by algorithms to enquire about the
      * specifics of the iterators they work on.
      */
-    typedef std::forward_iterator_tag iterator_category;
-    typedef size_type                 value_type;
-    typedef std::ptrdiff_t            difference_type;
-    typedef size_type *               pointer;
-    typedef size_type &               reference;
+    using iterator_category = std::forward_iterator_tag;
+    using value_type        = size_type;
+    using difference_type   = std::ptrdiff_t;
+    using pointer           = size_type *;
+    using reference         = size_type &;
 
   private:
     /**
index eb45a2f8eeded4b11cd308f8cb349d51fa6347ff..cf09a4f6e7fbeb7169409c64d191c5d19d495ba8 100644 (file)
@@ -128,7 +128,7 @@ public:
      * Typedef the elements of the collection to give them a name that is more
      * distinct.
      */
-    typedef Iterator BaseIterator;
+    using BaseIterator = Iterator;
 
     /**
      * Constructor. Initialize this iterator-over-iterator in such a way that
@@ -175,15 +175,15 @@ public:
     operator!=(const IteratorOverIterators &i_o_i);
 
     /**
-     * Mark the class as forward iterator and declare some typedefs which are
+     * Mark the class as forward iterator and declare some alias which are
      * standard for iterators and are used by algorithms to enquire about the
      * specifics of the iterators they work on.
      */
-    typedef std::forward_iterator_tag          iterator_category;
-    typedef Iterator                           value_type;
-    typedef typename Iterator::difference_type difference_type;
-    typedef Iterator *                         pointer;
-    typedef Iterator &                         reference;
+    using iterator_category = std::forward_iterator_tag;
+    using value_type        = Iterator;
+    using difference_type   = typename Iterator::difference_type;
+    using pointer           = Iterator *;
+    using reference         = Iterator &;
 
   private:
     /**
@@ -196,7 +196,7 @@ public:
   /**
    * Typedef for the iterator type represent by this class.
    */
-  typedef Iterator iterator;
+  using iterator = Iterator;
 
   /**
    * Default constructor. Create a range represented by two default
index de4047b15ac0c030a5987cb9f80d49a69fe379b7..f7be30427b2f7689950ecdbb5efe5b0edbfe04f1 100644 (file)
@@ -56,12 +56,13 @@ DEAL_II_NAMESPACE_OPEN
  *   {
  *   public:
  *     // const iterators store a const pointer
- *     typedef typename std::conditional<Constness, const Container<T>*,
- *                                       Container<T>*>::type
- *     container_pointer_type;
+ *     using container_pointer_type
+ *       = typename std::conditional<Constness,
+ *                                   const Container<T>*,
+ *                                   Container<T>*>::type;
  *
- *     // This typedef is assumed to exist.
- *     typedef std::size_t size_type;
+ *     // This alias is assumed to exist.
+ *     using size_type = std::size_t;
  *
  *     // constructor.
  *     Accessor(const container_pointer_type container,
@@ -94,9 +95,9 @@ DEAL_II_NAMESPACE_OPEN
  *   };
  *
  * public:
- *   typedef std::size_t size_type;
- *   typedef Iterator<true> const_iterator;
- *   typedef Iterator<false> iterator;
+ *   using size_type = std::size_t;
+ *   using const_iterator = Iterator<true>;
+ *   using iterator = Iterator<false>;
  *
  *   iterator begin ();
  *   iterator end ();
@@ -143,33 +144,33 @@ public:
   /**
    * Iterator category.
    */
-  typedef std::random_access_iterator_tag iterator_category;
+  using iterator_category = std::random_access_iterator_tag;
 
   /**
-   * A typedef for the type you get when you dereference an iterator of the
+   * An alias for the type you get when you dereference an iterator of the
    * current kind.
    */
-  typedef AccessorType value_type;
+  using value_type = AccessorType;
 
   /**
    * Difference type.
    */
-  typedef std::ptrdiff_t difference_type;
+  using difference_type = std::ptrdiff_t;
 
   /**
    * Reference type.
    */
-  typedef const value_type &reference;
+  using reference = const value_type &;
 
   /**
    * Pointer type.
    */
-  typedef const value_type *pointer;
+  using pointer = const value_type *;
 
   /**
    * Size type used by the underlying container.
    */
-  typedef typename value_type::size_type size_type;
+  using size_type = typename value_type::size_type;
 
   /**
    * Copy operator.
index 3aaa2adf8838a4b9fc62568d9c2da6b2f19bfc27..dfe65a39c060f1dd4f6aec544110f7a21808bd55 100644 (file)
@@ -286,7 +286,7 @@ std::size_t
 MGLevelObject<Object>::memory_consumption() const
 {
   std::size_t result = sizeof(*this);
-  typedef typename std::vector<std::shared_ptr<Object>>::const_iterator Iter;
+  using Iter = typename std::vector<std::shared_ptr<Object>>::const_iterator;
   const Iter end = objects.end();
   for (Iter o = objects.begin(); o != end; ++o)
     result += (*o)->memory_consumption();
index d9fb558b1c576e35d9dda5e16f1be390cda858fd..a86996fe0836e55e0d4a0321017caadede602959 100644 (file)
@@ -27,9 +27,9 @@
 // without MPI, we would still like to use
 // some constructs with MPI data
 // types. Therefore, create some dummies
-typedef int MPI_Comm;
-typedef int MPI_Datatype;
-typedef int MPI_Op;
+using MPI_Comm     = int;
+using MPI_Datatype = int;
+using MPI_Op       = int;
 #  ifndef MPI_COMM_WORLD
 #    define MPI_COMM_WORLD 0
 #  endif
index b29833536b90cad43f59acb6ad66decae1d745cc..db7c151643b8d54153cb4a9f28b6ad9b3f259bf8 100644 (file)
@@ -336,12 +336,12 @@ namespace numbers
     static const bool is_complex = false;
 
     /**
-     * For this data type, typedef the corresponding real type. Since the
+     * For this data type, alias the corresponding real type. Since the
      * general template is selected for all data types that are not
      * specializations of std::complex<T>, the underlying type must be real-
      * values, so the real_type is equal to the underlying type.
      */
-    typedef number real_type;
+    using real_type = number;
 
     /**
      * Return the complex-conjugate of the given number. Since the general
@@ -386,12 +386,12 @@ namespace numbers
     static const bool is_complex = true;
 
     /**
-     * For this data type, typedef the corresponding real type. Since this
+     * For this data type, alias the corresponding real type. Since this
      * specialization of the template is selected for number types
      * std::complex<T>, the real type is equal to the type used to store the
      * two components of the complex number.
      */
-    typedef number real_type;
+    using real_type = number;
 
     /**
      * Return the complex-conjugate of the given number.
index d0ffb55744d92150d772ba4527d38cf8ee104ca0..9f82c117502586795caec8254edef2ebfa18d88f 100644 (file)
@@ -184,9 +184,9 @@ namespace parallel
     for (OutputIterator in = begin_in; in != end_in;)
       *out++ = predicate(*in++);
 #else
-    typedef std::tuple<InputIterator, OutputIterator> Iterators;
-    typedef SynchronousIterators<Iterators>           SyncIterators;
-    Iterators                                         x_begin(begin_in, out);
+    using Iterators     = std::tuple<InputIterator, OutputIterator>;
+    using SyncIterators = SynchronousIterators<Iterators>;
+    Iterators x_begin(begin_in, out);
     Iterators x_end(end_in, OutputIterator());
     tbb::parallel_for(tbb::blocked_range<SyncIterators>(x_begin,
                                                         x_end,
@@ -241,10 +241,10 @@ namespace parallel
     for (OutputIterator in1 = begin_in1; in1 != end_in1;)
       *out++ = predicate(*in1++, *in2++);
 #else
-    typedef std::tuple<InputIterator1, InputIterator2, OutputIterator>
-                                            Iterators;
-    typedef SynchronousIterators<Iterators> SyncIterators;
-    Iterators                               x_begin(begin_in1, in2, out);
+    using Iterators =
+      std::tuple<InputIterator1, InputIterator2, OutputIterator>;
+    using SyncIterators = SynchronousIterators<Iterators>;
+    Iterators x_begin(begin_in1, in2, out);
     Iterators x_end(end_in1, InputIterator2(), OutputIterator());
     tbb::parallel_for(tbb::blocked_range<SyncIterators>(x_begin,
                                                         x_end,
@@ -301,12 +301,11 @@ namespace parallel
     for (OutputIterator in1 = begin_in1; in1 != end_in1;)
       *out++ = predicate(*in1++, *in2++, *in3++);
 #else
-    typedef std::
-      tuple<InputIterator1, InputIterator2, InputIterator3, OutputIterator>
-                                            Iterators;
-    typedef SynchronousIterators<Iterators> SyncIterators;
-    Iterators                               x_begin(begin_in1, in2, in3, out);
-    Iterators                               x_end(end_in1,
+    using Iterators = std::
+      tuple<InputIterator1, InputIterator2, InputIterator3, OutputIterator>;
+    using SyncIterators = SynchronousIterators<Iterators>;
+    Iterators x_begin(begin_in1, in2, in3, out);
+    Iterators x_end(end_in1,
                     InputIterator2(),
                     InputIterator3(),
                     OutputIterator());
index 8a2b497a0a1f9ada69323b301e1ee6f93f0996ec..8c8420c95d19cb998967fd0dda4e40f4bd9e507e 100644 (file)
@@ -144,7 +144,7 @@ namespace Functions
      *
      *  @code
      *
-     *  set Function expression = cos(pi*x) ; cos(pi*y)
+     *  set Function expression = cos(pi*x); cos(pi*y)
      *
      *  @endcode
      *
index b1d89298af285d1eef1e40382ca86da71bc87e13..c0451162cdb418317f3de4f39ee5f01b62e840f4 100644 (file)
@@ -197,7 +197,7 @@ private:
   /**
    * Type of values in the class maps.
    */
-  typedef std::map<std::string, std::vector<std::string>>::value_type map_type;
+  using map_type = std::map<std::string, std::vector<std::string>>::value_type;
 
   /**
    * Initialize the static list objects for further use.
index 4346f16eff48ec5fa6ef99dee601eab0512e9d03..a0fc0970398b13eed0f6a9b299343f6dab850b72 100644 (file)
@@ -732,7 +732,7 @@ namespace Patterns
    * or, if you want to exploit ParameterHandler::add_parameter():
    *
    * @code
-   * typedef std::tuple<std::string, Point<3>, unsigned int> T;
+   * using T = std::tuple<std::string, Point<3>, unsigned int>;
    *
    * T a = Patterns::Tools::Convert<T>::to_value("Ciao : 1.0, 2.0, 3.0 : 33");
    *
@@ -1203,7 +1203,7 @@ namespace Patterns
    * A typical usage of these tools is in the following example:
    *
    * @code
-   * typedef std::vector<unsigned int> T;
+   * using T = std::vector<unsigned int>;
    *
    * T vec(3);
    * vec[0] = 1;
@@ -1884,7 +1884,7 @@ namespace Patterns
     template <int rank, int dim, class Number>
     struct Convert<Tensor<rank, dim, Number>>
     {
-      typedef Tensor<rank, dim, Number> T;
+      using T = Tensor<rank, dim, Number>;
       static std::unique_ptr<Patterns::PatternBase>
       to_pattern()
       {
@@ -1951,7 +1951,7 @@ namespace Patterns
     template <int dim, class Number>
     struct Convert<Point<dim, Number>>
     {
-      typedef Point<dim, Number> T;
+      using T = Point<dim, Number>;
 
       static std::unique_ptr<Patterns::PatternBase>
       to_pattern()
@@ -1981,7 +1981,7 @@ namespace Patterns
     template <class Number>
     struct Convert<std::complex<Number>>
     {
-      typedef std::complex<Number> T;
+      using T = std::complex<Number>;
 
       static std::unique_ptr<Patterns::PatternBase>
       to_pattern()
@@ -2045,7 +2045,7 @@ namespace Patterns
     template <>
     struct Convert<std::string>
     {
-      typedef std::string T;
+      using T = std::string;
 
       static std::unique_ptr<Patterns::PatternBase>
       to_pattern()
@@ -2076,7 +2076,7 @@ namespace Patterns
     template <class Key, class Value>
     struct Convert<std::pair<Key, Value>>
     {
-      typedef std::pair<Key, Value> T;
+      using T = std::pair<Key, Value>;
 
       static std::unique_ptr<Patterns::PatternBase>
       to_pattern()
@@ -2121,7 +2121,7 @@ namespace Patterns
     template <class... Args>
     struct Convert<std::tuple<Args...>>
     {
-      typedef std::tuple<Args...> T;
+      using T = std::tuple<Args...>;
 
       static std::unique_ptr<Patterns::PatternBase>
       to_pattern()
index a13ba572cc90afd164558f0824b4bcabe88110ea..d767b4faa630cf32bf9c0cf7a40be6afc3dc48a4 100644 (file)
@@ -77,10 +77,10 @@ class QProjector
 {
 public:
   /**
-   * Define a typedef for a quadrature that acts on an object of one dimension
+   * Define an alias for a quadrature that acts on an object of one dimension
    * less. For cells, this would then be a face quadrature.
    */
-  typedef Quadrature<dim - 1> SubQuadrature;
+  using SubQuadrature = Quadrature<dim - 1>;
 
   /**
    * Compute the quadrature points on the cell if the given quadrature formula
index 56d08aa484feddda88b1f8104e1b0f056acdd6b0..25a919674f89fde61c75d49860e20f51d62b3a10 100644 (file)
@@ -86,10 +86,10 @@ class Quadrature : public Subscriptor
 {
 public:
   /**
-   * Define a typedef for a quadrature that acts on an object of one dimension
+   * Define an alias for a quadrature that acts on an object of one dimension
    * less. For cells, this would then be a face quadrature.
    */
-  typedef Quadrature<dim - 1> SubQuadrature;
+  using SubQuadrature = Quadrature<dim - 1>;
 
   /**
    * Constructor.
index 1c1c3cfddacdbeb6a9945c8a1db0c60a6d1ccb0c..2f1a2e2c163124fa27a02a23928899fd4ce81c1f 100644 (file)
@@ -351,10 +351,10 @@ namespace parallel
         "User's DataType class should be derived from TransferableQuadraturePointData");
 
       /**
-       * A typedef for a cell.
+       * An alias for a cell.
        */
-      typedef typename parallel::distributed::Triangulation<dim>::cell_iterator
-        CellIteratorType;
+      using CellIteratorType =
+        typename parallel::distributed::Triangulation<dim>::cell_iterator;
 
       /**
        * Constructor which takes the FiniteElement @p projection_fe , the quadrature
index d0fc3640f0a5ec39b91974fce5877f58f3f36b20..4a14c9ec4d70a278ad3b43e8a1d08dd4aa831e79 100644 (file)
@@ -187,12 +187,12 @@ private:
   /**
    * The data type used in #counter_map.
    */
-  typedef std::map<const char *, unsigned int>::value_type map_value_type;
+  using map_value_type = std::map<const char *, unsigned int>::value_type;
 
   /**
    * The iterator type used in #counter_map.
    */
-  typedef std::map<const char *, unsigned int>::iterator map_iterator;
+  using map_iterator = std::map<const char *, unsigned int>::iterator;
 
   /**
    * Store the number of objects which subscribed to this object. Initially,
index acf4714ed775758f495610dc91ffb73602441bdb..df45f4d3c4c79ed3c57049f21b23328a16e1bd01 100644 (file)
@@ -164,9 +164,9 @@ namespace internal
               typename OtherNumber = Number>
     struct double_contraction_result
     {
-      typedef typename ProductType<Number, OtherNumber>::type value_type;
-      typedef ::dealii::SymmetricTensor<rank1 + rank2 - 4, dim, value_type>
-        type;
+      using value_type = typename ProductType<Number, OtherNumber>::type;
+      using type =
+        ::dealii::SymmetricTensor<rank1 + rank2 - 4, dim, value_type>;
     };
 
 
@@ -181,13 +181,13 @@ namespace internal
     template <int dim, typename Number, typename OtherNumber>
     struct double_contraction_result<2, 2, dim, Number, OtherNumber>
     {
-      typedef typename ProductType<Number, OtherNumber>::type type;
+      using type = typename ProductType<Number, OtherNumber>::type;
     };
 
 
 
     /**
-     * Declaration of typedefs for the type of data structures which are used
+     * Declaration of alias for the type of data structures which are used
      * to store symmetric tensors. For example, for rank-2 symmetric tensors,
      * we use a flat vector to store all the elements. On the other hand,
      * symmetric rank-4 tensors are mappings from symmetric rank-2 tensors
@@ -217,7 +217,7 @@ namespace internal
       /**
        * Declare the type in which we actually store the data.
        */
-      typedef Tensor<1, n_independent_components, Number> base_tensor_type;
+      using base_tensor_type = Tensor<1, n_independent_components, Number>;
     };
 
 
@@ -248,7 +248,7 @@ namespace internal
        * can represent the data as a matrix if we represent the rank-2 tensors
        * as vectors.
        */
-      typedef Tensor<2, n_rank2_components, Number> base_tensor_type;
+      using base_tensor_type = Tensor<2, n_rank2_components, Number>;
     };
 
 
@@ -269,9 +269,9 @@ namespace internal
     template <int rank, int dim, typename Number>
     struct AccessorTypes<rank, dim, true, Number>
     {
-      typedef const ::dealii::SymmetricTensor<rank, dim, Number> tensor_type;
+      using tensor_type = const ::dealii::SymmetricTensor<rank, dim, Number>;
 
-      typedef Number reference;
+      using reference = Number;
     };
 
     /**
@@ -283,9 +283,9 @@ namespace internal
     template <int rank, int dim, typename Number>
     struct AccessorTypes<rank, dim, false, Number>
     {
-      typedef ::dealii::SymmetricTensor<rank, dim, Number> tensor_type;
+      using tensor_type = ::dealii::SymmetricTensor<rank, dim, Number>;
 
-      typedef Number &reference;
+      using reference = Number &;
     };
 
 
@@ -328,12 +328,12 @@ namespace internal
     {
     public:
       /**
-       * Import two typedefs from the switch class above.
+       * Import two alias from the switch class above.
        */
-      typedef typename AccessorTypes<rank, dim, constness, Number>::reference
-        reference;
-      typedef typename AccessorTypes<rank, dim, constness, Number>::tensor_type
-        tensor_type;
+      using reference =
+        typename AccessorTypes<rank, dim, constness, Number>::reference;
+      using tensor_type =
+        typename AccessorTypes<rank, dim, constness, Number>::tensor_type;
 
     private:
       /**
@@ -411,12 +411,12 @@ namespace internal
     {
     public:
       /**
-       * Import two typedefs from the switch class above.
+       * Import two alias from the switch class above.
        */
-      typedef typename AccessorTypes<rank, dim, constness, Number>::reference
-        reference;
-      typedef typename AccessorTypes<rank, dim, constness, Number>::tensor_type
-        tensor_type;
+      using reference =
+        typename AccessorTypes<rank, dim, constness, Number>::reference;
+      using tensor_type =
+        typename AccessorTypes<rank, dim, constness, Number>::tensor_type;
 
     private:
       /**
@@ -883,13 +883,13 @@ private:
   /**
    * A structure that describes properties of the base tensor.
    */
-  typedef internal::SymmetricTensorAccessors::StorageType<rank_, dim, Number>
-    base_tensor_descriptor;
+  using base_tensor_descriptor =
+    internal::SymmetricTensorAccessors::StorageType<rank_, dim, Number>;
 
   /**
    * Data storage type for a symmetric tensor.
    */
-  typedef typename base_tensor_descriptor::base_tensor_type base_tensor_type;
+  using base_tensor_type = typename base_tensor_descriptor::base_tensor_type;
 
   /**
    * The place where we store the data of the tensor.
@@ -1575,9 +1575,8 @@ namespace internal
       const typename SymmetricTensorAccessors::
         StorageType<2, dim, OtherNumber>::base_tensor_type &sdata)
   {
-    typedef typename SymmetricTensorAccessors::
-      double_contraction_result<2, 2, dim, Number, OtherNumber>::type
-        result_type;
+    using result_type = typename SymmetricTensorAccessors::
+      double_contraction_result<2, 2, dim, Number, OtherNumber>::type;
 
     switch (dim)
       {
@@ -1610,12 +1609,10 @@ namespace internal
       const typename SymmetricTensorAccessors::
         StorageType<2, dim, OtherNumber>::base_tensor_type &sdata)
   {
-    typedef typename SymmetricTensorAccessors::
-      double_contraction_result<4, 2, dim, Number, OtherNumber>::type
-        result_type;
-    typedef typename SymmetricTensorAccessors::
-      double_contraction_result<4, 2, dim, Number, OtherNumber>::value_type
-        value_type;
+    using result_type = typename SymmetricTensorAccessors::
+      double_contraction_result<4, 2, dim, Number, OtherNumber>::type;
+    using value_type = typename SymmetricTensorAccessors::
+      double_contraction_result<4, 2, dim, Number, OtherNumber>::value_type;
 
     const unsigned int data_dim = SymmetricTensorAccessors::
       StorageType<2, dim, value_type>::n_independent_components;
@@ -1641,11 +1638,10 @@ namespace internal
       const typename SymmetricTensorAccessors::
         StorageType<4, dim, OtherNumber>::base_tensor_type &sdata)
   {
-    typedef typename SymmetricTensorAccessors::
-      double_contraction_result<2, 4, dim, Number, OtherNumber>::value_type
-        value_type;
-    typedef typename SymmetricTensorAccessors::StorageType<2, dim, value_type>::
-      base_tensor_type base_tensor_type;
+    using value_type = typename SymmetricTensorAccessors::
+      double_contraction_result<2, 4, dim, Number, OtherNumber>::value_type;
+    using base_tensor_type = typename SymmetricTensorAccessors::
+      StorageType<2, dim, value_type>::base_tensor_type;
 
     base_tensor_type tmp;
     for (unsigned int i = 0; i < tmp.dimension; ++i)
@@ -1679,11 +1675,10 @@ namespace internal
       const typename SymmetricTensorAccessors::
         StorageType<4, dim, OtherNumber>::base_tensor_type &sdata)
   {
-    typedef typename SymmetricTensorAccessors::
-      double_contraction_result<4, 4, dim, Number, OtherNumber>::value_type
-        value_type;
-    typedef typename SymmetricTensorAccessors::StorageType<4, dim, value_type>::
-      base_tensor_type base_tensor_type;
+    using value_type = typename SymmetricTensorAccessors::
+      double_contraction_result<4, 4, dim, Number, OtherNumber>::value_type;
+    using base_tensor_type = typename SymmetricTensorAccessors::
+      StorageType<4, dim, value_type>::base_tensor_type;
 
     const unsigned int data_dim = SymmetricTensorAccessors::
       StorageType<2, dim, value_type>::n_independent_components;
@@ -3091,7 +3086,7 @@ namespace internal
     template <int dim, typename Number>
     struct SortEigenValuesVectors
     {
-      typedef std::pair<Number, Tensor<1, dim, Number>> EigValsVecs;
+      using EigValsVecs = std::pair<Number, Tensor<1, dim, Number>>;
       bool
       operator()(const EigValsVecs &lhs, const EigValsVecs &rhs)
       {
@@ -3605,8 +3600,8 @@ operator*(const SymmetricTensor<rank_, dim, Number> &t,
   // standard committee saw it fit to not define an
   //   operator*(float,std::complex<double>)
   // (as well as with switched arguments and double<->float).
-  typedef typename ProductType<Number, OtherNumber>::type product_type;
-  SymmetricTensor<rank_, dim, product_type>               tt(t);
+  using product_type = typename ProductType<Number, OtherNumber>::type;
+  SymmetricTensor<rank_, dim, product_type> tt(t);
   // we used to shorten the following by 'tt *= product_type(factor);'
   // which requires that a converting constructor
   // 'product_type::product_type(const OtherNumber) is defined.
index a714d2ead5ce579d6bcd08025e0d526ba8046bbf..0ae1530fe5a3f3f3f0a348bd446778f258e7af70 100644 (file)
@@ -98,7 +98,7 @@ eigenvalues(const SymmetricTensor<2, 3, Number> &T)
       // and p = (tr((T - q.I)^{2})/6)^{1/2} . Then solve the equation
       // 0 = det(\lambda*I - B) = \lambda^{3} - 3*\lambda - det(B)
       // which has the solution
-      // \lambda = 2*cos(1/3 * acos(det(B)/2) +2/3*pi*k ) ; k = 0,1,2
+      // \lambda = 2*cos(1/3 * acos(det(B)/2) +2/3*pi*k ); k = 0,1,2
       // when substituting  \lambda = 2.cos(theta) and using trig identities.
       const Number tr_T = trace(T);
       const Number q    = tr_T / 3.0;
@@ -918,9 +918,8 @@ eigenvectors(const SymmetricTensor<2, dim, Number> &T,
                 AssertThrow(false, ExcNotImplemented());
             }
 
-          typedef
-            typename Differentiation::AD::ADNumberTraits<Number>::scalar_type
-                       scalar_type;
+          using scalar_type =
+            typename Differentiation::AD::ADNumberTraits<Number>::scalar_type;
           const double delta = sf * std::numeric_limits<scalar_type>::epsilon();
           const double rotation_angle = delta * numbers::PI / 180.0;
 
index b614862d24bfd465ef0e51c384694ca4384e9513..8e07b8eb277d7cf6dc29ceb7f87f267044c8c6fb 100644 (file)
@@ -73,7 +73,7 @@ namespace internal
   namespace TableBaseAccessors
   {
     /**
-     * @internal Have a class which declares some nested typedefs, depending
+     * @internal Have a class which declares some nested alias, depending
      * on its template parameters. The general template declares nothing, but
      * there are more useful specializations regarding the last parameter
      * indicating constness of the table for which accessor objects are to be
@@ -84,39 +84,39 @@ namespace internal
     {};
 
     /**
-     * @internal Have a class which declares some nested typedefs, depending
+     * @internal Have a class which declares some nested alias, depending
      * on its template parameters. Specialization for accessors to constant
      * objects.
      */
     template <int N, typename T>
     struct Types<N, T, true>
     {
-      typedef const T               value_type;
-      typedef const TableBase<N, T> TableType;
+      using value_type = const T;
+      using TableType  = const TableBase<N, T>;
 
-      typedef typename AlignedVector<T>::const_iterator iterator;
-      typedef typename AlignedVector<T>::const_iterator const_iterator;
+      using iterator       = typename AlignedVector<T>::const_iterator;
+      using const_iterator = typename AlignedVector<T>::const_iterator;
 
-      typedef typename AlignedVector<T>::const_reference reference;
-      typedef typename AlignedVector<T>::const_reference const_reference;
+      using reference       = typename AlignedVector<T>::const_reference;
+      using const_reference = typename AlignedVector<T>::const_reference;
     };
 
     /**
-     * @internal Have a class which declares some nested typedefs, depending
+     * @internal Have a class which declares some nested alias, depending
      * on its template parameters. Specialization for accessors to non-
      * constant objects.
      */
     template <int N, typename T>
     struct Types<N, T, false>
     {
-      typedef T               value_type;
-      typedef TableBase<N, T> TableType;
+      using value_type = T;
+      using TableType  = TableBase<N, T>;
 
-      typedef typename AlignedVector<T>::iterator       iterator;
-      typedef typename AlignedVector<T>::const_iterator const_iterator;
+      using iterator       = typename AlignedVector<T>::iterator;
+      using const_iterator = typename AlignedVector<T>::const_iterator;
 
-      typedef typename AlignedVector<T>::reference       reference;
-      typedef typename AlignedVector<T>::const_reference const_reference;
+      using reference       = typename AlignedVector<T>::reference;
+      using const_reference = typename AlignedVector<T>::const_reference;
     };
 
 
@@ -162,13 +162,13 @@ namespace internal
     class Accessor
     {
     public:
-      typedef typename Types<N, T, C>::TableType TableType;
+      using TableType = typename Types<N, T, C>::TableType;
 
-      typedef typename Types<N, T, C>::iterator       iterator;
-      typedef typename Types<N, T, C>::const_iterator const_iterator;
+      using iterator       = typename Types<N, T, C>::iterator;
+      using const_iterator = typename Types<N, T, C>::const_iterator;
 
-      typedef size_t    size_type;
-      typedef ptrdiff_t difference_type;
+      using size_type       = size_t;
+      using difference_type = ptrdiff_t;
 
     private:
       /**
@@ -253,21 +253,21 @@ namespace internal
        * this row, as well as all the other types usually required for the
        * standard library algorithms.
        */
-      typedef typename Types<N, T, C>::value_type value_type;
+      using value_type = typename Types<N, T, C>::value_type;
 
-      typedef typename Types<N, T, C>::iterator       iterator;
-      typedef typename Types<N, T, C>::const_iterator const_iterator;
+      using iterator       = typename Types<N, T, C>::iterator;
+      using const_iterator = typename Types<N, T, C>::const_iterator;
 
-      typedef typename Types<N, T, C>::reference       reference;
-      typedef typename Types<N, T, C>::const_reference const_reference;
+      using reference       = typename Types<N, T, C>::reference;
+      using const_reference = typename Types<N, T, C>::const_reference;
 
-      typedef size_t    size_type;
-      typedef ptrdiff_t difference_type;
+      using size_type       = size_t;
+      using difference_type = ptrdiff_t;
 
       /**
-       * Import a typedef from the switch class above.
+       * Import an alias from the switch class above.
        */
-      typedef typename Types<N, T, C>::TableType TableType;
+      using TableType = typename Types<N, T, C>::TableType;
 
     private:
       /**
@@ -421,12 +421,12 @@ template <int N, typename T>
 class TableBase : public Subscriptor
 {
 public:
-  typedef T value_type;
+  using value_type = T;
 
   /**
    * Integer type used to count the number of elements in this container.
    */
-  typedef typename AlignedVector<T>::size_type size_type;
+  using size_type = typename AlignedVector<T>::size_type;
 
 
   /**
@@ -730,7 +730,7 @@ public:
   /**
    * Integer type used to count the number of elements in this container.
    */
-  typedef typename TableBase<1, T>::size_type size_type;
+  using size_type = typename TableBase<1, T>::size_type;
 
   /**
    * Default constructor. Set all dimensions to zero.
@@ -848,7 +848,7 @@ public:
   /**
    * Integer type used to count the number of elements in this container.
    */
-  typedef typename TableBase<2, T>::size_type size_type;
+  using size_type = typename TableBase<2, T>::size_type;
 
   /**
    * Default constructor. Set all dimensions to zero.
@@ -1033,7 +1033,7 @@ public:
   /**
    * Integer type used to count the number of elements in this container.
    */
-  typedef typename TableBase<3, T>::size_type size_type;
+  using size_type = typename TableBase<3, T>::size_type;
 
   /**
    * Default constructor. Set all dimensions to zero.
@@ -1165,7 +1165,7 @@ public:
   /**
    * Integer type used to count the number of elements in this container.
    */
-  typedef typename TableBase<4, T>::size_type size_type;
+  using size_type = typename TableBase<4, T>::size_type;
 
   /**
    * Default constructor. Set all dimensions to zero.
@@ -1259,7 +1259,7 @@ public:
   /**
    * Integer type used to count the number of elements in this container.
    */
-  typedef typename TableBase<5, T>::size_type size_type;
+  using size_type = typename TableBase<5, T>::size_type;
 
 
   /**
@@ -1356,7 +1356,7 @@ public:
   /**
    * Integer type used to count the number of elements in this container.
    */
-  typedef typename TableBase<6, T>::size_type size_type;
+  using size_type = typename TableBase<6, T>::size_type;
 
   /**
    * Default constructor. Set all dimensions to zero.
@@ -1454,7 +1454,7 @@ public:
   /**
    * Integer type used to count the number of elements in this container.
    */
-  typedef typename TableBase<7, T>::size_type size_type;
+  using size_type = typename TableBase<7, T>::size_type;
 
   /**
    * Default constructor. Set all dimensions to zero.
@@ -1567,10 +1567,10 @@ namespace TransposeTableIterators
     /**
      * Type of the stored pointer to the TransposeTable.
      */
-    typedef typename std::conditional<Constness,
-                                      const TransposeTable<T> *,
-                                      TransposeTable<T> *>::type
-      container_pointer_type;
+    using container_pointer_type =
+      typename std::conditional<Constness,
+                                const TransposeTable<T> *,
+                                TransposeTable<T> *>::type;
 
     /**
      * Default constructor.
@@ -1604,7 +1604,7 @@ namespace TransposeTableIterators
     /**
      * Numerical type of the row and column indices of the TransposeTable.
      */
-    typedef typename TransposeTable<T>::size_type size_type;
+    using size_type = typename TransposeTable<T>::size_type;
 
     /**
      * Access the row of the current entry.
@@ -1706,15 +1706,15 @@ namespace TransposeTableIterators
     /**
      * Size type used by TransposeTable.
      */
-    typedef typename TransposeTable<T>::size_type size_type;
+    using size_type = typename TransposeTable<T>::size_type;
 
     /**
      * Type of the stored pointer to the TransposeTable.
      */
-    typedef typename std::conditional<Constness,
-                                      const TransposeTable<T> *,
-                                      TransposeTable<T> *>::type
-      container_pointer_type;
+    using container_pointer_type =
+      typename std::conditional<Constness,
+                                const TransposeTable<T> *,
+                                TransposeTable<T> *>::type;
 
     /**
      * Constructor from an accessor.
@@ -1767,33 +1767,33 @@ public:
   /**
    * Integer type used to count the number of elements in this container.
    */
-  typedef typename TableBase<2, T>::size_type size_type;
+  using size_type = typename TableBase<2, T>::size_type;
 
   /**
    * Typedef for the values in the table.
    */
-  typedef typename AlignedVector<T>::value_type value_type;
+  using value_type = typename AlignedVector<T>::value_type;
 
   /**
    * Typedef for the references in the table.
    */
-  typedef typename AlignedVector<T>::reference reference;
+  using reference = typename AlignedVector<T>::reference;
 
   /**
    * Typedef for the constant references in the table.
    */
-  typedef typename AlignedVector<T>::const_reference const_reference;
+  using const_reference = typename AlignedVector<T>::const_reference;
 
   /**
    * Typedef for a constant iterator that traverses the table in column-major
    * order.
    */
-  typedef TransposeTableIterators::Iterator<T, true> const_iterator;
+  using const_iterator = TransposeTableIterators::Iterator<T, true>;
 
   /**
    * Typedef for an iterator that traverses the table in column-major order.
    */
-  typedef TransposeTableIterators::Iterator<T, false> iterator;
+  using iterator = TransposeTableIterators::Iterator<T, false>;
 
   /**
    * Default constructor. Set all dimensions to zero.
index 7a9170c180155d0878f092c65732568f0cca4d9f..2b59adef94d3b41eeaa4d062e98a2c482fec7b14 100644 (file)
@@ -130,9 +130,8 @@ namespace internal
     /**
      * Abbreviation for the data type stored by this object.
      */
-    typedef boost::
-      variant<int, unsigned int, unsigned long long int, double, std::string>
-        value_type;
+    using value_type = boost::
+      variant<int, unsigned int, unsigned long long int, double, std::string>;
 
     /**
      * Stored value.
index 8f52da6edf4789d5f5ad36635ca81cea529503ff..bf2d314c9040255073a7863b5335cf9206034417 100644 (file)
@@ -97,7 +97,7 @@ struct constraint_and_return_value;
 
 /**
  * This specialization of the general template for the case of a <tt>true</tt>
- * first template argument declares a local typedef <tt>type</tt> to the
+ * first template argument declares a local alias <tt>type</tt> to the
  * second template argument. It is used in order to construct constraints on
  * template arguments in template (and member template) functions. The
  * negative specialization is missing.
@@ -124,7 +124,7 @@ struct constraint_and_return_value;
  * @code
  *   template <bool, typename> struct constraint_and_return_value;
  *   template <typename T> struct constraint_and_return_value<true,T> {
- *     typedef T type;
+ *     using type = T;
  *   };
  * @endcode
  * constraint_and_return_value<false,T> is not defined. Given something like
@@ -155,14 +155,14 @@ struct constraint_and_return_value;
 template <typename T>
 struct DEAL_II_DEPRECATED constraint_and_return_value<true, T>
 {
-  typedef T type;
+  using type = T;
 };
 
 
 
 /**
  * A template class that simply exports its template argument as a local
- * typedef. This class, while at first appearing useless, makes sense in the
+ * alias. This class, while at first appearing useless, makes sense in the
  * following context: if you have a function template as follows:
  * @code
  *   template <typename T> void f(T, T);
@@ -214,7 +214,7 @@ struct DEAL_II_DEPRECATED constraint_and_return_value<true, T>
 template <typename T>
 struct identity
 {
-  typedef T type;
+  using type = T;
 };
 
 
@@ -390,7 +390,7 @@ namespace internal
   template <typename T, typename U>
   struct ProductTypeImpl
   {
-    typedef decltype(std::declval<T>() * std::declval<U>()) type;
+    using type = decltype(std::declval<T>() * std::declval<U>());
   };
 
 } // namespace internal
@@ -398,7 +398,7 @@ namespace internal
 
 
 /**
- * A class with a local typedef that represents the type that results from the
+ * A class with a local alias that represents the type that results from the
  * product of two variables of type @p T and @p U. In other words, we would
  * like to infer the type of the <code>product</code> variable in code like
  * this:
@@ -407,7 +407,7 @@ namespace internal
  *   U u;
  *   auto product = t*u;
  * @endcode
- * The local typedef of this structure represents the type the variable
+ * The local alias of this structure represents the type the variable
  * <code>product</code> would have.
  *
  *
@@ -448,9 +448,9 @@ namespace internal
 template <typename T, typename U>
 struct ProductType
 {
-  typedef
+  using type =
     typename internal::ProductTypeImpl<typename std::decay<T>::type,
-                                       typename std::decay<U>::type>::type type;
+                                       typename std::decay<U>::type>::type;
 };
 
 namespace internal
@@ -463,37 +463,37 @@ namespace internal
   template <typename T>
   struct ProductTypeImpl<std::complex<T>, std::complex<T>>
   {
-    typedef std::complex<T> type;
+    using type = std::complex<T>;
   };
 
   template <typename T, typename U>
   struct ProductTypeImpl<std::complex<T>, std::complex<U>>
   {
-    typedef std::complex<typename ProductType<T, U>::type> type;
+    using type = std::complex<typename ProductType<T, U>::type>;
   };
 
   template <typename U>
   struct ProductTypeImpl<double, std::complex<U>>
   {
-    typedef std::complex<typename ProductType<double, U>::type> type;
+    using type = std::complex<typename ProductType<double, U>::type>;
   };
 
   template <typename T>
   struct ProductTypeImpl<std::complex<T>, double>
   {
-    typedef std::complex<typename ProductType<T, double>::type> type;
+    using type = std::complex<typename ProductType<T, double>::type>;
   };
 
   template <typename U>
   struct ProductTypeImpl<float, std::complex<U>>
   {
-    typedef std::complex<typename ProductType<float, U>::type> type;
+    using type = std::complex<typename ProductType<float, U>::type>;
   };
 
   template <typename T>
   struct ProductTypeImpl<std::complex<T>, float>
   {
-    typedef std::complex<typename ProductType<T, float>::type> type;
+    using type = std::complex<typename ProductType<T, float>::type>;
   };
 
 } // namespace internal
@@ -501,12 +501,12 @@ namespace internal
 
 
 /**
- * This class provides a local typedef @p type that is equal to the template
+ * This class provides a local alias @p type that is equal to the template
  * argument but only if the template argument corresponds to a scalar type
  * (i.e., one of the floating point types, signed or unsigned integer, or a
  * complex number). If the template type @p T is not a scalar, then no class
  * <code>EnableIfScalar@<T@></code> is declared and, consequently, no local
- * typedef is available.
+ * alias is available.
  *
  * The purpose of the class is to disable certain template functions if one of
  * the arguments is not a scalar number. By way of (nonsensical) example,
@@ -558,37 +558,37 @@ struct EnableIfScalar;
 template <>
 struct EnableIfScalar<double>
 {
-  typedef double type;
+  using type = double;
 };
 
 template <>
 struct EnableIfScalar<float>
 {
-  typedef float type;
+  using type = float;
 };
 
 template <>
 struct EnableIfScalar<long double>
 {
-  typedef long double type;
+  using type = long double;
 };
 
 template <>
 struct EnableIfScalar<int>
 {
-  typedef int type;
+  using type = int;
 };
 
 template <>
 struct EnableIfScalar<unsigned int>
 {
-  typedef unsigned int type;
+  using type = unsigned int;
 };
 
 template <typename T>
 struct EnableIfScalar<std::complex<T>>
 {
-  typedef std::complex<T> type;
+  using type = std::complex<T>;
 };
 
 
index cd9eb8a02f9394d5a2493577c7a492d6f00e7b71..1b3b06a06ea2bf34dd64b0fdd33e38bfaa9b20f9 100644 (file)
@@ -120,22 +120,22 @@ public:
    * corresponds to type number, and it is equal to Number for all other
    * cases. See also the respective field in Vector<Number>.
    *
-   * This typedef is used to represent the return type of norms.
+   * This alias is used to represent the return type of norms.
    */
-  typedef typename numbers::NumberTraits<Number>::real_type real_type;
+  using real_type = typename numbers::NumberTraits<Number>::real_type;
 
   /**
    * Type of objects encapsulated by this container and returned by
    * operator[](). This is a scalar number type for a rank 0 tensor.
    */
-  typedef Number value_type;
+  using value_type = Number;
 
   /**
    * Declare an array type which can be used to initialize an object of this
    * type statically. In case of a tensor of rank 0 this is just the scalar
    * number type Number.
    */
-  typedef Number array_type;
+  using array_type = Number;
 
   /**
    * Constructor. Set to zero.
@@ -327,7 +327,7 @@ public:
    * Internal type declaration that is used to specialize the return type of
    * operator[]() for Tensor<1,dim,Number>
    */
-  typedef Number tensor_type;
+  using tensor_type = Number;
 
 private:
   /**
@@ -424,16 +424,14 @@ public:
    * operator[](). This is a tensor of lower rank for a general tensor, and a
    * scalar number type for Tensor<1,dim,Number>.
    */
-  typedef typename Tensor<rank_ - 1, dim, Number>::tensor_type value_type;
+  using value_type = typename Tensor<rank_ - 1, dim, Number>::tensor_type;
 
   /**
    * Declare an array type which can be used to initialize an object of this
-   * type statically.
+   * type statically. For `dim == 0`, its size is 1. Otherwise, it is `dim`.
    */
-  typedef typename Tensor<rank_ - 1, dim, Number>::array_type
-    array_type[(dim != 0) ? dim : 1];
-  // ... avoid a compiler warning in case of dim == 0 and ensure that the
-  // array always has positive size.
+  using array_type =
+    typename Tensor<rank_ - 1, dim, Number>::array_type[(dim != 0) ? dim : 1];
 
   /**
    * Constructor. Initialize all entries to zero.
@@ -664,7 +662,7 @@ public:
    * Internal type declaration that is used to specialize the return type of
    * operator[]() for Tensor<1,dim,Number>
    */
-  typedef Tensor<rank_, dim, Number> tensor_type;
+  using tensor_type = Tensor<rank_, dim, Number>;
 
 private:
   /**
@@ -1962,8 +1960,8 @@ contract3(const TensorT1<rank_1, dim, T1> &         left,
           const TensorT2<rank_1 + rank_2, dim, T2> &middle,
           const TensorT3<rank_2, dim, T3> &         right)
 {
-  typedef typename ProductType<T1, typename ProductType<T2, T3>::type>::type
-    return_type;
+  using return_type =
+    typename ProductType<T1, typename ProductType<T2, T3>::type>::type;
   return TensorAccessors::contract3<rank_1, rank_2, dim, return_type>(left,
                                                                       middle,
                                                                       right);
index e07cc04c836542d5a7336997ce056c633faabd41..f8efb0e1f290c0c2ba3fcb23f37d1bf539de4ed5 100644 (file)
@@ -49,14 +49,14 @@ DEAL_II_NAMESPACE_OPEN
  * The methods and algorithms implemented in this namespace, however, are
  * fully generic. More precisely, it can operate on nested c-style arrays, or
  * on class types <code>T</code> with a minimal interface that provides a
- * local typedef <code>value_type</code> and an index operator
+ * local alias <code>value_type</code> and an index operator
  * <code>operator[](unsigned int)</code> that returns a (const or non-const)
  * reference of <code>value_type</code>:
  * @code
  *   template <...>
  *   class T
  *   {
- *     typedef ... value_type;
+ *     using value_type = ...;
  *     value_type & operator[](unsigned int);
  *     const value_type & operator[](unsigned int) const;
  *   };
@@ -86,16 +86,16 @@ namespace TensorAccessors
 
 
   /**
-   * This class provides a local typedef @p value_type denoting the resulting
+   * This class provides a local alias @p value_type denoting the resulting
    * type of an access with operator[](unsigned int). More precisely, @p
    * value_type will be
-   *  - <code>T::value_type</code> if T is a tensorial class providing a
-   * typedef <code>value_type</code> and does not have a const qualifier.
+   *  - <code>T::value_type</code> if T is a tensorial class providing an
+   * alias <code>value_type</code> and does not have a const qualifier.
    *  - <code>const T::value_type</code> if T is a tensorial class
-   * providing a typedef <code>value_type</code> and does have a const
+   * providing an alias <code>value_type</code> and does have a const
    * qualifier.
    *  - <code>const T::value_type</code> if T is a tensorial class
-   * providing a typedef <code>value_type</code> and does have a const
+   * providing an alias <code>value_type</code> and does have a const
    * qualifier.
    *  - <code>A</code> if T is of array type <code>A[...]</code>
    *  - <code>const A</code> if T is of array type <code>A[...]</code> and
@@ -104,31 +104,31 @@ namespace TensorAccessors
   template <typename T>
   struct ValueType
   {
-    typedef typename T::value_type value_type;
+    using value_type = typename T::value_type;
   };
 
   template <typename T>
   struct ValueType<const T>
   {
-    typedef const typename T::value_type value_type;
+    using value_type = const typename T::value_type;
   };
 
   template <typename T, std::size_t N>
   struct ValueType<T[N]>
   {
-    typedef T value_type;
+    using value_type = T;
   };
 
   template <typename T, std::size_t N>
   struct ValueType<const T[N]>
   {
-    typedef const T value_type;
+    using value_type = const T;
   };
 
 
   /**
-   * This class provides a local typedef @p value_type that is equal to the
-   * typedef <code>value_type</code> after @p deref_steps recursive
+   * This class provides a local alias @p value_type that is equal to the
+   * alias <code>value_type</code> after @p deref_steps recursive
    * dereferences via ```operator[](unsigned int)```. Further, constness is
    * preserved via the ValueType type trait, i.e., if T is const,
    * ReturnType<rank, T>::value_type will also be const.
@@ -136,15 +136,15 @@ namespace TensorAccessors
   template <int deref_steps, typename T>
   struct ReturnType
   {
-    typedef typename ReturnType<deref_steps - 1,
-                                typename ValueType<T>::value_type>::value_type
-      value_type;
+    using value_type =
+      typename ReturnType<deref_steps - 1,
+                          typename ValueType<T>::value_type>::value_type;
   };
 
   template <typename T>
   struct ReturnType<0, T>
   {
-    typedef T value_type;
+    using value_type = T;
   };
 
 
@@ -174,14 +174,14 @@ namespace TensorAccessors
    * tensors.
    *
    * @note This function returns an internal class object consisting of an
-   * array subscript operator <code>operator[](unsigned int)</code> and a
-   * typedef <code>value_type</code> describing its return value.
+   * array subscript operator <code>operator[](unsigned int)</code> and an
+   * alias <code>value_type</code> describing its return value.
    *
    * @tparam index The index to be shifted to the end. Indices are counted
    * from 0, thus the valid range is $0\le\text{index}<\text{rank}$.
    * @tparam rank Rank of the tensorial object @p t
    * @tparam T A tensorial object of rank @p rank. @p T must provide a local
-   * typedef <code>value_type</code> and an index operator
+   * alias <code>value_type</code> and an index operator
    * <code>operator[]()</code> that returns a (const or non-const) reference
    * of <code>value_type</code>.
    *
@@ -209,7 +209,7 @@ namespace TensorAccessors
    * This is equivalent to <code>tensor[0][1][2][3][4] = 42.</code>.
    *
    * @tparam T A tensorial object of rank @p rank. @p T must provide a local
-   * typedef <code>value_type</code> and an index operator
+   * alias <code>value_type</code> and an index operator
    * <code>operator[]()</code> that returns a (const or non-const) reference
    * of <code>value_type</code>. Further, its tensorial rank must be equal or
    * greater than @p rank.
@@ -361,19 +361,19 @@ namespace TensorAccessors
     template <typename T>
     struct ReferenceType
     {
-      typedef T &type;
+      using type = T &;
     };
 
     template <int rank, typename S>
     struct ReferenceType<StoreIndex<rank, S>>
     {
-      typedef StoreIndex<rank, S> type;
+      using type = StoreIndex<rank, S>;
     };
 
     template <int index, int rank, typename T>
     struct ReferenceType<ReorderedIndexView<index, rank, T>>
     {
-      typedef ReorderedIndexView<index, rank, T> type;
+      using type = ReorderedIndexView<index, rank, T>;
     };
 
 
@@ -413,10 +413,9 @@ namespace TensorAccessors
         : t_(t)
       {}
 
-      typedef ReorderedIndexView<index - 1,
-                                 rank - 1,
-                                 typename ValueType<T>::value_type>
-        value_type;
+      using value_type = ReorderedIndexView<index - 1,
+                                            rank - 1,
+                                            typename ValueType<T>::value_type>;
 
       // Recurse by applying index j directly:
       inline DEAL_II_ALWAYS_INLINE value_type operator[](unsigned int j) const
@@ -447,7 +446,7 @@ namespace TensorAccessors
         : t_(t)
       {}
 
-      typedef StoreIndex<rank - 1, internal::Identity<T>> value_type;
+      using value_type = StoreIndex<rank - 1, internal::Identity<T>>;
 
       inline DEAL_II_ALWAYS_INLINE value_type operator[](unsigned int j) const
       {
@@ -469,8 +468,8 @@ namespace TensorAccessors
         : t_(t)
       {}
 
-      typedef typename ReferenceType<typename ValueType<T>::value_type>::type
-        value_type;
+      using value_type =
+        typename ReferenceType<typename ValueType<T>::value_type>::type;
 
       inline DEAL_II_ALWAYS_INLINE value_type operator[](unsigned int j) const
       {
@@ -494,7 +493,7 @@ namespace TensorAccessors
         : t_(t)
       {}
 
-      typedef typename ValueType<T>::value_type return_type;
+      using return_type = typename ValueType<T>::value_type;
 
       inline DEAL_II_ALWAYS_INLINE typename ReferenceType<return_type>::type
       apply(unsigned int j) const
@@ -523,15 +522,15 @@ namespace TensorAccessors
         , i_(i)
       {}
 
-      typedef StoreIndex<rank - 1, StoreIndex<rank, S>> value_type;
+      using value_type = StoreIndex<rank - 1, StoreIndex<rank, S>>;
 
       inline DEAL_II_ALWAYS_INLINE value_type operator[](unsigned int j) const
       {
         return value_type(*this, j);
       }
 
-      typedef
-        typename ValueType<typename S::return_type>::value_type return_type;
+      using return_type =
+        typename ValueType<typename S::return_type>::value_type;
 
       inline typename ReferenceType<return_type>::type
       apply(unsigned int j) const
@@ -557,9 +556,9 @@ namespace TensorAccessors
         , i_(i)
       {}
 
-      typedef
-        typename ValueType<typename S::return_type>::value_type return_type;
-      typedef return_type                                       value_type;
+      using return_type =
+        typename ValueType<typename S::return_type>::value_type;
+      using value_type = return_type;
 
       inline DEAL_II_ALWAYS_INLINE return_type &operator[](unsigned int j) const
       {
index 9133f4b3faa76b102305d6a11fdab8b619d7ed4a..8b80dae6ca36021fc675076c39ccf96f813e68cc 100644 (file)
@@ -58,11 +58,11 @@ class TensorFunction : public FunctionTime<Number>, public Subscriptor
 {
 public:
   /**
-   * Define typedefs for the return types of the <tt>value</tt> functions.
+   * Define alias for the return types of the <tt>value</tt> functions.
    */
-  typedef Tensor<rank, dim, Number> value_type;
+  using value_type = Tensor<rank, dim, Number>;
 
-  typedef Tensor<rank + 1, dim, Number> gradient_type;
+  using gradient_type = Tensor<rank + 1, dim, Number>;
 
   /**
    * Constructor. May take an initial value for the time variable, which
index 7b4171499fe411d6b0b19e2f9105325c9b961804..21cb8cd7479de9064daa344e4a654b956c22cfb0 100644 (file)
@@ -474,7 +474,7 @@ namespace Threads
    * If using POSIX functions, then alias the POSIX wrapper classes to the
    * names we use throughout the library.
    */
-  typedef PosixThreadBarrier Barrier;
+  using Barrier = PosixThreadBarrier;
 
 #  else
   /**
@@ -482,21 +482,21 @@ namespace Threads
    * aliased to dummy classes that actually do nothing, in particular not lock
    * objects. Likewise for the barrier class.
    */
-  typedef DummyThreadMutex Mutex;
+  using Mutex = DummyThreadMutex;
 
   /**
    * In non-multithread mode, the mutex and thread management classes are
    * aliased to dummy classes that actually do nothing, in particular not lock
    * objects. Likewise for the barrier class.
    */
-  typedef DummyThreadCondition ConditionVariable;
+  using ConditionVariable = DummyThreadCondition;
 
   /**
    * In non-multithread mode, the mutex and thread management classes are
    * aliased to dummy classes that actually do nothing, in particular not lock
    * objects. Likewise for the barrier class.
    */
-  typedef DummyBarrier Barrier;
+  using Barrier = DummyBarrier;
 #  endif
 
 } // namespace Threads
@@ -661,7 +661,7 @@ namespace Threads
               const ForwardIterator &end,
               const unsigned int     n_intervals)
   {
-    typedef std::pair<ForwardIterator, ForwardIterator> IteratorPair;
+    using IteratorPair = std::pair<ForwardIterator, ForwardIterator>;
 
     // in non-multithreaded mode, we often have the case that this
     // function is called with n_intervals==1, so have a shortcut here
@@ -724,7 +724,7 @@ namespace Threads
       RT value;
 
     public:
-      typedef RT &reference_type;
+      using reference_type = RT &;
 
       inline return_value()
         : value()
@@ -760,7 +760,7 @@ namespace Threads
       RT *value;
 
     public:
-      typedef RT &reference_type;
+      using reference_type = RT &;
 
       inline return_value()
         : value(nullptr)
@@ -791,7 +791,7 @@ namespace Threads
     template <>
     struct return_value<void>
     {
-      typedef void reference_type;
+      using reference_type = void;
 
       static inline void
       get()
@@ -1280,7 +1280,7 @@ namespace Threads
   new_thread(FunctionObjectType function_object)
     -> Thread<decltype(function_object())>
   {
-    typedef decltype(function_object()) return_type;
+    using return_type = decltype(function_object());
     return Thread<return_type>(std::function<return_type()>(function_object));
   }
 
@@ -1953,7 +1953,7 @@ namespace Threads
   new_task(FunctionObjectType function_object)
     -> Task<decltype(function_object())>
   {
-    typedef decltype(function_object()) return_type;
+    using return_type = decltype(function_object());
     dealii::MultithreadInfo::initialize_multithreading();
     return Task<return_type>(std::function<return_type()>(function_object));
   }
index 27e23900f109f52eaf0ec09ae5cd8841aba57e67..7c9e17be94f492e8f0d73127cda12d4640a50eee 100644 (file)
@@ -42,22 +42,22 @@ struct CPUClock
    * 1/64th of a second and POSIX uses microseconds, so go with microseconds
    * for uniformity.
    */
-  typedef std::chrono::microseconds duration;
+  using duration = std::chrono::microseconds;
 
   /**
    * Signed integral type used to store the value returned by count().
    */
-  typedef duration::rep rep;
+  using rep = duration::rep;
 
   /**
    * Ratio representing the length of a period (in seconds).
    */
-  typedef duration::period period;
+  using period = duration::period;
 
   /**
    * Time point type.
    */
-  typedef std::chrono::time_point<CPUClock, duration> time_point;
+  using time_point = std::chrono::time_point<CPUClock, duration>;
 
   /**
    * Boolean indicating that the clock monotonically increases.
@@ -313,8 +313,8 @@ private:
    *
    * @tparam clock_type_ The type of the clock whose measurements are being
    * stored. This class should conform to the usual clock interface expected
-   * by <code>std::chrono</code> (i.e., the correct <code>typedef</code>s and
-   * a static <code>now()</code> method).
+   * by <code>std::chrono</code> (i.e., the correct alias and a static
+   * <code>now()</code> method).
    */
   template <class clock_type_>
   struct ClockMeasurements
@@ -322,17 +322,17 @@ private:
     /**
      * Store the clock type.
      */
-    typedef clock_type_ clock_type;
+    using clock_type = clock_type_;
 
     /**
      * The time point type of the provided clock.
      */
-    typedef typename clock_type::time_point time_point_type;
+    using time_point_type = typename clock_type::time_point;
 
     /**
      * The duration type of the provided clock.
      */
-    typedef typename clock_type::duration duration_type;
+    using duration_type = typename clock_type::duration;
 
     /**
      * The time point corresponding to the start of the current lap. This is
@@ -365,14 +365,14 @@ private:
   };
 
   /**
-   * typedef for the wall clock.
+   * Alias for the wall clock.
    */
-  typedef std::chrono::steady_clock wall_clock_type;
+  using wall_clock_type = std::chrono::steady_clock;
 
   /**
-   * typedef for the CPU clock.
+   * Alias for the CPU clock.
    */
-  typedef CPUClock cpu_clock_type;
+  using cpu_clock_type = CPUClock;
 
   /**
    * Collection of wall time measurements.
index 49ee6dc49d8940f3be41569d5cb693793c0aded1..f92594529224139c3086c39b4b23cf2adde2c088 100644 (file)
@@ -25,7 +25,7 @@
 DEAL_II_NAMESPACE_OPEN
 
 /**
- * A namespace in which we declare typedefs for types used in deal.II, as well
+ * A namespace in which we declare alias for types used in deal.II, as well
  * as special values for these types.
  */
 namespace types
@@ -40,12 +40,12 @@ namespace types
    * There is a special value, numbers::invalid_subdomain_id that is used to
    * indicate an invalid value of this type.
    */
-  typedef unsigned int subdomain_id;
+  using subdomain_id = unsigned int;
 
   /**
    * The type used for global indices of vertices.
    */
-  typedef unsigned long long int global_vertex_index;
+  using global_vertex_index = unsigned long long int;
 
   /**
    * An identifier that denotes the MPI type associated with
@@ -69,7 +69,7 @@ namespace types
    */
   // TODO: we should check that unsigned long long int
   // has the same size as uint64_t
-  typedef unsigned long long int global_dof_index;
+  using global_dof_index = unsigned long long int;
 
   /**
    * An identifier that denotes the MPI type associated with
@@ -86,7 +86,7 @@ namespace types
    *
    * The data type always indicates an unsigned integer type.
    */
-  typedef unsigned int global_dof_index;
+  using global_dof_index = unsigned int;
 
   /**
    * An identifier that denotes the MPI type associated with
@@ -108,7 +108,7 @@ namespace types
    * @see
    * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
    */
-  typedef unsigned int boundary_id;
+  using boundary_id = unsigned int;
 
   /**
    * The type used to denote manifold indicators associated with every object
@@ -120,7 +120,7 @@ namespace types
    * @see
    * @ref GlossManifoldIndicator "Glossary entry on manifold indicators"
    */
-  typedef unsigned int manifold_id;
+  using manifold_id = unsigned int;
 
   /**
    * The type used to denote material indicators associated with every cell.
@@ -131,13 +131,13 @@ namespace types
    * @see
    * @ref GlossMaterialId "Glossary entry on material indicators"
    */
-  typedef unsigned int material_id;
+  using material_id = unsigned int;
 } // namespace types
 
 /**
  * Declare type used in Epetra.
  */
-typedef double TrilinosScalar;
+using TrilinosScalar = double;
 
 
 namespace TrilinosWrappers
@@ -148,12 +148,12 @@ namespace TrilinosWrappers
     /**
      * Declare type of integer used in the Epetra package of Trilinos.
      */
-    typedef long long int_type;
+    using int_type = long long;
 #else
     /**
      * Declare type of integer used in the Epetra package of Trilinos.
      */
-    typedef int int_type;
+    using int_type = int;
 #endif
   } // namespace types
 } // namespace TrilinosWrappers
index eadadd88965e23dc8713bf52d52b932bdf99f338..94aa7e9aa550226b2e4d22001dc50516d31a3c36 100644 (file)
@@ -100,7 +100,7 @@ namespace internal
 template <typename Number>
 struct EnableIfScalar<VectorizedArray<Number>>
 {
-  typedef VectorizedArray<typename EnableIfScalar<Number>::type> type;
+  using type = VectorizedArray<typename EnableIfScalar<Number>::type>;
 };
 
 
index faa296e2ef9520f41bf581cc78a465b3ccb1ae4f..b09c2d1fdfb4491db7c900b34aa4b21c21c8302e 100644 (file)
@@ -227,7 +227,7 @@ namespace WorkStream
            * Typedef to a list of scratch data objects. The rationale for this
            * list is provided in the variables that use these lists.
            */
-          typedef std::list<ScratchDataObject> ScratchDataList;
+          using ScratchDataList = std::list<ScratchDataObject>;
 
           /**
            * A list of iterators that need to be worked on. Only the first
@@ -490,10 +490,10 @@ namespace WorkStream
         operator()(void *item) override
         {
           // first unpack the current item
-          typedef
+          using ItemType =
             typename IteratorRangeToItemStream<Iterator,
                                                ScratchData,
-                                               CopyData>::ItemType ItemType;
+                                               CopyData>::ItemType;
 
           ItemType *current_item = static_cast<ItemType *>(item);
 
@@ -635,10 +635,10 @@ namespace WorkStream
         operator()(void *item) override
         {
           // first unpack the current item
-          typedef
+          using ItemType =
             typename IteratorRangeToItemStream<Iterator,
                                                ScratchData,
-                                               CopyData>::ItemType ItemType;
+                                               CopyData>::ItemType;
 
           ItemType *current_item = static_cast<ItemType *>(item);
 
@@ -854,15 +854,14 @@ namespace WorkStream
         }
 
       private:
-        typedef typename Implementation3::
-          ScratchAndCopyDataObjects<Iterator, ScratchData, CopyData>
-            ScratchAndCopyDataObjects;
+        using ScratchAndCopyDataObjects = typename Implementation3::
+          ScratchAndCopyDataObjects<Iterator, ScratchData, CopyData>;
 
         /**
          * Typedef to a list of scratch data objects. The rationale for this
          * list is provided in the variables that use these lists.
          */
-        typedef std::list<ScratchAndCopyDataObjects> ScratchAndCopyDataList;
+        using ScratchAndCopyDataList = std::list<ScratchAndCopyDataObjects>;
 
         Threads::ThreadLocalStorage<ScratchAndCopyDataList> data;
 
@@ -1145,11 +1144,10 @@ namespace WorkStream
         for (unsigned int color = 0; color < colored_iterators.size(); ++color)
           if (colored_iterators[color].size() > 0)
             {
-              typedef internal::Implementation3::
-                WorkerAndCopier<Iterator, ScratchData, CopyData>
-                  WorkerAndCopier;
+              using WorkerAndCopier = internal::Implementation3::
+                WorkerAndCopier<Iterator, ScratchData, CopyData>;
 
-              typedef typename std::vector<Iterator>::const_iterator RangeType;
+              using RangeType = typename std::vector<Iterator>::const_iterator;
 
               WorkerAndCopier worker_and_copier(worker,
                                                 copier,
index 769bbc580a454d3346d0b9d3e2613afc6d2c04fb..a85529cc5a40f63629add2d3819a6420b489aad4 100644 (file)
@@ -97,9 +97,9 @@ namespace Differentiation
        *   // State whether the auto-differentiable number uses taping or not.
        *   static const bool             is_taped;
        *   // The real-type for the auto-differentiable number
-       *   typedef <ADNumberType>        real_type;
+       *   using real_type = <ADNumberType>;
        *   // The type of number returned when taking the first derivative of the @p real_type.
-       *   typedef <Scalar/ADNumberType> derivative_type;
+       *   using derivative_type = <Scalar/ADNumberType>;
        *   // The number of derivative levels computable from the @p real_type.
        *   static const unsigned int     n_supported_derivative_levels;
        *
@@ -513,7 +513,7 @@ namespace Differentiation
       template <typename Number>
       struct RemoveComplexWrapper
       {
-        typedef Number type;
+        using type = Number;
       };
 
 
@@ -525,7 +525,7 @@ namespace Differentiation
       template <typename Number>
       struct RemoveComplexWrapper<std::complex<Number>>
       {
-        typedef typename RemoveComplexWrapper<Number>::type type;
+        using type = typename RemoveComplexWrapper<Number>::type;
       };
 
 
@@ -735,10 +735,10 @@ namespace Differentiation
      * internal::ADNumberInfoFromEnum is to be defined, from which we require
      * the following basic information determine all of the required information
      * and type traits for our helper classes:
-     *   - A typedef called @p scalar_type, which defines the scalar or
+     *   - An alias called @p scalar_type, which defines the scalar or
      *     floating-point valued counterpart to the auto-differentiable number
      * type. This can be real or complex valued.
-     *   - A typedef called @p derivative_type, which defines the
+     *   - An alias called @p derivative_type, which defines the
      *     number type for directional derivatives.
      *   - A boolean called @p is_taped, which defines whether the auto-differentiable
      *     number is a taped number or not.
@@ -855,41 +855,40 @@ namespace Differentiation
        * Underlying floating point value type.
        * This could real-valued or complex-valued.
        */
-      typedef ScalarType scalar_type;
+      using scalar_type = ScalarType;
 
 
       /**
        * Type for real numbers
        */
-      typedef typename internal::ADNumberInfoFromEnum<
+      using real_type = typename internal::ADNumberInfoFromEnum<
         typename internal::RemoveComplexWrapper<ScalarType>::type,
-        ADNumberTypeCode>::real_type real_type;
+        ADNumberTypeCode>::real_type;
 
 
       /**
        * Type for complex numbers
        */
-      typedef std::complex<real_type> complex_type;
+      using complex_type = std::complex<real_type>;
 
 
       /**
        * The actual auto-differentiable number type
        */
-      typedef
-        typename std::conditional<is_real_valued, real_type, complex_type>::type
-          ad_type;
+      using ad_type = typename std::
+        conditional<is_real_valued, real_type, complex_type>::type;
 
       /**
        * The actual auto-differentiable number directional derivative type
        */
-      typedef typename std::conditional<
+      using derivative_type = typename std::conditional<
         is_real_valued,
         typename internal::ADNumberInfoFromEnum<
           typename internal::RemoveComplexWrapper<ScalarType>::type,
           ADNumberTypeCode>::derivative_type,
         std::complex<typename internal::ADNumberInfoFromEnum<
           typename internal::RemoveComplexWrapper<ScalarType>::type,
-          ADNumberTypeCode>::derivative_type>>::type derivative_type;
+          ADNumberTypeCode>::derivative_type>>::type;
 
 
       /**
@@ -1038,7 +1037,7 @@ namespace Differentiation
        * Underlying floating point value type.
        * This could real-valued or complex-valued.
        */
-      typedef ScalarType scalar_type;
+      using scalar_type = ScalarType;
 
       static ScalarType
       get_directional_derivative(const ScalarType & /*x*/,
index 8b9aa3f9195398144ec7f5e869d30908c66b2417..87e3169697bfb1ea48ed9e5238cbfad2c5d1df34 100644 (file)
@@ -120,9 +120,9 @@ namespace Differentiation
         typename std::enable_if<
           std::is_floating_point<ScalarType>::value>::type>
       {
-        static const bool         is_taped = true;
-        typedef adouble           real_type;
-        typedef double            derivative_type;
+        static const bool is_taped = true;
+        using real_type            = adouble;
+        using derivative_type      = double;
         static const unsigned int n_supported_derivative_levels =
           std::numeric_limits<unsigned int>::max();
       };
@@ -139,9 +139,9 @@ namespace Differentiation
         typename std::enable_if<
           std::is_floating_point<ScalarType>::value>::type>
       {
-        static const bool         is_taped = false;
-        typedef adtl::adouble     real_type;
-        typedef double            derivative_type;
+        static const bool is_taped                              = false;
+        using real_type                                         = adtl::adouble;
+        using derivative_type                                   = double;
         static const unsigned int n_supported_derivative_levels = 1;
       };
 
@@ -153,7 +153,7 @@ namespace Differentiation
           ADNumberTraits<ADNumberType>::type_code == NumberTypes::adolc_taped &&
           ADNumberTraits<ADNumberType>::is_real_valued>::type>
       {
-        typedef typename ADNumberTraits<ADNumberType>::scalar_type scalar_type;
+        using scalar_type = typename ADNumberTraits<ADNumberType>::scalar_type;
 
         /*
          * Initialize the state of an independent variable.
@@ -191,7 +191,7 @@ namespace Differentiation
                          NumberTypes::adolc_tapeless &&
                        ADNumberTraits<ADNumberType>::is_real_valued>::type>
       {
-        typedef typename ADNumberTraits<ADNumberType>::scalar_type scalar_type;
+        using scalar_type = typename ADNumberTraits<ADNumberType>::scalar_type;
 
         /*
          * Initialize the state of an independent variable.
index c259f542ec306763ee5f05af6880c9f1bd344501..2c727f1ca2dc1f77aebeb2ff712918c37be0cfd4 100644 (file)
@@ -36,7 +36,7 @@ namespace internal
   template <>
   struct ProductTypeImpl<adouble, adouble>
   {
-    typedef adouble type;
+    using type = adouble;
   };
 
   // Typedefs for "adub"s are all that's necessary to ensure that no temporary
@@ -46,13 +46,13 @@ namespace internal
   template <>
   struct ProductTypeImpl<adub, adouble>
   {
-    typedef adouble type;
+    using type = adouble;
   };
 
   template <>
   struct ProductTypeImpl<adouble, adub>
   {
-    typedef adouble type;
+    using type = adouble;
   };
 
   /* --- Double --- */
@@ -60,25 +60,25 @@ namespace internal
   template <>
   struct ProductTypeImpl<double, adouble>
   {
-    typedef adouble type;
+    using type = adouble;
   };
 
   template <>
   struct ProductTypeImpl<adouble, double>
   {
-    typedef adouble type;
+    using type = adouble;
   };
 
   template <>
   struct ProductTypeImpl<double, adub>
   {
-    typedef adouble type;
+    using type = adouble;
   };
 
   template <>
   struct ProductTypeImpl<adub, double>
   {
-    typedef adouble type;
+    using type = adouble;
   };
 
   /* --- Float --- */
@@ -86,25 +86,25 @@ namespace internal
   template <>
   struct ProductTypeImpl<float, adouble>
   {
-    typedef adouble type;
+    using type = adouble;
   };
 
   template <>
   struct ProductTypeImpl<adouble, float>
   {
-    typedef adouble type;
+    using type = adouble;
   };
 
   template <>
   struct ProductTypeImpl<float, adub>
   {
-    typedef adouble type;
+    using type = adouble;
   };
 
   template <>
   struct ProductTypeImpl<adub, float>
   {
-    typedef adouble type;
+    using type = adouble;
   };
 
   /* --- Complex double --- */
@@ -112,31 +112,31 @@ namespace internal
   template <>
   struct ProductTypeImpl<std::complex<double>, std::complex<adouble>>
   {
-    typedef std::complex<adouble> type;
+    using type = std::complex<adouble>;
   };
 
   template <>
   struct ProductTypeImpl<std::complex<adouble>, std::complex<double>>
   {
-    typedef std::complex<adouble> type;
+    using type = std::complex<adouble>;
   };
 
   template <>
   struct ProductTypeImpl<std::complex<adouble>, std::complex<adouble>>
   {
-    typedef std::complex<adouble> type;
+    using type = std::complex<adouble>;
   };
 
   template <>
   struct ProductTypeImpl<std::complex<adub>, std::complex<adouble>>
   {
-    typedef std::complex<adouble> type;
+    using type = std::complex<adouble>;
   };
 
   template <>
   struct ProductTypeImpl<std::complex<adouble>, std::complex<adub>>
   {
-    typedef std::complex<adouble> type;
+    using type = std::complex<adouble>;
   };
 
   /* --- Complex float --- */
@@ -144,13 +144,13 @@ namespace internal
   template <>
   struct ProductTypeImpl<std::complex<float>, std::complex<adouble>>
   {
-    typedef std::complex<adouble> type;
+    using type = std::complex<adouble>;
   };
 
   template <>
   struct ProductTypeImpl<std::complex<adouble>, std::complex<float>>
   {
-    typedef std::complex<adouble> type;
+    using type = std::complex<adouble>;
   };
 
 } // namespace internal
@@ -158,27 +158,27 @@ namespace internal
 template <>
 struct EnableIfScalar<adouble>
 {
-  typedef adouble type;
+  using type = adouble;
 };
 
 template <>
 struct EnableIfScalar<std::complex<adouble>>
 {
-  typedef std::complex<adouble> type;
+  using type = std::complex<adouble>;
 };
 
 
 template <>
 struct EnableIfScalar<adub>
 {
-  typedef adouble type;
+  using type = adouble;
 };
 
 
 template <>
 struct EnableIfScalar<std::complex<adub>>
 {
-  typedef std::complex<adouble> type;
+  using type = std::complex<adouble>;
 };
 
 
@@ -192,19 +192,19 @@ namespace internal
   template <>
   struct ProductTypeImpl<double, adtl::adouble>
   {
-    typedef adtl::adouble type;
+    using type = adtl::adouble;
   };
 
   template <>
   struct ProductTypeImpl<adtl::adouble, double>
   {
-    typedef adtl::adouble type;
+    using type = adtl::adouble;
   };
 
   template <>
   struct ProductTypeImpl<adtl::adouble, adtl::adouble>
   {
-    typedef adtl::adouble type;
+    using type = adtl::adouble;
   };
 
   /* --- Float --- */
@@ -212,13 +212,13 @@ namespace internal
   template <>
   struct ProductTypeImpl<float, adtl::adouble>
   {
-    typedef adtl::adouble type;
+    using type = adtl::adouble;
   };
 
   template <>
   struct ProductTypeImpl<adtl::adouble, float>
   {
-    typedef adtl::adouble type;
+    using type = adtl::adouble;
   };
 
   /* --- Complex double --- */
@@ -226,20 +226,20 @@ namespace internal
   template <>
   struct ProductTypeImpl<std::complex<double>, std::complex<adtl::adouble>>
   {
-    typedef std::complex<adtl::adouble> type;
+    using type = std::complex<adtl::adouble>;
   };
 
   template <>
   struct ProductTypeImpl<std::complex<adtl::adouble>, std::complex<double>>
   {
-    typedef std::complex<adtl::adouble> type;
+    using type = std::complex<adtl::adouble>;
   };
 
   template <>
   struct ProductTypeImpl<std::complex<adtl::adouble>,
                          std::complex<adtl::adouble>>
   {
-    typedef std::complex<adtl::adouble> type;
+    using type = std::complex<adtl::adouble>;
   };
 
   /* --- Complex float --- */
@@ -247,13 +247,13 @@ namespace internal
   template <>
   struct ProductTypeImpl<std::complex<float>, std::complex<adtl::adouble>>
   {
-    typedef std::complex<adtl::adouble> type;
+    using type = std::complex<adtl::adouble>;
   };
 
   template <>
   struct ProductTypeImpl<std::complex<adtl::adouble>, std::complex<float>>
   {
-    typedef std::complex<adtl::adouble> type;
+    using type = std::complex<adtl::adouble>;
   };
 
 } // namespace internal
@@ -262,14 +262,14 @@ namespace internal
 template <>
 struct EnableIfScalar<adtl::adouble>
 {
-  typedef adtl::adouble type;
+  using type = adtl::adouble;
 };
 
 
 template <>
 struct EnableIfScalar<std::complex<adtl::adouble>>
 {
-  typedef std::complex<adtl::adouble> type;
+  using type = std::complex<adtl::adouble>;
 };
 
 
index efc52a18ce08c9ecf4f83155018d03177551dbc5..5139fce83089174f3f3278988b3dc88a98bb7740 100644 (file)
@@ -160,10 +160,10 @@ namespace Differentiation
           SacadoNumber,
           Sacado::Fad::DFad<typename SacadoNumber::value_type>>::value>::type>
       {
-        typedef SacadoNumber                  ad_type;
-        typedef typename ad_type::scalar_type scalar_type;
-        typedef typename ad_type::value_type  value_type;
-        typedef typename ad_type::value_type  derivative_type;
+        using ad_type         = SacadoNumber;
+        using scalar_type     = typename ad_type::scalar_type;
+        using value_type      = typename ad_type::value_type;
+        using derivative_type = typename ad_type::value_type;
 
         static const unsigned int n_supported_derivative_levels =
           1 + SacadoNumberInfo<derivative_type>::n_supported_derivative_levels;
@@ -180,10 +180,10 @@ namespace Differentiation
           SacadoNumber,
           Sacado::Rad::ADvar<typename SacadoNumber::value_type>>::value>::type>
       {
-        typedef SacadoNumber                          ad_type;
-        typedef typename ad_type::ADVari::scalar_type scalar_type;
-        typedef typename ad_type::ADVari::value_type  value_type;
-        typedef typename ad_type::ADVari::value_type  derivative_type;
+        using ad_type         = SacadoNumber;
+        using scalar_type     = typename ad_type::ADVari::scalar_type;
+        using value_type      = typename ad_type::ADVari::value_type;
+        using derivative_type = typename ad_type::ADVari::value_type;
 
         static const unsigned int n_supported_derivative_levels =
           1 + SacadoNumberInfo<derivative_type>::n_supported_derivative_levels;
@@ -217,10 +217,10 @@ namespace Differentiation
         typename std::enable_if<
           std::is_floating_point<ScalarType>::value>::type>
       {
-        static const bool                     is_taped = false;
-        typedef Sacado::Fad::DFad<ScalarType> real_type;
-        typedef
-          typename SacadoNumberInfo<real_type>::derivative_type derivative_type;
+        static const bool is_taped = false;
+        using real_type            = Sacado::Fad::DFad<ScalarType>;
+        using derivative_type =
+          typename SacadoNumberInfo<real_type>::derivative_type;
         static const unsigned int n_supported_derivative_levels =
           SacadoNumberInfo<real_type>::n_supported_derivative_levels;
       };
@@ -238,9 +238,9 @@ namespace Differentiation
           std::is_floating_point<ScalarType>::value>::type>
       {
         static const bool is_taped = false;
-        typedef Sacado::Fad::DFad<Sacado::Fad::DFad<ScalarType>> real_type;
-        typedef
-          typename SacadoNumberInfo<real_type>::derivative_type derivative_type;
+        using real_type = Sacado::Fad::DFad<Sacado::Fad::DFad<ScalarType>>;
+        using derivative_type =
+          typename SacadoNumberInfo<real_type>::derivative_type;
         static const unsigned int n_supported_derivative_levels =
           SacadoNumberInfo<real_type>::n_supported_derivative_levels;
       };
@@ -257,10 +257,10 @@ namespace Differentiation
         typename std::enable_if<
           std::is_floating_point<ScalarType>::value>::type>
       {
-        static const bool                      is_taped = false;
-        typedef Sacado::Rad::ADvar<ScalarType> real_type;
-        typedef
-          typename SacadoNumberInfo<real_type>::derivative_type derivative_type;
+        static const bool is_taped = false;
+        using real_type            = Sacado::Rad::ADvar<ScalarType>;
+        using derivative_type =
+          typename SacadoNumberInfo<real_type>::derivative_type;
         static const unsigned int n_supported_derivative_levels =
           SacadoNumberInfo<real_type>::n_supported_derivative_levels;
       };
@@ -278,9 +278,9 @@ namespace Differentiation
           std::is_floating_point<ScalarType>::value>::type>
       {
         static const bool is_taped = false;
-        typedef Sacado::Rad::ADvar<Sacado::Fad::DFad<ScalarType>> real_type;
-        typedef
-          typename SacadoNumberInfo<real_type>::derivative_type derivative_type;
+        using real_type = Sacado::Rad::ADvar<Sacado::Fad::DFad<ScalarType>>;
+        using derivative_type =
+          typename SacadoNumberInfo<real_type>::derivative_type;
         static const unsigned int n_supported_derivative_levels =
           SacadoNumberInfo<real_type>::n_supported_derivative_levels;
       };
@@ -293,14 +293,12 @@ namespace Differentiation
       template <typename NumberType>
       struct Marking<Sacado::Fad::DFad<NumberType>>
       {
-        typedef
-          typename SacadoNumberInfo<Sacado::Fad::DFad<NumberType>>::ad_type
-            ad_type;
-        typedef typename SacadoNumberInfo<
-          Sacado::Fad::DFad<NumberType>>::derivative_type derivative_type;
-        typedef
-          typename SacadoNumberInfo<Sacado::Fad::DFad<NumberType>>::scalar_type
-            scalar_type;
+        using ad_type =
+          typename SacadoNumberInfo<Sacado::Fad::DFad<NumberType>>::ad_type;
+        using derivative_type = typename SacadoNumberInfo<
+          Sacado::Fad::DFad<NumberType>>::derivative_type;
+        using scalar_type =
+          typename SacadoNumberInfo<Sacado::Fad::DFad<NumberType>>::scalar_type;
 
         /*
          * Initialize the state of an independent variable.
@@ -338,14 +336,12 @@ namespace Differentiation
       template <typename NumberType>
       struct Marking<Sacado::Rad::ADvar<NumberType>>
       {
-        typedef
-          typename SacadoNumberInfo<Sacado::Rad::ADvar<NumberType>>::ad_type
-            ad_type;
-        typedef typename SacadoNumberInfo<
-          Sacado::Rad::ADvar<NumberType>>::derivative_type derivative_type;
-        typedef
-          typename SacadoNumberInfo<Sacado::Rad::ADvar<NumberType>>::scalar_type
-            scalar_type;
+        using ad_type =
+          typename SacadoNumberInfo<Sacado::Rad::ADvar<NumberType>>::ad_type;
+        using derivative_type = typename SacadoNumberInfo<
+          Sacado::Rad::ADvar<NumberType>>::derivative_type;
+        using scalar_type = typename SacadoNumberInfo<
+          Sacado::Rad::ADvar<NumberType>>::scalar_type;
 
         /*
          * Initialize the state of an independent variable.
@@ -391,14 +387,12 @@ namespace Differentiation
       template <typename NumberType>
       struct ExtractData<Sacado::Fad::DFad<NumberType>>
       {
-        typedef typename SacadoNumberInfo<
-          Sacado::Fad::DFad<NumberType>>::derivative_type derivative_type;
-        typedef
-          typename SacadoNumberInfo<Sacado::Fad::DFad<NumberType>>::scalar_type
-            scalar_type;
-        typedef
-          typename SacadoNumberInfo<Sacado::Fad::DFad<NumberType>>::value_type
-            value_type;
+        using derivative_type = typename SacadoNumberInfo<
+          Sacado::Fad::DFad<NumberType>>::derivative_type;
+        using scalar_type =
+          typename SacadoNumberInfo<Sacado::Fad::DFad<NumberType>>::scalar_type;
+        using value_type =
+          typename SacadoNumberInfo<Sacado::Fad::DFad<NumberType>>::value_type;
 
         /**
          * Extract the real scalar value.
@@ -445,14 +439,12 @@ namespace Differentiation
       template <typename NumberType>
       struct ExtractData<Sacado::Rad::ADvar<NumberType>>
       {
-        typedef typename SacadoNumberInfo<
-          Sacado::Rad::ADvar<NumberType>>::derivative_type derivative_type;
-        typedef
-          typename SacadoNumberInfo<Sacado::Rad::ADvar<NumberType>>::scalar_type
-            scalar_type;
-        typedef
-          typename SacadoNumberInfo<Sacado::Rad::ADvar<NumberType>>::value_type
-            value_type;
+        using derivative_type = typename SacadoNumberInfo<
+          Sacado::Rad::ADvar<NumberType>>::derivative_type;
+        using scalar_type = typename SacadoNumberInfo<
+          Sacado::Rad::ADvar<NumberType>>::scalar_type;
+        using value_type =
+          typename SacadoNumberInfo<Sacado::Rad::ADvar<NumberType>>::value_type;
 
         /**
          * Extract the real scalar value.
index b07f3536aae9c43434e3af842ac19344c7a83840..e4faee351070764d39e1eb8b5f922a4d04bbc64a 100644 (file)
@@ -44,43 +44,43 @@ namespace internal
   template <typename T>
   struct ProductTypeImpl<Sacado::Fad::DFad<T>, float>
   {
-    typedef Sacado::Fad::DFad<T> type;
+    using type = Sacado::Fad::DFad<T>;
   };
 
   template <typename T>
   struct ProductTypeImpl<float, Sacado::Fad::DFad<T>>
   {
-    typedef Sacado::Fad::DFad<T> type;
+    using type = Sacado::Fad::DFad<T>;
   };
 
   template <typename T>
   struct ProductTypeImpl<Sacado::Fad::DFad<T>, double>
   {
-    typedef Sacado::Fad::DFad<T> type;
+    using type = Sacado::Fad::DFad<T>;
   };
 
   template <typename T>
   struct ProductTypeImpl<double, Sacado::Fad::DFad<T>>
   {
-    typedef Sacado::Fad::DFad<T> type;
+    using type = Sacado::Fad::DFad<T>;
   };
 
   template <typename T>
   struct ProductTypeImpl<Sacado::Fad::DFad<T>, int>
   {
-    typedef Sacado::Fad::DFad<T> type;
+    using type = Sacado::Fad::DFad<T>;
   };
 
   template <typename T>
   struct ProductTypeImpl<int, Sacado::Fad::DFad<T>>
   {
-    typedef Sacado::Fad::DFad<T> type;
+    using type = Sacado::Fad::DFad<T>;
   };
 
   template <typename T, typename U>
   struct ProductTypeImpl<Sacado::Fad::DFad<T>, Sacado::Fad::DFad<U>>
   {
-    typedef Sacado::Fad::DFad<typename ProductType<T, U>::type> type;
+    using type = Sacado::Fad::DFad<typename ProductType<T, U>::type>;
   };
 
 
@@ -93,26 +93,23 @@ namespace internal
   template <typename T, typename U>
   struct ProductTypeImpl<Sacado::Fad::Expr<T>, U>
   {
-    typedef
-      typename ProductType<typename Sacado::Fad::Expr<T>::value_type, U>::type
-        type;
+    using type =
+      typename ProductType<typename Sacado::Fad::Expr<T>::value_type, U>::type;
   };
 
   template <typename T, typename U>
   struct ProductTypeImpl<T, Sacado::Fad::Expr<U>>
   {
-    typedef
-      typename ProductType<T, typename Sacado::Fad::Expr<U>::value_type>::type
-        type;
+    using type =
+      typename ProductType<T, typename Sacado::Fad::Expr<U>::value_type>::type;
   };
 
   template <typename T, typename U>
   struct ProductTypeImpl<Sacado::Fad::Expr<T>, Sacado::Fad::Expr<U>>
   {
-    typedef
+    using type =
       typename ProductType<typename Sacado::Fad::Expr<T>::value_type,
-                           typename Sacado::Fad::Expr<U>::value_type>::type
-        type;
+                           typename Sacado::Fad::Expr<U>::value_type>::type;
   };
 
 } // namespace internal
@@ -121,13 +118,13 @@ namespace internal
 template <typename T>
 struct EnableIfScalar<Sacado::Fad::DFad<T>>
 {
-  typedef Sacado::Fad::DFad<T> type;
+  using type = Sacado::Fad::DFad<T>;
 };
 
 template <typename T>
 struct EnableIfScalar<Sacado::Fad::Expr<T>>
 {
-  typedef typename Sacado::Fad::Expr<T>::value_type type;
+  using type = typename Sacado::Fad::Expr<T>::value_type;
 };
 
 
@@ -141,43 +138,43 @@ namespace internal
   template <typename T>
   struct ProductTypeImpl<Sacado::Rad::ADvar<T>, float>
   {
-    typedef Sacado::Rad::ADvar<T> type;
+    using type = Sacado::Rad::ADvar<T>;
   };
 
   template <typename T>
   struct ProductTypeImpl<float, Sacado::Rad::ADvar<T>>
   {
-    typedef Sacado::Rad::ADvar<T> type;
+    using type = Sacado::Rad::ADvar<T>;
   };
 
   template <typename T>
   struct ProductTypeImpl<Sacado::Rad::ADvar<T>, double>
   {
-    typedef Sacado::Rad::ADvar<T> type;
+    using type = Sacado::Rad::ADvar<T>;
   };
 
   template <typename T>
   struct ProductTypeImpl<double, Sacado::Rad::ADvar<T>>
   {
-    typedef Sacado::Rad::ADvar<T> type;
+    using type = Sacado::Rad::ADvar<T>;
   };
 
   template <typename T>
   struct ProductTypeImpl<Sacado::Rad::ADvar<T>, int>
   {
-    typedef Sacado::Rad::ADvar<T> type;
+    using type = Sacado::Rad::ADvar<T>;
   };
 
   template <typename T>
   struct ProductTypeImpl<int, Sacado::Rad::ADvar<T>>
   {
-    typedef Sacado::Rad::ADvar<T> type;
+    using type = Sacado::Rad::ADvar<T>;
   };
 
   template <typename T, typename U>
   struct ProductTypeImpl<Sacado::Rad::ADvar<T>, Sacado::Rad::ADvar<U>>
   {
-    typedef Sacado::Rad::ADvar<typename ProductType<T, U>::type> type;
+    using type = Sacado::Rad::ADvar<typename ProductType<T, U>::type>;
   };
 
   /* --- Sacado::Rad::ADvar: Temporary type --- */
@@ -185,43 +182,43 @@ namespace internal
   template <typename T>
   struct ProductTypeImpl<Sacado::Rad::ADvari<T>, float>
   {
-    typedef Sacado::Rad::ADvari<T> type;
+    using type = Sacado::Rad::ADvari<T>;
   };
 
   template <typename T>
   struct ProductTypeImpl<float, Sacado::Rad::ADvari<T>>
   {
-    typedef Sacado::Rad::ADvari<T> type;
+    using type = Sacado::Rad::ADvari<T>;
   };
 
   template <typename T>
   struct ProductTypeImpl<Sacado::Rad::ADvari<T>, double>
   {
-    typedef Sacado::Rad::ADvari<T> type;
+    using type = Sacado::Rad::ADvari<T>;
   };
 
   template <typename T>
   struct ProductTypeImpl<double, Sacado::Rad::ADvari<T>>
   {
-    typedef Sacado::Rad::ADvari<T> type;
+    using type = Sacado::Rad::ADvari<T>;
   };
 
   template <typename T>
   struct ProductTypeImpl<Sacado::Rad::ADvari<T>, int>
   {
-    typedef Sacado::Rad::ADvari<T> type;
+    using type = Sacado::Rad::ADvari<T>;
   };
 
   template <typename T>
   struct ProductTypeImpl<int, Sacado::Rad::ADvari<T>>
   {
-    typedef Sacado::Rad::ADvari<T> type;
+    using type = Sacado::Rad::ADvari<T>;
   };
 
   template <typename T, typename U>
   struct ProductTypeImpl<Sacado::Rad::ADvari<T>, Sacado::Rad::ADvari<U>>
   {
-    typedef Sacado::Rad::ADvari<typename ProductType<T, U>::type> type;
+    using type = Sacado::Rad::ADvari<typename ProductType<T, U>::type>;
   };
 
   /* --- Sacado::Rad::ADvar: Main and temporary type --- */
@@ -229,13 +226,13 @@ namespace internal
   template <typename T, typename U>
   struct ProductTypeImpl<Sacado::Rad::ADvar<T>, Sacado::Rad::ADvari<U>>
   {
-    typedef Sacado::Rad::ADvar<typename ProductType<T, U>::type> type;
+    using type = Sacado::Rad::ADvar<typename ProductType<T, U>::type>;
   };
 
   template <typename T, typename U>
   struct ProductTypeImpl<Sacado::Rad::ADvari<T>, Sacado::Rad::ADvar<U>>
   {
-    typedef Sacado::Rad::ADvar<typename ProductType<T, U>::type> type;
+    using type = Sacado::Rad::ADvar<typename ProductType<T, U>::type>;
   };
 
 } // namespace internal
@@ -244,14 +241,14 @@ namespace internal
 template <typename T>
 struct EnableIfScalar<Sacado::Rad::ADvar<T>>
 {
-  typedef Sacado::Rad::ADvar<T> type;
+  using type = Sacado::Rad::ADvar<T>;
 };
 
 
 template <typename T>
 struct EnableIfScalar<Sacado::Rad::ADvari<T>>
 {
-  typedef Sacado::Rad::ADvari<T> type;
+  using type = Sacado::Rad::ADvari<T>;
 };
 
 
index 5278add952d37532f144fbe325ceeaedb32704b0..9c23519cc62577b035a046b3b4eb2ef0c09960f0 100644 (file)
@@ -53,7 +53,7 @@ namespace internal
   namespace p4est
   {
     /**
-     * A structure whose explicit specializations contain typedefs to the
+     * A structure whose explicit specializations contain alias to the
      * relevant p4est_* and p8est_* types. Using this structure, for example
      * by saying <tt>types<dim>::connectivity</tt> we can write code in a
      * dimension independent way, either referring to p4est_connectivity_t or
@@ -65,35 +65,35 @@ namespace internal
     template <>
     struct types<2>
     {
-      typedef p4est_connectivity_t connectivity;
-      typedef p4est_t              forest;
-      typedef p4est_tree_t         tree;
-      typedef p4est_quadrant_t     quadrant;
-      typedef p4est_topidx_t       topidx;
-      typedef p4est_locidx_t       locidx;
+      using connectivity = p4est_connectivity_t;
+      using forest       = p4est_t;
+      using tree         = p4est_tree_t;
+      using quadrant     = p4est_quadrant_t;
+      using topidx       = p4est_topidx_t;
+      using locidx       = p4est_locidx_t;
 #  if DEAL_II_P4EST_VERSION_GTE(0, 3, 4, 3)
-      typedef p4est_connect_type_t balance_type;
+      using balance_type = p4est_connect_type_t;
 #  else
-      typedef p4est_balance_type_t balance_type;
+      using balance_type = p4est_balance_type_t;
 #  endif
-      typedef p4est_ghost_t ghost;
+      using ghost = p4est_ghost_t;
     };
 
     template <>
     struct types<3>
     {
-      typedef p8est_connectivity_t connectivity;
-      typedef p8est_t              forest;
-      typedef p8est_tree_t         tree;
-      typedef p8est_quadrant_t     quadrant;
-      typedef p4est_topidx_t       topidx;
-      typedef p4est_locidx_t       locidx;
+      using connectivity = p8est_connectivity_t;
+      using forest       = p8est_t;
+      using tree         = p8est_tree_t;
+      using quadrant     = p8est_quadrant_t;
+      using topidx       = p4est_topidx_t;
+      using locidx       = p4est_locidx_t;
 #  if DEAL_II_P4EST_VERSION_GTE(0, 3, 4, 3)
-      typedef p8est_connect_type_t balance_type;
+      using balance_type = p8est_connect_type_t;
 #  else
-      typedef p8est_balance_type_t balance_type;
+      using balance_type = p8est_balance_type_t;
 #  endif
-      typedef p8est_ghost_t ghost;
+      using ghost = p8est_ghost_t;
     };
 
 
@@ -430,26 +430,26 @@ namespace internal
     template <>
     struct iter<2>
     {
-      typedef p4est_iter_corner_info_t corner_info;
-      typedef p4est_iter_corner_side_t corner_side;
-      typedef p4est_iter_corner_t      corner_iter;
-      typedef p4est_iter_face_info_t   face_info;
-      typedef p4est_iter_face_side_t   face_side;
-      typedef p4est_iter_face_t        face_iter;
+      using corner_info = p4est_iter_corner_info_t;
+      using corner_side = p4est_iter_corner_side_t;
+      using corner_iter = p4est_iter_corner_t;
+      using face_info   = p4est_iter_face_info_t;
+      using face_side   = p4est_iter_face_side_t;
+      using face_iter   = p4est_iter_face_t;
     };
 
     template <>
     struct iter<3>
     {
-      typedef p8est_iter_corner_info_t corner_info;
-      typedef p8est_iter_corner_side_t corner_side;
-      typedef p8est_iter_corner_t      corner_iter;
-      typedef p8est_iter_edge_info_t   edge_info;
-      typedef p8est_iter_edge_side_t   edge_side;
-      typedef p8est_iter_edge_t        edge_iter;
-      typedef p8est_iter_face_info_t   face_info;
-      typedef p8est_iter_face_side_t   face_side;
-      typedef p8est_iter_face_t        face_iter;
+      using corner_info = p8est_iter_corner_info_t;
+      using corner_side = p8est_iter_corner_side_t;
+      using corner_iter = p8est_iter_corner_t;
+      using edge_info   = p8est_iter_edge_info_t;
+      using edge_side   = p8est_iter_edge_side_t;
+      using edge_iter   = p8est_iter_edge_t;
+      using face_info   = p8est_iter_face_info_t;
+      using face_side   = p8est_iter_face_side_t;
+      using face_iter   = p8est_iter_face_t;
     };
 
 
index fc6a1e3d40f44385a6ddae49648d702fa002e192..88e99b4432ca8dfc09ecd61493761e653fe6b5e2 100644 (file)
@@ -102,11 +102,10 @@ namespace parallel
     class Triangulation : public dealii::parallel::Triangulation<dim, spacedim>
     {
     public:
-      typedef
-        typename dealii::Triangulation<dim, spacedim>::active_cell_iterator
-          active_cell_iterator;
-      typedef typename dealii::Triangulation<dim, spacedim>::cell_iterator
-        cell_iterator;
+      using active_cell_iterator =
+        typename dealii::Triangulation<dim, spacedim>::active_cell_iterator;
+      using cell_iterator =
+        typename dealii::Triangulation<dim, spacedim>::cell_iterator;
 
       /**
        * Configuration flags for distributed Triangulations to be set in the
index b6aa5ef89afd02a6d30d70ceec5fde3871708030..0c20b18eef99cb1ab8aed50e4478594eff8e666d 100644 (file)
@@ -252,12 +252,12 @@ namespace parallel
     {
     public:
       /**
-       * A typedef that is used to identify cell iterators. The concept of
+       * An alias that is used to identify cell iterators. The concept of
        * iterators is discussed at length in the
        * @ref Iterators "iterators documentation module".
        *
-       * The current typedef identifies cells in a triangulation. You can find
-       * the exact type it refers to in the base class's own typedef, but it
+       * The current alias identifies cells in a triangulation. You can find
+       * the exact type it refers to in the base class's own alias, but it
        * should be TriaIterator<CellAccessor<dim,spacedim> >. The TriaIterator
        * class works like a pointer that when you dereference it yields an
        * object of type CellAccessor. CellAccessor is a class that identifies
@@ -268,17 +268,17 @@ namespace parallel
        *
        * @ingroup Iterators
        */
-      typedef typename dealii::Triangulation<dim, spacedim>::cell_iterator
-        cell_iterator;
+      using cell_iterator =
+        typename dealii::Triangulation<dim, spacedim>::cell_iterator;
 
       /**
-       * A typedef that is used to identify
+       * An alias that is used to identify
        * @ref GlossActive "active cell iterators".
        * The concept of iterators is discussed at length in the
        * @ref Iterators "iterators documentation module".
        *
-       * The current typedef identifies active cells in a triangulation. You
-       * can find the exact type it refers to in the base class's own typedef,
+       * The current alias identifies active cells in a triangulation. You
+       * can find the exact type it refers to in the base class's own alias,
        * but it should be TriaActiveIterator<CellAccessor<dim,spacedim> >. The
        * TriaActiveIterator class works like a pointer to active objects that
        * when you dereference it yields an object of type CellAccessor.
@@ -289,12 +289,11 @@ namespace parallel
        *
        * @ingroup Iterators
        */
-      typedef
-        typename dealii::Triangulation<dim, spacedim>::active_cell_iterator
-          active_cell_iterator;
+      using active_cell_iterator =
+        typename dealii::Triangulation<dim, spacedim>::active_cell_iterator;
 
-      typedef
-        typename dealii::Triangulation<dim, spacedim>::CellStatus CellStatus;
+      using CellStatus =
+        typename dealii::Triangulation<dim, spacedim>::CellStatus;
 
       /**
        * Configuration flags for distributed Triangulations to be set in the
@@ -917,11 +916,10 @@ namespace parallel
        * description of the latter, see the documentation for the member
        * function register_data_attach.
        */
-      typedef typename std::tuple<
+      using quadrant_cell_relation_t = typename std::tuple<
         typename dealii::internal::p4est::types<dim>::quadrant *,
         CellStatus,
-        cell_iterator>
-        quadrant_cell_relation_t;
+        cell_iterator>;
 
       /**
        * Vector of tuples, which each contain a p4est quadrant, a deal.II cell
index 045a72fb592eb75015f3a3fe51234d8a733e3c53..a9fb00eb3535aed649299bcfdd12dfaf38ba258c 100644 (file)
@@ -28,46 +28,41 @@ class Function;
 
 
 /**
- * This class declares a local typedef that denotes a mapping between a
- * boundary indicator (see
- * @ref GlossBoundaryIndicator)
- * that is used to describe what kind of boundary condition holds on a
- * particular piece of the boundary, and the function describing the actual
- * function that provides the boundary values on this part of the boundary.
- * This type is required in many functions in the library where, for example,
- * we need to know about the functions $h_i(\mathbf x)$ used in boundary
- * conditions
+ * This class declares a local alias that denotes a mapping between a boundary
+ * indicator (see @ref GlossBoundaryIndicator) that is used to describe what
+ * kind of boundary condition holds on a particular piece of the boundary, and
+ * the function describing the actual function that provides the boundary values
+ * on this part of the boundary. This type is required in many functions in the
+ * library where, for example, we need to know about the functions
+ * $h_i(\mathbf x)$ used in boundary conditions
  * @f{align*}{
  * \mathbf n \cdot \nabla u = h_i \qquad \qquad
  * \text{on}\ \Gamma_i\subset\partial\Omega.
  * @f}
- * An example is the function KellyErrorEstimator::estimate() that allows us
- * to provide a set of functions $h_i$ for all those boundary indicators $i$
- * for which the boundary condition is supposed to be of Neumann type. Of
- * course, the same kind of principle can be applied to cases where we care
- * about Dirichlet values, where one needs to provide a map from boundary
- * indicator $i$ to Dirichlet function $h_i$ if the boundary conditions are
- * given as
+ * An example is the function KellyErrorEstimator::estimate() that allows us to
+ * provide a set of functions $h_i$ for all those boundary indicators $i$ for
+ * which the boundary condition is supposed to be of Neumann type. Of course,
+ * the same kind of principle can be applied to cases where we care about
+ * Dirichlet values, where one needs to provide a map from boundary indicator
+ * $i$ to Dirichlet function $h_i$ if the boundary conditions are given as
  * @f{align*}{
  * u = h_i \qquad \qquad \text{on}\ \Gamma_i\subset\partial\Omega.
  * @f}
- * This is, for example, the case for the VectorTools::interpolate()
- * functions.
+ * This is, for example, the case for the VectorTools::interpolate() functions.
  *
  * Tutorial programs step-6, step-7 and step-8 show examples of how to use
- * function arguments of this type in situations where we actually have an
- * empty map (i.e., we want to describe that <i>no</i> part of the boundary is
- * a Neumann boundary). step-16 actually uses it in a case where one of the
- * parts of the boundary uses a boundary indicator for which we want to use a
- * function object.
+ * function arguments of this type in situations where we actually have an empty
+ * map (i.e., we want to describe that <i>no</i> part of the boundary is a
+ * Neumann boundary). step-16 actually uses it in a case where one of the parts
+ * of the boundary uses a boundary indicator for which we want to use a function
+ * object.
  *
- * It seems odd at first to declare this typedef inside a class, rather than
- * declaring a typedef at global scope. The reason is that C++ does not allow
- * to define templated typedefs, where here in fact we want a typedef that
- * depends on the space dimension. (Defining templated typedefs is something
- * that is possible starting with the C++11 standard, but that wasn't possible
- * within the C++98 standard in place when this programming pattern was
- * conceived.)
+ * It seems odd at first to declare this alias inside a class, rather than
+ * declaring an alias at global scope. The reason is that C++ does not allow to
+ * define templated alias, where here in fact we want an alias that depends on
+ * the space dimension. (Defining templated alias is something that is possible
+ * starting with the C++11 standard, but that wasn't possible within the C++98
+ * standard in place when this programming pattern was conceived.)
  *
  * @ingroup functions
  * @author Wolfgang Bangerth, Ralf Hartmann, 2001
@@ -78,12 +73,12 @@ struct DEAL_II_DEPRECATED FunctionMap
   /**
    * Declare the type as discussed above. Since we can't name it FunctionMap
    * (as that would ambiguate a possible constructor of this class), name it
-   * in the fashion of the standard container local typedefs.
+   * in the fashion of the standard container local alias.
    *
    * @deprecated Use the alias type directly.
    */
-  DEAL_II_DEPRECATED
-  typedef std::map<types::boundary_id, const Function<dim, Number> *> type;
+  using type DEAL_II_DEPRECATED =
+    std::map<types::boundary_id, const Function<dim, Number> *>;
 };
 
 DEAL_II_NAMESPACE_CLOSE
index 74fb8a949727d82db2e3fd031b8a0d5601d1823b..9bd462f582ee1c61d5196b738328ebce9e08c849 100644 (file)
@@ -79,10 +79,10 @@ namespace internal
   namespace DoFAccessorImplementation
   {
     /**
-     * This is a switch class which only declares a @p typedef. It is meant to
+     * This is a switch class which only declares an @p alias. It is meant to
      * determine which class a DoFAccessor class is to be derived from. By
      * default, <tt>DoFAccessor@<structdim,dim,spacedim@></tt> derives from
-     * the typedef in the general
+     * the alias in the general
      * <tt>Inheritance@<structdim,dim,spacedim@></tt> class, which is
      * <tt>TriaAccessor@<structdim,dim,spacedim@></tt>, but if
      * <tt>structdim==dim</tt>, then the specialization
@@ -99,10 +99,10 @@ namespace internal
     struct Inheritance
     {
       /**
-       * Declaration of the @p typedef.  See the full documentation for more
+       * Declaration of the @p alias. See the full documentation for more
        * information.
        */
-      typedef dealii::TriaAccessor<structdim, dim, spacedim> BaseClass;
+      using BaseClass = dealii::TriaAccessor<structdim, dim, spacedim>;
     };
 
 
@@ -115,10 +115,10 @@ namespace internal
     struct Inheritance<dim, dim, spacedim>
     {
       /**
-       * Declaration of the @p typedef.  See the full documentation for more
+       * Declaration of the @p alias. See the full documentation for more
        * information.
        */
-      typedef dealii::CellAccessor<dim, spacedim> BaseClass;
+      using BaseClass = dealii::CellAccessor<dim, spacedim>;
     };
   } // namespace DoFAccessorImplementation
 } // namespace internal
@@ -148,9 +148,9 @@ namespace internal
  * function get_active_or_mg_dof_indices(). See the section on Generic loops
  * below.
  *
- * <h3>Typedefs</h3>
+ * <h3>Alias</h3>
  *
- * Usage is best to happen through the typedefs to the various kinds of
+ * Usage is best to happen through the alias to the various kinds of
  * iterators provided by the DoFHandler and hp::DoFHandler classes, since they
  * are more secure to changes in the class naming and template interface as
  * well as providing easier typing (much less complicated names!).
@@ -226,16 +226,16 @@ public:
   static const unsigned int space_dimension = DoFHandlerType::space_dimension;
 
   /**
-   * Declare a typedef to the base class to make accessing some of the
+   * Declare an alias to the base class to make accessing some of the
    * exception classes simpler.
    */
-  typedef typename dealii::internal::DoFAccessorImplementation::
-    Inheritance<structdim, dimension, space_dimension>::BaseClass BaseClass;
+  using BaseClass = typename dealii::internal::DoFAccessorImplementation::
+    Inheritance<structdim, dimension, space_dimension>::BaseClass;
 
   /**
    * Data type passed by the iterator class.
    */
-  typedef DoFHandlerType AccessorData;
+  using AccessorData = DoFHandlerType;
 
   /**
    * @name Constructors
@@ -778,15 +778,15 @@ public:
   static const unsigned int space_dimension = spacedim;
 
   /**
-   * Declare a typedef to the base class to make accessing some of the
+   * Declare an alias to the base class to make accessing some of the
    * exception classes simpler.
    */
-  typedef TriaAccessor<0, 1, spacedim> BaseClass;
+  using BaseClass = TriaAccessor<0, 1, spacedim>;
 
   /**
    * Data type passed by the iterator class.
    */
-  typedef DoFHandlerType<1, spacedim> AccessorData;
+  using AccessorData = DoFHandlerType<1, spacedim>;
 
   /**
    * @name Constructors
@@ -1252,10 +1252,10 @@ class DoFInvalidAccessor : public InvalidAccessor<structdim, dim, spacedim>
 {
 public:
   /**
-   * Propagate typedef from base class to this class.
+   * Propagate alias from base class to this class.
    */
-  typedef typename InvalidAccessor<structdim, dim, spacedim>::AccessorData
-    AccessorData;
+  using AccessorData =
+    typename InvalidAccessor<structdim, dim, spacedim>::AccessorData;
 
   /**
    * Constructor.  This class is used for iterators that do not make
@@ -1334,30 +1334,27 @@ public:
   /**
    * Data type passed by the iterator class.
    */
-  typedef DoFHandlerType AccessorData;
+  using AccessorData = DoFHandlerType;
 
   /**
-   * Declare a typedef to the base class to make accessing some of the
+   * Declare an alias to the base class to make accessing some of the
    * exception classes simpler.
    */
-  typedef DoFAccessor<DoFHandlerType::dimension,
-                      DoFHandlerType,
-                      level_dof_access>
-    BaseClass;
+  using BaseClass =
+    DoFAccessor<DoFHandlerType::dimension, DoFHandlerType, level_dof_access>;
 
   /**
    * Define the type of the container this is part of.
    */
-  typedef DoFHandlerType Container;
+  using Container = DoFHandlerType;
 
   /**
    * A type for an iterator over the faces of a cell. This is what the face()
    * function returns.
    */
-  typedef TriaIterator<DoFAccessor<DoFHandlerType::dimension - 1,
-                                   DoFHandlerType,
-                                   level_dof_access>>
-    face_iterator;
+  using face_iterator = TriaIterator<DoFAccessor<DoFHandlerType::dimension - 1,
+                                                 DoFHandlerType,
+                                                 level_dof_access>>;
 
   /**
    * @name Constructors and initialization
index bc214020d6c6b1e64d5bdae8bec6c99a211a225e..9b08cd587bf5814ee350c1014f97018b6412e380 100644 (file)
@@ -199,34 +199,32 @@ namespace internal
 template <int dim, int spacedim = dim>
 class DoFHandler : public Subscriptor
 {
-  typedef dealii::internal::DoFHandlerImplementation::
-    Iterators<DoFHandler<dim, spacedim>, false>
-      ActiveSelector;
-  typedef dealii::internal::DoFHandlerImplementation::
-    Iterators<DoFHandler<dim, spacedim>, true>
-      LevelSelector;
+  using ActiveSelector = dealii::internal::DoFHandlerImplementation::
+    Iterators<DoFHandler<dim, spacedim>, false>;
+  using LevelSelector = dealii::internal::DoFHandlerImplementation::
+    Iterators<DoFHandler<dim, spacedim>, true>;
 
 public:
-  typedef typename ActiveSelector::CellAccessor cell_accessor;
-  typedef typename ActiveSelector::FaceAccessor face_accessor;
+  using cell_accessor = typename ActiveSelector::CellAccessor;
+  using face_accessor = typename ActiveSelector::FaceAccessor;
 
-  typedef typename ActiveSelector::line_iterator        line_iterator;
-  typedef typename ActiveSelector::active_line_iterator active_line_iterator;
+  using line_iterator        = typename ActiveSelector::line_iterator;
+  using active_line_iterator = typename ActiveSelector::active_line_iterator;
 
-  typedef typename ActiveSelector::quad_iterator        quad_iterator;
-  typedef typename ActiveSelector::active_quad_iterator active_quad_iterator;
+  using quad_iterator        = typename ActiveSelector::quad_iterator;
+  using active_quad_iterator = typename ActiveSelector::active_quad_iterator;
 
-  typedef typename ActiveSelector::hex_iterator        hex_iterator;
-  typedef typename ActiveSelector::active_hex_iterator active_hex_iterator;
+  using hex_iterator        = typename ActiveSelector::hex_iterator;
+  using active_hex_iterator = typename ActiveSelector::active_hex_iterator;
 
   /**
-   * A typedef that is used to identify
+   * An alias that is used to identify
    * @ref GlossActive "active cell iterators".
    * The concept of iterators is discussed at length in the
    * @ref Iterators "iterators documentation module".
    *
-   * The current typedef identifies active cells in a DoFHandler object. While
-   * the actual data type of the typedef is hidden behind a few layers of
+   * The current alias identifies active cells in a DoFHandler object. While
+   * the actual data type of the alias is hidden behind a few layers of
    * (unfortunately necessary) indirections, it is in essence
    * TriaActiveIterator<DoFCellAccessor>. The TriaActiveIterator class works
    * like a pointer to active objects that when you dereference it yields an
@@ -239,22 +237,22 @@ public:
    *
    * @ingroup Iterators
    */
-  typedef typename ActiveSelector::active_cell_iterator active_cell_iterator;
+  using active_cell_iterator = typename ActiveSelector::active_cell_iterator;
 
   /**
-   * A typedef that is used to identify cell iterators. The concept of
+   * An alias that is used to identify cell iterators. The concept of
    * iterators is discussed at length in the
    * @ref Iterators "iterators documentation module".
    *
-   * The current typedef identifies cells in a DoFHandler object. Some of
+   * The current alias identifies cells in a DoFHandler object. Some of
    * these cells may in fact be active (see
    * @ref GlossActive "active cell iterators")
    * in which case they can in fact be asked for the degrees of freedom that
    * live on them. On the other hand, if the cell is not active, any such
    * query will result in an error. Note that this is what distinguishes this
-   * typedef from the level_cell_iterator typedef.
+   * alias from the level_cell_iterator alias.
    *
-   * While the actual data type of the typedef is hidden behind a few layers
+   * While the actual data type of the alias is hidden behind a few layers
    * of (unfortunately necessary) indirections, it is in essence
    * TriaIterator<DoFCellAccessor>. The TriaIterator class works like a
    * pointer to objects that when you dereference it yields an object of type
@@ -267,14 +265,14 @@ public:
    *
    * @ingroup Iterators
    */
-  typedef typename ActiveSelector::cell_iterator cell_iterator;
+  using cell_iterator = typename ActiveSelector::cell_iterator;
 
   /**
-   * A typedef that is used to identify iterators that point to faces.
+   * An alias that is used to identify iterators that point to faces.
    * The concept of iterators is discussed at length in the
    * @ref Iterators "iterators documentation module".
    *
-   * While the actual data type of the typedef is hidden behind a few layers
+   * While the actual data type of the alias is hidden behind a few layers
    * of (unfortunately necessary) indirections, it is in essence
    * TriaIterator<DoFAccessor>. The
    * TriaIterator class works like a pointer to objects that when
@@ -285,26 +283,26 @@ public:
    *
    * @ingroup Iterators
    */
-  typedef typename ActiveSelector::face_iterator face_iterator;
+  using face_iterator = typename ActiveSelector::face_iterator;
 
   /**
-   * A typedef that is used to identify iterators that point to active faces,
+   * An alias that is used to identify iterators that point to active faces,
    * i.e., to faces that have no children. Active faces must be faces of at
    * least one active cell.
    *
-   * Other than the "active" qualification, this typedef is identical to the
-   * @p face_iterator typedef. In particular, dereferencing either yields
+   * Other than the "active" qualification, this alias is identical to the
+   * @p face_iterator alias. In particular, dereferencing either yields
    * the same kind of object.
    *
    * @ingroup Iterators
    */
-  typedef typename ActiveSelector::active_face_iterator active_face_iterator;
+  using active_face_iterator = typename ActiveSelector::active_face_iterator;
 
-  typedef typename LevelSelector::CellAccessor level_cell_accessor;
-  typedef typename LevelSelector::FaceAccessor level_face_accessor;
+  using level_cell_accessor = typename LevelSelector::CellAccessor;
+  using level_face_accessor = typename LevelSelector::FaceAccessor;
 
-  typedef typename LevelSelector::cell_iterator level_cell_iterator;
-  typedef typename LevelSelector::face_iterator level_face_iterator;
+  using level_cell_iterator = typename LevelSelector::cell_iterator;
+  using level_face_iterator = typename LevelSelector::face_iterator;
 
 
   /**
index eafb81cfc869ae7d89c84bc89c372deb9f6fdf4c..e6ed01460c60ea71c9146081bf4217c597a2d030 100644 (file)
@@ -59,33 +59,33 @@ namespace internal
     template <template <int, int> class DoFHandlerType, int spacedim, bool lda>
     struct Iterators<DoFHandlerType<1, spacedim>, lda>
     {
-      typedef DoFHandlerType<1, spacedim>                   DoFHandler_type;
-      typedef dealii::DoFCellAccessor<DoFHandler_type, lda> CellAccessor;
-      typedef dealii::DoFAccessor<0, DoFHandler_type, lda>  FaceAccessor;
-
-      typedef TriaRawIterator<CellAccessor>    raw_line_iterator;
-      typedef TriaIterator<CellAccessor>       line_iterator;
-      typedef TriaActiveIterator<CellAccessor> active_line_iterator;
-
-      typedef TriaRawIterator<DoFInvalidAccessor<2, 1, spacedim>>
-                                                               raw_quad_iterator;
-      typedef TriaIterator<DoFInvalidAccessor<2, 1, spacedim>> quad_iterator;
-      typedef TriaActiveIterator<DoFInvalidAccessor<2, 1, spacedim>>
-        active_quad_iterator;
-
-      typedef TriaRawIterator<DoFInvalidAccessor<3, 1, spacedim>>
-                                                               raw_hex_iterator;
-      typedef TriaIterator<DoFInvalidAccessor<3, 1, spacedim>> hex_iterator;
-      typedef TriaActiveIterator<DoFInvalidAccessor<3, 1, spacedim>>
-        active_hex_iterator;
-
-      typedef raw_line_iterator    raw_cell_iterator;
-      typedef line_iterator        cell_iterator;
-      typedef active_line_iterator active_cell_iterator;
-
-      typedef TriaRawIterator<FaceAccessor>    raw_face_iterator;
-      typedef TriaIterator<FaceAccessor>       face_iterator;
-      typedef TriaActiveIterator<FaceAccessor> active_face_iterator;
+      using DoFHandler_type = DoFHandlerType<1, spacedim>;
+      using CellAccessor    = dealii::DoFCellAccessor<DoFHandler_type, lda>;
+      using FaceAccessor    = dealii::DoFAccessor<0, DoFHandler_type, lda>;
+
+      using raw_line_iterator    = TriaRawIterator<CellAccessor>;
+      using line_iterator        = TriaIterator<CellAccessor>;
+      using active_line_iterator = TriaActiveIterator<CellAccessor>;
+
+      using raw_quad_iterator =
+        TriaRawIterator<DoFInvalidAccessor<2, 1, spacedim>>;
+      using quad_iterator = TriaIterator<DoFInvalidAccessor<2, 1, spacedim>>;
+      using active_quad_iterator =
+        TriaActiveIterator<DoFInvalidAccessor<2, 1, spacedim>>;
+
+      using raw_hex_iterator =
+        TriaRawIterator<DoFInvalidAccessor<3, 1, spacedim>>;
+      using hex_iterator = TriaIterator<DoFInvalidAccessor<3, 1, spacedim>>;
+      using active_hex_iterator =
+        TriaActiveIterator<DoFInvalidAccessor<3, 1, spacedim>>;
+
+      using raw_cell_iterator    = raw_line_iterator;
+      using cell_iterator        = line_iterator;
+      using active_cell_iterator = active_line_iterator;
+
+      using raw_face_iterator    = TriaRawIterator<FaceAccessor>;
+      using face_iterator        = TriaIterator<FaceAccessor>;
+      using active_face_iterator = TriaActiveIterator<FaceAccessor>;
     };
 
 
@@ -105,31 +105,31 @@ namespace internal
     template <template <int, int> class DoFHandlerType, int spacedim, bool lda>
     struct Iterators<DoFHandlerType<2, spacedim>, lda>
     {
-      typedef DoFHandlerType<2, spacedim>                   DoFHandler_type;
-      typedef dealii::DoFCellAccessor<DoFHandler_type, lda> CellAccessor;
-      typedef dealii::DoFAccessor<1, DoFHandler_type, lda>  FaceAccessor;
-
-      typedef TriaRawIterator<FaceAccessor>    raw_line_iterator;
-      typedef TriaIterator<FaceAccessor>       line_iterator;
-      typedef TriaActiveIterator<FaceAccessor> active_line_iterator;
-
-      typedef TriaRawIterator<CellAccessor>    raw_quad_iterator;
-      typedef TriaIterator<CellAccessor>       quad_iterator;
-      typedef TriaActiveIterator<CellAccessor> active_quad_iterator;
-
-      typedef TriaRawIterator<DoFInvalidAccessor<3, 2, spacedim>>
-                                                               raw_hex_iterator;
-      typedef TriaIterator<DoFInvalidAccessor<3, 2, spacedim>> hex_iterator;
-      typedef TriaActiveIterator<DoFInvalidAccessor<3, 2, spacedim>>
-        active_hex_iterator;
-
-      typedef raw_quad_iterator    raw_cell_iterator;
-      typedef quad_iterator        cell_iterator;
-      typedef active_quad_iterator active_cell_iterator;
-
-      typedef raw_line_iterator    raw_face_iterator;
-      typedef line_iterator        face_iterator;
-      typedef active_line_iterator active_face_iterator;
+      using DoFHandler_type = DoFHandlerType<2, spacedim>;
+      using CellAccessor    = dealii::DoFCellAccessor<DoFHandler_type, lda>;
+      using FaceAccessor    = dealii::DoFAccessor<1, DoFHandler_type, lda>;
+
+      using raw_line_iterator    = TriaRawIterator<FaceAccessor>;
+      using line_iterator        = TriaIterator<FaceAccessor>;
+      using active_line_iterator = TriaActiveIterator<FaceAccessor>;
+
+      using raw_quad_iterator    = TriaRawIterator<CellAccessor>;
+      using quad_iterator        = TriaIterator<CellAccessor>;
+      using active_quad_iterator = TriaActiveIterator<CellAccessor>;
+
+      using raw_hex_iterator =
+        TriaRawIterator<DoFInvalidAccessor<3, 2, spacedim>>;
+      using hex_iterator = TriaIterator<DoFInvalidAccessor<3, 2, spacedim>>;
+      using active_hex_iterator =
+        TriaActiveIterator<DoFInvalidAccessor<3, 2, spacedim>>;
+
+      using raw_cell_iterator    = raw_quad_iterator;
+      using cell_iterator        = quad_iterator;
+      using active_cell_iterator = active_quad_iterator;
+
+      using raw_face_iterator    = raw_line_iterator;
+      using face_iterator        = line_iterator;
+      using active_face_iterator = active_line_iterator;
     };
 
 
@@ -149,32 +149,32 @@ namespace internal
     template <template <int, int> class DoFHandlerType, int spacedim, bool lda>
     struct Iterators<DoFHandlerType<3, spacedim>, lda>
     {
-      typedef DoFHandlerType<3, spacedim>                   DoFHandler_type;
-      typedef dealii::DoFCellAccessor<DoFHandler_type, lda> CellAccessor;
-      typedef dealii::DoFAccessor<2, DoFHandler_type, lda>  FaceAccessor;
-
-      typedef TriaRawIterator<dealii::DoFAccessor<1, DoFHandler_type, lda>>
-        raw_line_iterator;
-      typedef TriaIterator<dealii::DoFAccessor<1, DoFHandler_type, lda>>
-        line_iterator;
-      typedef TriaActiveIterator<dealii::DoFAccessor<1, DoFHandler_type, lda>>
-        active_line_iterator;
-
-      typedef TriaRawIterator<FaceAccessor>    raw_quad_iterator;
-      typedef TriaIterator<FaceAccessor>       quad_iterator;
-      typedef TriaActiveIterator<FaceAccessor> active_quad_iterator;
-
-      typedef TriaRawIterator<CellAccessor>    raw_hex_iterator;
-      typedef TriaIterator<CellAccessor>       hex_iterator;
-      typedef TriaActiveIterator<CellAccessor> active_hex_iterator;
-
-      typedef raw_hex_iterator    raw_cell_iterator;
-      typedef hex_iterator        cell_iterator;
-      typedef active_hex_iterator active_cell_iterator;
-
-      typedef raw_quad_iterator    raw_face_iterator;
-      typedef quad_iterator        face_iterator;
-      typedef active_quad_iterator active_face_iterator;
+      using DoFHandler_type = DoFHandlerType<3, spacedim>;
+      using CellAccessor    = dealii::DoFCellAccessor<DoFHandler_type, lda>;
+      using FaceAccessor    = dealii::DoFAccessor<2, DoFHandler_type, lda>;
+
+      using raw_line_iterator =
+        TriaRawIterator<dealii::DoFAccessor<1, DoFHandler_type, lda>>;
+      using line_iterator =
+        TriaIterator<dealii::DoFAccessor<1, DoFHandler_type, lda>>;
+      using active_line_iterator =
+        TriaActiveIterator<dealii::DoFAccessor<1, DoFHandler_type, lda>>;
+
+      using raw_quad_iterator    = TriaRawIterator<FaceAccessor>;
+      using quad_iterator        = TriaIterator<FaceAccessor>;
+      using active_quad_iterator = TriaActiveIterator<FaceAccessor>;
+
+      using raw_hex_iterator    = TriaRawIterator<CellAccessor>;
+      using hex_iterator        = TriaIterator<CellAccessor>;
+      using active_hex_iterator = TriaActiveIterator<CellAccessor>;
+
+      using raw_cell_iterator    = raw_hex_iterator;
+      using cell_iterator        = hex_iterator;
+      using active_cell_iterator = active_hex_iterator;
+
+      using raw_face_iterator    = raw_quad_iterator;
+      using face_iterator        = quad_iterator;
+      using active_face_iterator = active_quad_iterator;
     };
   } // namespace DoFHandlerImplementation
 } // namespace internal
index aaa5297c54d6634fcddc754b27939225d16aa1d0..56daaa1e7186032b7592dd2f4b79d6761e3b0767 100644 (file)
@@ -83,7 +83,7 @@ namespace FETools
 
     private:
       // A shortcut for the type of the OutVector
-      typedef typename OutVector::value_type value_type;
+      using value_type = typename OutVector::value_type;
 
       // A structure holding all data to
       // set dofs recursively on cells of arbitrary level
index a9a9a740f58c1b29fe3a47957c45f99dd83ed3c4..2399adec307f81abd4818478d743e3985806a23c 100644 (file)
@@ -552,23 +552,23 @@ namespace internal
        * components are non-zero and thus have a row in the array presently
        * under discussion.
        */
-      typedef dealii::Table<2, double> ShapeVector;
+      using ShapeVector = dealii::Table<2, double>;
 
       /**
        * Storage type for gradients. The layout of data is the same as for the
        * #ShapeVector data type.
        */
-      typedef dealii::Table<2, Tensor<1, spacedim>> GradientVector;
+      using GradientVector = dealii::Table<2, Tensor<1, spacedim>>;
 
       /**
        * Likewise for second order derivatives.
        */
-      typedef dealii::Table<2, Tensor<2, spacedim>> HessianVector;
+      using HessianVector = dealii::Table<2, Tensor<2, spacedim>>;
 
       /**
        * And the same also applies to the third order derivatives.
        */
-      typedef dealii::Table<2, Tensor<3, spacedim>> ThirdDerivativeVector;
+      using ThirdDerivativeVector = dealii::Table<2, Tensor<3, spacedim>>;
 
       /**
        * Store the values of the shape functions at the quadrature points. See
index 5437f9eb9fed500d729d11fb481ea9f85d129ab0..37e2a52a3ebeffcd6e42e998db70c2fd7affb02e 100644 (file)
@@ -76,7 +76,7 @@ namespace internal
   template <class NumberType>
   struct CurlType<1, NumberType>
   {
-    typedef Tensor<1, 1, NumberType> type;
+    using type = Tensor<1, 1, NumberType>;
   };
 
   /**
@@ -88,7 +88,7 @@ namespace internal
   template <class NumberType>
   struct CurlType<2, NumberType>
   {
-    typedef Tensor<1, 1, NumberType> type;
+    using type = Tensor<1, 1, NumberType>;
   };
 
   /**
@@ -100,7 +100,7 @@ namespace internal
   template <class NumberType>
   struct CurlType<3, NumberType>
   {
-    typedef Tensor<1, 3, NumberType> type;
+    using type = Tensor<1, 3, NumberType>;
   };
 } // namespace internal
 
@@ -145,32 +145,32 @@ namespace FEValuesViews
   {
   public:
     /**
-     * A typedef for the data type of values of the view this class
+     * An alias for the data type of values of the view this class
      * represents. Since we deal with a single components, the value type is a
      * scalar double.
      */
-    typedef double value_type;
+    using value_type = double;
 
     /**
-     * A typedef for the type of gradients of the view this class represents.
+     * An alias for the type of gradients of the view this class represents.
      * Here, for a scalar component of the finite element, the gradient is a
      * <code>Tensor@<1,dim@></code>.
      */
-    typedef dealii::Tensor<1, spacedim> gradient_type;
+    using gradient_type = dealii::Tensor<1, spacedim>;
 
     /**
-     * A typedef for the type of second derivatives of the view this class
+     * An alias for the type of second derivatives of the view this class
      * represents. Here, for a scalar component of the finite element, the
      * Hessian is a <code>Tensor@<2,dim@></code>.
      */
-    typedef dealii::Tensor<2, spacedim> hessian_type;
+    using hessian_type = dealii::Tensor<2, spacedim>;
 
     /**
-     * A typedef for the type of third derivatives of the view this class
+     * An alias for the type of third derivatives of the view this class
      * represents. Here, for a scalar component of the finite element, the
      * Third derivative is a <code>Tensor@<3,dim@></code>.
      */
-    typedef dealii::Tensor<3, spacedim> third_derivative_type;
+    using third_derivative_type = dealii::Tensor<3, spacedim>;
 
     /**
      * A struct that provides the output type for the product of the value
@@ -180,48 +180,44 @@ namespace FEValuesViews
     struct OutputType
     {
       /**
-       * A typedef for the data type of the product of a @p Number and the
+       * An alias for the data type of the product of a @p Number and the
        * values of the view the Scalar class.
        */
-      typedef
+      using value_type =
         typename ProductType<Number,
-                             typename Scalar<dim, spacedim>::value_type>::type
-          value_type;
+                             typename Scalar<dim, spacedim>::value_type>::type;
 
       /**
-       * A typedef for the data type of the product of a @p Number and the
+       * An alias for the data type of the product of a @p Number and the
        * gradients of the view the Scalar class.
        */
-      typedef typename ProductType<
+      using gradient_type = typename ProductType<
         Number,
-        typename Scalar<dim, spacedim>::gradient_type>::type gradient_type;
+        typename Scalar<dim, spacedim>::gradient_type>::type;
 
       /**
-       * A typedef for the data type of the product of a @p Number and the
+       * An alias for the data type of the product of a @p Number and the
        * laplacians of the view the Scalar class.
        */
-      typedef
+      using laplacian_type =
         typename ProductType<Number,
-                             typename Scalar<dim, spacedim>::value_type>::type
-          laplacian_type;
+                             typename Scalar<dim, spacedim>::value_type>::type;
 
       /**
-       * A typedef for the data type of the product of a @p Number and the
+       * An alias for the data type of the product of a @p Number and the
        * hessians of the view the Scalar class.
        */
-      typedef
-        typename ProductType<Number,
-                             typename Scalar<dim, spacedim>::hessian_type>::type
-          hessian_type;
+      using hessian_type = typename ProductType<
+        Number,
+        typename Scalar<dim, spacedim>::hessian_type>::type;
 
       /**
-       * A typedef for the data type of the product of a @p Number and the
+       * An alias for the data type of the product of a @p Number and the
        * third derivatives of the view the Scalar class.
        */
-      typedef typename ProductType<
+      using third_derivative_type = typename ProductType<
         Number,
-        typename Scalar<dim, spacedim>::third_derivative_type>::type
-        third_derivative_type;
+        typename Scalar<dim, spacedim>::third_derivative_type>::type;
     };
 
     /**
@@ -585,24 +581,24 @@ namespace FEValuesViews
   {
   public:
     /**
-     * A typedef for the data type of values of the view this class
+     * An alias for the data type of values of the view this class
      * represents. Since we deal with a set of <code>dim</code> components,
      * the value type is a Tensor<1,spacedim>.
      */
-    typedef dealii::Tensor<1, spacedim> value_type;
+    using value_type = dealii::Tensor<1, spacedim>;
 
     /**
-     * A typedef for the type of gradients of the view this class represents.
+     * An alias for the type of gradients of the view this class represents.
      * Here, for a set of <code>dim</code> components of the finite element,
      * the gradient is a <code>Tensor@<2,spacedim@></code>.
      *
      * See the general documentation of this class for how exactly the
      * gradient of a vector is defined.
      */
-    typedef dealii::Tensor<2, spacedim> gradient_type;
+    using gradient_type = dealii::Tensor<2, spacedim>;
 
     /**
-     * A typedef for the type of symmetrized gradients of the view this class
+     * An alias for the type of symmetrized gradients of the view this class
      * represents. Here, for a set of <code>dim</code> components of the
      * finite element, the symmetrized gradient is a
      * <code>SymmetricTensor@<2,spacedim@></code>.
@@ -611,36 +607,36 @@ namespace FEValuesViews
      * $\varepsilon(\mathbf v)=\frac 12 (\nabla \mathbf v + \nabla \mathbf
      * v^T)$.
      */
-    typedef dealii::SymmetricTensor<2, spacedim> symmetric_gradient_type;
+    using symmetric_gradient_type = dealii::SymmetricTensor<2, spacedim>;
 
     /**
-     * A typedef for the type of the divergence of the view this class
+     * An alias for the type of the divergence of the view this class
      * represents. Here, for a set of <code>dim</code> components of the
      * finite element, the divergence of course is a scalar.
      */
-    typedef double divergence_type;
+    using divergence_type = double;
 
     /**
-     * A typedef for the type of the curl of the view this class represents.
+     * An alias for the type of the curl of the view this class represents.
      * Here, for a set of <code>spacedim=2</code> components of the finite
      * element, the curl is a <code>Tensor@<1, 1@></code>. For
      * <code>spacedim=3</code> it is a <code>Tensor@<1, dim@></code>.
      */
-    typedef typename dealii::internal::CurlType<spacedim>::type curl_type;
+    using curl_type = typename dealii::internal::CurlType<spacedim>::type;
 
     /**
-     * A typedef for the type of second derivatives of the view this class
+     * An alias for the type of second derivatives of the view this class
      * represents. Here, for a set of <code>dim</code> components of the
      * finite element, the Hessian is a <code>Tensor@<3,dim@></code>.
      */
-    typedef dealii::Tensor<3, spacedim> hessian_type;
+    using hessian_type = dealii::Tensor<3, spacedim>;
 
     /**
-     * A typedef for the type of third derivatives of the view this class
+     * An alias for the type of third derivatives of the view this class
      * represents. Here, for a set of <code>dim</code> components of the
      * finite element, the third derivative is a <code>Tensor@<4,dim@></code>.
      */
-    typedef dealii::Tensor<4, spacedim> third_derivative_type;
+    using third_derivative_type = dealii::Tensor<4, spacedim>;
 
     /**
      * A struct that provides the output type for the product of the value
@@ -650,74 +646,68 @@ namespace FEValuesViews
     struct OutputType
     {
       /**
-       * A typedef for the data type of the product of a @p Number and the
+       * An alias for the data type of the product of a @p Number and the
        * values of the view the Vector class.
        */
-      typedef
+      using value_type =
         typename ProductType<Number,
-                             typename Vector<dim, spacedim>::value_type>::type
-          value_type;
+                             typename Vector<dim, spacedim>::value_type>::type;
 
       /**
-       * A typedef for the data type of the product of a @p Number and the
+       * An alias for the data type of the product of a @p Number and the
        * gradients of the view the Vector class.
        */
-      typedef typename ProductType<
+      using gradient_type = typename ProductType<
         Number,
-        typename Vector<dim, spacedim>::gradient_type>::type gradient_type;
+        typename Vector<dim, spacedim>::gradient_type>::type;
 
       /**
-       * A typedef for the data type of the product of a @p Number and the
+       * An alias for the data type of the product of a @p Number and the
        * symmetric gradients of the view the Vector class.
        */
-      typedef typename ProductType<
+      using symmetric_gradient_type = typename ProductType<
         Number,
-        typename Vector<dim, spacedim>::symmetric_gradient_type>::type
-        symmetric_gradient_type;
+        typename Vector<dim, spacedim>::symmetric_gradient_type>::type;
 
       /**
-       * A typedef for the data type of the product of a @p Number and the
+       * An alias for the data type of the product of a @p Number and the
        * divergences of the view the Vector class.
        */
-      typedef typename ProductType<
+      using divergence_type = typename ProductType<
         Number,
-        typename Vector<dim, spacedim>::divergence_type>::type divergence_type;
+        typename Vector<dim, spacedim>::divergence_type>::type;
 
       /**
-       * A typedef for the data type of the product of a @p Number and the
+       * An alias for the data type of the product of a @p Number and the
        * laplacians of the view the Vector class.
        */
-      typedef
+      using laplacian_type =
         typename ProductType<Number,
-                             typename Vector<dim, spacedim>::value_type>::type
-          laplacian_type;
+                             typename Vector<dim, spacedim>::value_type>::type;
 
       /**
-       * A typedef for the data type of the product of a @p Number and the
+       * An alias for the data type of the product of a @p Number and the
        * curls of the view the Vector class.
        */
-      typedef
+      using curl_type =
         typename ProductType<Number,
-                             typename Vector<dim, spacedim>::curl_type>::type
-          curl_type;
+                             typename Vector<dim, spacedim>::curl_type>::type;
 
       /**
-       * A typedef for the data type of the product of a @p Number and the
+       * An alias for the data type of the product of a @p Number and the
        * hessians of the view the Vector class.
        */
-      typedef
-        typename ProductType<Number,
-                             typename Vector<dim, spacedim>::hessian_type>::type
-          hessian_type;
+      using hessian_type = typename ProductType<
+        Number,
+        typename Vector<dim, spacedim>::hessian_type>::type;
 
       /**
-       * A typedef for the data type of the product of a @p Number and the
+       * An alias for the data type of the product of a @p Number and the
        * third derivatives of the view the Vector class.
        */
-      typedef typename ProductType<
+      using third_derivative_type = typename ProductType<
         Number,
-        typename Vector<dim, spacedim>::third_derivative_type>::type
-        third_derivative_type;
+        typename Vector<dim, spacedim>::third_derivative_type>::type;
     };
 
     /**
@@ -1267,15 +1257,15 @@ namespace FEValuesViews
   {
   public:
     /**
-     * A typedef for the data type of values of the view this class
+     * An alias for the data type of values of the view this class
      * represents. Since we deal with a set of <code>(dim*dim + dim)/2</code>
      * components (i.e. the unique components of a symmetric second-order
      * tensor), the value type is a SymmetricTensor<2,spacedim>.
      */
-    typedef dealii::SymmetricTensor<2, spacedim> value_type;
+    using value_type = dealii::SymmetricTensor<2, spacedim>;
 
     /**
-     * A typedef for the type of the divergence of the view this class
+     * An alias for the type of the divergence of the view this class
      * represents. Here, for a set of <code>(dim*dim + dim)/2</code> unique
      * components of the finite element representing a symmetric second-order
      * tensor, the divergence of course is a * <code>Tensor@<1,dim@></code>.
@@ -1283,7 +1273,7 @@ namespace FEValuesViews
      * See the general discussion of this class for a definition of the
      * divergence.
      */
-    typedef dealii::Tensor<1, spacedim> divergence_type;
+    using divergence_type = dealii::Tensor<1, spacedim>;
 
     /**
      * A struct that provides the output type for the product of the value
@@ -1293,22 +1283,20 @@ namespace FEValuesViews
     struct OutputType
     {
       /**
-       * A typedef for the data type of the product of a @p Number and the
+       * An alias for the data type of the product of a @p Number and the
        * values of the view the SymmetricTensor class.
        */
-      typedef typename ProductType<
+      using value_type = typename ProductType<
         Number,
-        typename SymmetricTensor<2, dim, spacedim>::value_type>::type
-        value_type;
+        typename SymmetricTensor<2, dim, spacedim>::value_type>::type;
 
       /**
-       * A typedef for the data type of the product of a @p Number and the
+       * An alias for the data type of the product of a @p Number and the
        * divergences of the view the SymmetricTensor class.
        */
-      typedef typename ProductType<
+      using divergence_type = typename ProductType<
         Number,
-        typename SymmetricTensor<2, dim, spacedim>::divergence_type>::type
-        divergence_type;
+        typename SymmetricTensor<2, dim, spacedim>::divergence_type>::type;
     };
 
     /**
@@ -1560,18 +1548,18 @@ namespace FEValuesViews
      * Data type for what you get when you apply an extractor of this kind to
      * a vector-valued finite element.
      */
-    typedef dealii::Tensor<2, spacedim> value_type;
+    using value_type = dealii::Tensor<2, spacedim>;
 
     /**
      * Data type for taking the divergence of a tensor: a vector.
      */
-    typedef dealii::Tensor<1, spacedim> divergence_type;
+    using divergence_type = dealii::Tensor<1, spacedim>;
 
     /**
      * Data type for taking the gradient of a second order tensor: a third order
      * tensor.
      */
-    typedef dealii::Tensor<3, spacedim> gradient_type;
+    using gradient_type = dealii::Tensor<3, spacedim>;
 
     /**
      * A struct that provides the output type for the product of the value
@@ -1581,29 +1569,28 @@ namespace FEValuesViews
     struct OutputType
     {
       /**
-       * A typedef for the data type of the product of a @p Number and the
+       * An alias for the data type of the product of a @p Number and the
        * values of the view the Tensor class.
        */
-      typedef typename ProductType<
+      using value_type = typename ProductType<
         Number,
-        typename Tensor<2, dim, spacedim>::value_type>::type value_type;
+        typename Tensor<2, dim, spacedim>::value_type>::type;
 
       /**
-       * A typedef for the data type of the product of a @p Number and the
+       * An alias for the data type of the product of a @p Number and the
        * divergences of the view the Tensor class.
        */
-      typedef typename ProductType<
+      using divergence_type = typename ProductType<
         Number,
-        typename Tensor<2, dim, spacedim>::divergence_type>::type
-        divergence_type;
+        typename Tensor<2, dim, spacedim>::divergence_type>::type;
 
       /**
-       * A typedef for the data type of the product of a @p Number and the
+       * An alias for the data type of the product of a @p Number and the
        * gradient of the view the Tensor class.
        */
-      typedef typename ProductType<
+      using gradient_type = typename ProductType<
         Number,
-        typename Tensor<2, dim, spacedim>::gradient_type>::type gradient_type;
+        typename Tensor<2, dim, spacedim>::gradient_type>::type;
     };
 
     /**
index fc82364fd8d355cd73cca268b8e876ab63d4c6af..871fd2a58bbff37680968f902b7a1fe11c5bcb27 100644 (file)
@@ -70,7 +70,7 @@ public:
    * (using 2 times 32 bit for storage), a limitation that is identical to
    * the one used by p4est.
    */
-  typedef std::array<unsigned int, 4> binary_type;
+  using binary_type = std::array<unsigned int, 4>;
 
   /**
    * Construct a CellId object with a given @p coarse_cell_id and vector of
index b9119a24b9d01246077e1e927dd7e1416f1cc600..7a08dc63be2a65414a287560f6452089cc0f5278 100644 (file)
@@ -486,10 +486,13 @@ namespace IteratorFilters
  *
  * The same can be achieved by the following snippet, though harder to read:
  * @code
- *   typedef FilteredIterator<typename Triangulation<dim>::active_cell_iterator>
- * FI; n_flagged_cells = std::distance (FI(IteratorFilters::UserFlagSet())
- *                            .set_to_next_positive(tria.begin_active()),
- *                     FI(IteratorFilters::UserFlagSet(), tria.end()));
+ *   using FI =
+ *     FilteredIterator<typename Triangulation<dim>::active_cell_iterator>;
+ *   n_flagged_cells =
+ *     std::distance (
+ *       FI(IteratorFilters::UserFlagSet()).set_to_next_positive(
+ *         tria.begin_active()),
+ *       FI(IteratorFilters::UserFlagSet(), tria.end()));
  * @endcode
  * It relies on the fact that if we create an unnamed filtered iterator with a
  * given predicate but no iterator value and assign it the next positive value
@@ -526,7 +529,7 @@ public:
   /**
    * Typedef to the accessor type of the underlying iterator.
    */
-  typedef typename BaseIterator::AccessorType AccessorType;
+  using AccessorType = typename BaseIterator::AccessorType;
 
   /**
    * Constructor. Set the iterator to the default state and use the given
@@ -812,16 +815,15 @@ namespace internal
     template <typename BaseIterator, typename Predicate>
     struct NestFilteredIterators<BaseIterator, std::tuple<Predicate>>
     {
-      typedef ::dealii::FilteredIterator<BaseIterator> type;
+      using type = ::dealii::FilteredIterator<BaseIterator>;
     };
 
     template <typename BaseIterator, typename Predicate, typename... Targs>
     struct NestFilteredIterators<BaseIterator, std::tuple<Predicate, Targs...>>
     {
-      typedef ::dealii::FilteredIterator<
+      using type = ::dealii::FilteredIterator<
         typename NestFilteredIterators<BaseIterator,
-                                       std::tuple<Targs...>>::type>
-        type;
+                                       std::tuple<Targs...>>::type>;
     };
   } // namespace FilteredIteratorImplementation
 } // namespace internal
index 38b1e6a25baed734312173bc2686d00b8749f0f9..e9f7e9f214feff0dcef90e3766ca86ab8ce21d58 100644 (file)
@@ -1184,9 +1184,9 @@ namespace GridGenerator
   template <template <int, int> class MeshType, int dim, int spacedim>
   struct ExtractBoundaryMesh
   {
-    typedef std::map<typename MeshType<dim - 1, spacedim>::cell_iterator,
-                     typename MeshType<dim, spacedim>::face_iterator>
-      return_type;
+    using return_type =
+      std::map<typename MeshType<dim - 1, spacedim>::cell_iterator,
+               typename MeshType<dim, spacedim>::face_iterator>;
   };
 #endif
 
index fa217687d55ee9eceac3dd35423094dc913ddc34..546cdded4ebc53e0cb95a2b4fb52af968627c24b 100644 (file)
@@ -80,9 +80,9 @@ namespace internal
   {
   public:
 #  ifndef _MSC_VER
-    typedef typename MeshType::active_cell_iterator type;
+    using type = typename MeshType::active_cell_iterator;
 #  else
-    typedef TriaActiveIterator<dealii::CellAccessor<dim, spacedim>> type;
+    using type = TriaActiveIterator<dealii::CellAccessor<dim, spacedim>>;
 #  endif
   };
 
@@ -91,18 +91,16 @@ namespace internal
   class ActiveCellIterator<dim, spacedim, dealii::DoFHandler<dim, spacedim>>
   {
   public:
-    typedef TriaActiveIterator<
-      dealii::DoFCellAccessor<dealii::DoFHandler<dim, spacedim>, false>>
-      type;
+    using type = TriaActiveIterator<
+      dealii::DoFCellAccessor<dealii::DoFHandler<dim, spacedim>, false>>;
   };
 
   template <int dim, int spacedim>
   class ActiveCellIterator<dim, spacedim, dealii::hp::DoFHandler<dim, spacedim>>
   {
   public:
-    typedef TriaActiveIterator<
-      dealii::DoFCellAccessor<dealii::hp::DoFHandler<dim, spacedim>, false>>
-      type;
+    using type = TriaActiveIterator<
+      dealii::DoFCellAccessor<dealii::hp::DoFHandler<dim, spacedim>, false>>;
   };
 #  endif
 } // namespace internal
@@ -737,7 +735,7 @@ namespace GridTools
    * describes the locally owned part of the mesh for each process. The bounding
    * boxes describing which part of the mesh is locally owned by process with
    * rank rk are contained in global_bboxes[rk]. The local description can be
-   * obtained from GridTools::compute_mesh_predicate_bounding_box ; then the
+   * obtained from GridTools::compute_mesh_predicate_bounding_box; then the
    * global one can be obtained using either
    * GridTools::exchange_local_bounding_boxes or Utilities::MPI::all_gather
    * @return A tuple containing the quadrature information
@@ -3558,9 +3556,9 @@ namespace GridTools
         "The function exchange_cell_data_to_ghosts() only works with parallel triangulations."));
 
     // map neighbor_id -> data_buffer where we accumulate the data to send
-    typedef std::map<dealii::types::subdomain_id,
-                     CellDataTransferBuffer<dim, DataType>>
-                           DestinationToBufferMap;
+    using DestinationToBufferMap =
+      std::map<dealii::types::subdomain_id,
+               CellDataTransferBuffer<dim, DataType>>;
     DestinationToBufferMap destination_to_data_buffer_map;
 
     std::map<unsigned int, std::set<dealii::types::subdomain_id>>
index a8e9be9827a6cc7cb235e363b538e5e9c02c22e6..7fa7e31ef6e96802941eb8d28b4b232a07e34634 100644 (file)
@@ -118,7 +118,7 @@ public:
   /**
    * Typedef to the iterator type of the grid class under consideration.
    */
-  typedef typename MeshType::cell_iterator cell_iterator;
+  using cell_iterator = typename MeshType::cell_iterator;
 
   /**
    * Constructor setting the class name arguments in the SmartPointer members.
index f182bda310309928a7174a1fdaa6e2a0f0555bc3..49cdc309ba7364a2bb2dac4a89522dae3edf388a 100644 (file)
@@ -346,8 +346,8 @@ public:
    *
    * For obvious reasons, this type is not useful in 1d.
    */
-  typedef Tensor<1, spacedim>
-    FaceVertexNormals[GeometryInfo<dim>::vertices_per_face];
+  using FaceVertexNormals =
+    std::array<Tensor<1, spacedim>, GeometryInfo<dim>::vertices_per_face>;
 
 
   /**
index 57b4177b85932e0f929da628cef2656b063e1128..17cdad1fed4380f782b3b3b000b119a88aff8bdc 100644 (file)
@@ -524,13 +524,13 @@ namespace internal
  * quite inconvenient if one attempted to operate on it directly, since data
  * is spread over quite a lot of arrays and other places. However, there are
  * ways powerful enough to work on these data structures without knowing their
- * exact relations. deal.II uses class local typedefs (see below) to make
+ * exact relations. deal.II uses class local alias (see below) to make
  * things as easy and dimension independent as possible.
  *
  * The Triangulation class provides iterators which enable looping over all
  * cells without knowing the exact representation used to describe them. For
  * more information see the documentation of <tt>TriaIterator</tt>. Their
- * names are typedefs imported from the Iterators class (thus making them
+ * names are alias imported from the Iterators class (thus making them
  * local types to this class) and are as follows:
  *
  * <ul>
@@ -540,16 +540,16 @@ namespace internal
  *
  * For <tt>dim==1</tt>, these iterators are mapped as follows:
  *  @code
- *    typedef line_iterator        cell_iterator;
- *    typedef active_line_iterator active_cell_iterator;
+ *    using cell_iterator = line_iterator;
+ *    using active_cell_iterator = active_line_iterator;
  *  @endcode
  * while for @p dim==2 we have the additional face iterator:
  *  @code
- *    typedef quad_iterator        cell_iterator;
- *    typedef active_quad_iterator active_cell_iterator;
+ *    using cell_iterator = quad_iterator;
+ *    using active_cell_iterator = active_quad_iterator;
  *
- *    typedef line_iterator        face_iterator;
- *    typedef active_line_iterator active_face_iterator;
+ *    using face_iterator = line_iterator;
+ *    using active_face_iterator = active_line_iterator;
  *  @endcode
  *
  * By using the cell iterators, you can write code independent of the spatial
@@ -1281,12 +1281,11 @@ class Triangulation : public Subscriptor
 {
 private:
   /**
-   * An internal typedef to make the definition of the iterator classes
+   * An internal alias to make the definition of the iterator classes
    * simpler.
    */
-  typedef dealii::internal::TriangulationImplementation::Iterators<dim,
-                                                                   spacedim>
-    IteratorSelector;
+  using IteratorSelector =
+    dealii::internal::TriangulationImplementation::Iterators<dim, spacedim>;
 
 public:
   /**
@@ -1494,11 +1493,11 @@ public:
   };
 
   /**
-   * A typedef that is used to identify cell iterators. The concept of
+   * An alias that is used to identify cell iterators. The concept of
    * iterators is discussed at length in the
    * @ref Iterators "iterators documentation module".
    *
-   * The current typedef identifies cells in a triangulation. The TriaIterator
+   * The current alias identifies cells in a triangulation. The TriaIterator
    * class works like a pointer that when you dereference it yields an object
    * of type CellAccessor. CellAccessor is a class that identifies properties
    * that are specific to cells in a triangulation, but it is derived (and
@@ -1508,15 +1507,15 @@ public:
    *
    * @ingroup Iterators
    */
-  typedef TriaIterator<CellAccessor<dim, spacedim>> cell_iterator;
+  using cell_iterator = TriaIterator<CellAccessor<dim, spacedim>>;
 
   /**
-   * A typedef that is used to identify
+   * An alias that is used to identify
    * @ref GlossActive "active cell iterators".
    * The concept of iterators is discussed at length in the
    * @ref Iterators "iterators documentation module".
    *
-   * The current typedef identifies active cells in a triangulation. The
+   * The current alias identifies active cells in a triangulation. The
    * TriaActiveIterator class works like a pointer to active objects that when
    * you dereference it yields an object of type CellAccessor. CellAccessor is
    * a class that identifies properties that are specific to cells in a
@@ -1526,14 +1525,14 @@ public:
    *
    * @ingroup Iterators
    */
-  typedef TriaActiveIterator<CellAccessor<dim, spacedim>> active_cell_iterator;
+  using active_cell_iterator = TriaActiveIterator<CellAccessor<dim, spacedim>>;
 
   /**
-   * A typedef that is used to identify iterators that point to faces.
+   * An alias that is used to identify iterators that point to faces.
    * The concept of iterators is discussed at length in the
    * @ref Iterators "iterators documentation module".
    *
-   * The current typedef identifies faces in a triangulation. The
+   * The current alias identifies faces in a triangulation. The
    * TriaIterator class works like a pointer to objects that when
    * you dereference it yields an object of type TriaAccessor, i.e.,
    * class that can be used to query geometric properties of faces
@@ -1541,55 +1540,55 @@ public:
    *
    * @ingroup Iterators
    */
-  typedef TriaIterator<TriaAccessor<dim - 1, dim, spacedim>> face_iterator;
+  using face_iterator = TriaIterator<TriaAccessor<dim - 1, dim, spacedim>>;
 
   /**
-   * A typedef that is used to identify iterators that point to active faces,
+   * An alias that is used to identify iterators that point to active faces,
    * i.e., to faces that have no children. Active faces must be faces of at
    * least one active cell.
    *
-   * Other than the "active" qualification, this typedef is identical to the
-   * @p face_iterator typedef. In particular, dereferencing either yields
+   * Other than the "active" qualification, this alias is identical to the
+   * @p face_iterator alias. In particular, dereferencing either yields
    * the same kind of object.
    *
    * @ingroup Iterators
    */
-  typedef TriaActiveIterator<TriaAccessor<dim - 1, dim, spacedim>>
-    active_face_iterator;
+  using active_face_iterator =
+    TriaActiveIterator<TriaAccessor<dim - 1, dim, spacedim>>;
 
   /**
-   * A typedef that defines an iterator type to iterate over
+   * An alias that defines an iterator type to iterate over
    * vertices of a mesh.  The concept of iterators is discussed at
    * length in the
    * @ref Iterators "iterators documentation module".
    *
    * @ingroup Iterators
    */
-  typedef TriaIterator<dealii::TriaAccessor<0, dim, spacedim>> vertex_iterator;
+  using vertex_iterator = TriaIterator<dealii::TriaAccessor<0, dim, spacedim>>;
 
   /**
-   * A typedef that defines an iterator type to iterate over
+   * An alias that defines an iterator type to iterate over
    * vertices of a mesh.  The concept of iterators is discussed at
    * length in the
    * @ref Iterators "iterators documentation module".
    *
-   * This typedef is in fact identical to the @p vertex_iterator typedef
+   * This alias is in fact identical to the @p vertex_iterator alias
    * above since all vertices in a mesh are active (i.e., are a vertex of
    * an active cell).
    *
    * @ingroup Iterators
    */
-  typedef TriaActiveIterator<dealii::TriaAccessor<0, dim, spacedim>>
-    active_vertex_iterator;
+  using active_vertex_iterator =
+    TriaActiveIterator<dealii::TriaAccessor<0, dim, spacedim>>;
 
-  typedef typename IteratorSelector::line_iterator        line_iterator;
-  typedef typename IteratorSelector::active_line_iterator active_line_iterator;
+  using line_iterator        = typename IteratorSelector::line_iterator;
+  using active_line_iterator = typename IteratorSelector::active_line_iterator;
 
-  typedef typename IteratorSelector::quad_iterator        quad_iterator;
-  typedef typename IteratorSelector::active_quad_iterator active_quad_iterator;
+  using quad_iterator        = typename IteratorSelector::quad_iterator;
+  using active_quad_iterator = typename IteratorSelector::active_quad_iterator;
 
-  typedef typename IteratorSelector::hex_iterator        hex_iterator;
-  typedef typename IteratorSelector::active_hex_iterator active_hex_iterator;
+  using hex_iterator        = typename IteratorSelector::hex_iterator;
+  using active_hex_iterator = typename IteratorSelector::active_hex_iterator;
 
   /**
    * A structure that is used as an exception object by the
@@ -2106,7 +2105,7 @@ public:
   template <typename T>
   struct CellWeightSum
   {
-    typedef T result_type;
+    using result_type = T;
 
     template <typename InputIterator>
     T
@@ -3447,14 +3446,14 @@ private:
    * Since users should never have to access these internal properties of how
    * we store data, these iterator types are made private.
    */
-  typedef TriaRawIterator<CellAccessor<dim, spacedim>> raw_cell_iterator;
-  typedef TriaRawIterator<TriaAccessor<dim - 1, dim, spacedim>>
-    raw_face_iterator;
-  typedef TriaRawIterator<dealii::TriaAccessor<0, dim, spacedim>>
-                                                       raw_vertex_iterator;
-  typedef typename IteratorSelector::raw_line_iterator raw_line_iterator;
-  typedef typename IteratorSelector::raw_quad_iterator raw_quad_iterator;
-  typedef typename IteratorSelector::raw_hex_iterator  raw_hex_iterator;
+  using raw_cell_iterator = TriaRawIterator<CellAccessor<dim, spacedim>>;
+  using raw_face_iterator =
+    TriaRawIterator<TriaAccessor<dim - 1, dim, spacedim>>;
+  using raw_vertex_iterator =
+    TriaRawIterator<dealii::TriaAccessor<0, dim, spacedim>>;
+  using raw_line_iterator = typename IteratorSelector::raw_line_iterator;
+  using raw_quad_iterator = typename IteratorSelector::raw_quad_iterator;
+  using raw_hex_iterator  = typename IteratorSelector::raw_hex_iterator;
 
   /**
    * Iterator to the first cell, used or not, on level @p level. If a level
index 499dec666cd65a55a37cc11ccf8eba140371a832..e609989151109432ce6b99b6c7021f6df41b6233 100644 (file)
@@ -116,7 +116,7 @@ namespace internal
     template <int dim>
     struct PresentLevelType<dim, dim>
     {
-      typedef int type;
+      using type = int;
     };
 
   } // namespace TriaAccessorImplementation
@@ -316,7 +316,7 @@ protected:
    * the iterator classes. Since the pure triangulation iterators need no
    * additional data, this data type is @p void.
    */
-  typedef void AccessorData;
+  using AccessorData = void;
 
   /**
    * Constructor. Protected, thus only callable from friend classes.
@@ -423,7 +423,7 @@ public:
    * accessor classes in a unified way, no matter what the type of number of
    * these parameters is.
    */
-  typedef void *LocalData;
+  using LocalData = void *;
 
   /**
    * @name Iterator address and state
@@ -553,10 +553,10 @@ class InvalidAccessor : public TriaAccessorBase<structdim, dim, spacedim>
 {
 public:
   /**
-   * Propagate typedef from base class to this class.
+   * Propagate alias from base class to this class.
    */
-  typedef typename TriaAccessorBase<structdim, dim, spacedim>::AccessorData
-    AccessorData;
+  using AccessorData =
+    typename TriaAccessorBase<structdim, dim, spacedim>::AccessorData;
 
   /**
    * Constructor.  This class is used for iterators that do not make
@@ -676,10 +676,10 @@ class TriaAccessor : public TriaAccessorBase<structdim, dim, spacedim>
 {
 public:
   /**
-   * Propagate typedef from base class to this class.
+   * Propagate alias from base class to this class.
    */
-  typedef typename TriaAccessorBase<structdim, dim, spacedim>::AccessorData
-    AccessorData;
+  using AccessorData =
+    typename TriaAccessorBase<structdim, dim, spacedim>::AccessorData;
 
   /**
    * Constructor.
@@ -1743,7 +1743,7 @@ public:
   /**
    * Pointer to internal data.
    */
-  typedef void AccessorData;
+  using AccessorData = void;
 
   /**
    * Constructor. The second argument is the global index of the vertex we
@@ -2124,7 +2124,7 @@ public:
   /**
    * Pointer to internal data.
    */
-  typedef void AccessorData;
+  using AccessorData = void;
 
   /**
    * Whether the vertex represented here is at the left end of the domain, the
@@ -2585,12 +2585,12 @@ public:
   /**
    * Propagate the AccessorData type into the present class.
    */
-  typedef typename TriaAccessor<dim, dim, spacedim>::AccessorData AccessorData;
+  using AccessorData = typename TriaAccessor<dim, dim, spacedim>::AccessorData;
 
   /**
    * Define the type of the container this is part of.
    */
-  typedef Triangulation<dim, spacedim> Container;
+  using Container = Triangulation<dim, spacedim>;
 
   /**
    * @name Constructors
index 9b4bcf16b57a32a40bf19c8faeffe78397b1627e..0141c517465c55c50a32128269742b879d9b7f75 100644 (file)
@@ -150,7 +150,7 @@ class TriaActiveIterator;
  *
  * <li> It must have void operators <tt>++</tt> and <tt>--</tt>.
  *
- * <li> It must declare a local <tt>typedef AccessorData</tt> which states the
+ * <li> It must declare a local alias <tt>AccessorData</tt> which states the
  * data type the accessor expects to get passed as fourth constructor
  * argument. By declaring a local data type, the respective iterator class may
  * type-safely enforce that data type to be one of its own constructor
@@ -234,7 +234,7 @@ public:
    * other functions can use the Accessor's type without knowledge of how the
    * exact implementation actually is.
    */
-  typedef Accessor AccessorType;
+  using AccessorType = Accessor;
 
   /**
    * Empty constructor. Such an object is not usable!
@@ -486,15 +486,15 @@ public:
   memory_consumption() const;
 
   /**
-   * Mark the class as bidirectional iterator and declare some typedefs which
+   * Mark the class as bidirectional iterator and declare some alias which
    * are standard for iterators and are used by algorithms to enquire about the
    * specifics of the iterators they work on.
    */
-  typedef std::bidirectional_iterator_tag iterator_category;
-  typedef Accessor                        value_type;
-  typedef int                             difference_type;
-  typedef Accessor *                      pointer;
-  typedef Accessor &                      reference;
+  using iterator_category = std::bidirectional_iterator_tag;
+  using value_type        = Accessor;
+  using difference_type   = int;
+  using pointer           = Accessor *;
+  using reference         = Accessor &;
 
   /**@name Exceptions*/
   /*@{*/
@@ -717,16 +717,16 @@ public:
   /*@}*/
 
   /**
-   * Declare some typedefs which are standard for iterators and are used
+   * Declare some alias which are standard for iterators and are used
    * by algorithms to enquire about the specifics of the iterators they
    * work on.
    */
-  typedef
-    typename TriaRawIterator<Accessor>::iterator_category     iterator_category;
-  typedef typename TriaRawIterator<Accessor>::value_type      value_type;
-  typedef typename TriaRawIterator<Accessor>::pointer         pointer;
-  typedef typename TriaRawIterator<Accessor>::reference       reference;
-  typedef typename TriaRawIterator<Accessor>::difference_type difference_type;
+  using iterator_category =
+    typename TriaRawIterator<Accessor>::iterator_category;
+  using value_type      = typename TriaRawIterator<Accessor>::value_type;
+  using pointer         = typename TriaRawIterator<Accessor>::pointer;
+  using reference       = typename TriaRawIterator<Accessor>::reference;
+  using difference_type = typename TriaRawIterator<Accessor>::difference_type;
 
   /**
    * Exception
@@ -906,15 +906,15 @@ public:
   /*@}*/
 
   /**
-   * Declare some typedefs which are standard for iterators and are used
+   * Declare some alias which are standard for iterators and are used
    * by algorithms to enquire about the specifics of the iterators they
    * work on.
    */
-  typedef typename TriaIterator<Accessor>::iterator_category iterator_category;
-  typedef typename TriaIterator<Accessor>::value_type        value_type;
-  typedef typename TriaIterator<Accessor>::pointer           pointer;
-  typedef typename TriaIterator<Accessor>::reference         reference;
-  typedef typename TriaIterator<Accessor>::difference_type   difference_type;
+  using iterator_category = typename TriaIterator<Accessor>::iterator_category;
+  using value_type        = typename TriaIterator<Accessor>::value_type;
+  using pointer           = typename TriaIterator<Accessor>::pointer;
+  using reference         = typename TriaIterator<Accessor>::reference;
+  using difference_type   = typename TriaIterator<Accessor>::difference_type;
 
   /**
    * Exception
index 77b799801e17f9fe2b898c5775840a520af8f73e..8a4f1c52e8e4ec919c8b9f9cc611ee09cccb0b24 100644 (file)
@@ -49,16 +49,16 @@ namespace internal
      * @ref Iterators
      * module for more information.
      *
-     * A @p line_iterator is typedef'd to an iterator operating on the @p
+     * A @p line_iterator is aliased to an iterator operating on the @p
      * lines member variable of a <tt>Triangulation<1></tt> object. An @p
      * active_line_iterator only operates on the active lines. @p
      * raw_line_iterator objects operate on all lines, used or not.
      *
      * Since we are in one dimension, the following identities are declared:
      *  @code
-     *    typedef raw_line_iterator    raw_cell_iterator;
-     *    typedef line_iterator        cell_iterator;
-     *    typedef active_line_iterator active_cell_iterator;
+     *    using raw_cell_iterator = raw_line_iterator;
+     *    using cell_iterator = line_iterator;
+     *    using active_cell_iterator = active_line_iterator;
      *  @endcode
      *
      * To enable the declaration of @p begin_quad and the like in
@@ -76,25 +76,25 @@ namespace internal
     template <int spacedim>
     struct Iterators<1, spacedim>
     {
-      typedef TriaRawIterator<dealii::CellAccessor<1, spacedim>>
-                                                              raw_line_iterator;
-      typedef TriaIterator<dealii::CellAccessor<1, spacedim>> line_iterator;
-      typedef TriaActiveIterator<dealii::CellAccessor<1, spacedim>>
-        active_line_iterator;
-
-      typedef TriaRawIterator<dealii::InvalidAccessor<2, 1, spacedim>>
-        raw_quad_iterator;
-      typedef TriaIterator<dealii::InvalidAccessor<2, 1, spacedim>>
-        quad_iterator;
-      typedef TriaActiveIterator<dealii::InvalidAccessor<2, 1, spacedim>>
-        active_quad_iterator;
-
-      typedef TriaRawIterator<dealii::InvalidAccessor<3, 1, spacedim>>
-        raw_hex_iterator;
-      typedef TriaIterator<dealii::InvalidAccessor<3, 1, spacedim>>
-        hex_iterator;
-      typedef TriaActiveIterator<dealii::InvalidAccessor<3, 1, spacedim>>
-        active_hex_iterator;
+      using raw_line_iterator =
+        TriaRawIterator<dealii::CellAccessor<1, spacedim>>;
+      using line_iterator = TriaIterator<dealii::CellAccessor<1, spacedim>>;
+      using active_line_iterator =
+        TriaActiveIterator<dealii::CellAccessor<1, spacedim>>;
+
+      using raw_quad_iterator =
+        TriaRawIterator<dealii::InvalidAccessor<2, 1, spacedim>>;
+      using quad_iterator =
+        TriaIterator<dealii::InvalidAccessor<2, 1, spacedim>>;
+      using active_quad_iterator =
+        TriaActiveIterator<dealii::InvalidAccessor<2, 1, spacedim>>;
+
+      using raw_hex_iterator =
+        TriaRawIterator<dealii::InvalidAccessor<3, 1, spacedim>>;
+      using hex_iterator =
+        TriaIterator<dealii::InvalidAccessor<3, 1, spacedim>>;
+      using active_hex_iterator =
+        TriaActiveIterator<dealii::InvalidAccessor<3, 1, spacedim>>;
     };
 
 
@@ -105,7 +105,7 @@ namespace internal
      * @ref Iterators
      * module for more information.
      *
-     * A @p line_iterator is typedef'd to an iterator operating on the @p
+     * A @p line_iterator is aliased to an iterator operating on the @p
      * lines member variable of a <tt>Triangulation<2></tt> object. An @p
      * active_line_iterator only operates on the active lines. @p
      * raw_line_iterator objects operate on all lines, used or not. Using @p
@@ -124,13 +124,13 @@ namespace internal
      *
      * Since we are in two dimension, the following identities are declared:
      *  @code
-     *    typedef raw_quad_iterator    raw_cell_iterator;
-     *    typedef quad_iterator        cell_iterator;
-     *    typedef active_quad_iterator active_cell_iterator;
+     *    using raw_cell_iterator = raw_quad_iterator;
+     *    using cell_iterator = quad_iterator;
+     *    using active_cell_iterator = active_quad_iterator;
      *
-     *    typedef raw_line_iterator    raw_face_iterator;
-     *    typedef line_iterator        face_iterator;
-     *    typedef active_line_iterator active_face_iterator;
+     *    using raw_face_iterator = raw_line_iterator;
+     *    using face_iterator = line_iterator;
+     *    using active_face_iterator = active_line_iterator;
      *  @endcode
      *
      * @author Wolfgang Bangerth, 1998
@@ -138,24 +138,24 @@ namespace internal
     template <int spacedim>
     struct Iterators<2, spacedim>
     {
-      typedef TriaRawIterator<dealii::TriaAccessor<1, 2, spacedim>>
-                                                                 raw_line_iterator;
-      typedef TriaIterator<dealii::TriaAccessor<1, 2, spacedim>> line_iterator;
-      typedef TriaActiveIterator<dealii::TriaAccessor<1, 2, spacedim>>
-        active_line_iterator;
-
-      typedef TriaRawIterator<dealii::CellAccessor<2, spacedim>>
-                                                              raw_quad_iterator;
-      typedef TriaIterator<dealii::CellAccessor<2, spacedim>> quad_iterator;
-      typedef TriaActiveIterator<dealii::CellAccessor<2, spacedim>>
-        active_quad_iterator;
-
-      typedef TriaRawIterator<dealii::InvalidAccessor<3, 2, spacedim>>
-        raw_hex_iterator;
-      typedef TriaIterator<dealii::InvalidAccessor<3, 2, spacedim>>
-        hex_iterator;
-      typedef TriaActiveIterator<dealii::InvalidAccessor<3, 2, spacedim>>
-        active_hex_iterator;
+      using raw_line_iterator =
+        TriaRawIterator<dealii::TriaAccessor<1, 2, spacedim>>;
+      using line_iterator = TriaIterator<dealii::TriaAccessor<1, 2, spacedim>>;
+      using active_line_iterator =
+        TriaActiveIterator<dealii::TriaAccessor<1, 2, spacedim>>;
+
+      using raw_quad_iterator =
+        TriaRawIterator<dealii::CellAccessor<2, spacedim>>;
+      using quad_iterator = TriaIterator<dealii::CellAccessor<2, spacedim>>;
+      using active_quad_iterator =
+        TriaActiveIterator<dealii::CellAccessor<2, spacedim>>;
+
+      using raw_hex_iterator =
+        TriaRawIterator<dealii::InvalidAccessor<3, 2, spacedim>>;
+      using hex_iterator =
+        TriaIterator<dealii::InvalidAccessor<3, 2, spacedim>>;
+      using active_hex_iterator =
+        TriaActiveIterator<dealii::InvalidAccessor<3, 2, spacedim>>;
     };
 
 
@@ -169,13 +169,13 @@ namespace internal
      * for lower dimensions (see <tt>Iterators<[12]></tt>). The dimension
      * specific data types are here, since we are in three dimensions:
      *  @code
-     *    typedef raw_hex_iterator    raw_cell_iterator;
-     *    typedef hex_iterator        cell_iterator;
-     *    typedef active_hex_iterator active_cell_iterator;
+     *    using raw_cell_iterator = raw_hex_iterator;
+     *    using cell_iterator = hex_iterator;
+     *    using active_cell_iterator = active_hex_iterator;
      *
-     *    typedef raw_quad_iterator    raw_face_iterator;
-     *    typedef quad_iterator        face_iterator;
-     *    typedef active_quad_iterator active_face_iterator;
+     *    using raw_face_iterator = raw_quad_iterator;
+     *    using face_iterator = quad_iterator;
+     *    using active_face_iterator = active_quad_iterator;
      *  @endcode
      *
      * @author Wolfgang Bangerth, 1998
@@ -183,23 +183,23 @@ namespace internal
     template <int spacedim>
     struct Iterators<3, spacedim>
     {
-      typedef TriaRawIterator<dealii::TriaAccessor<1, 3, spacedim>>
-                                                                 raw_line_iterator;
-      typedef TriaIterator<dealii::TriaAccessor<1, 3, spacedim>> line_iterator;
-      typedef TriaActiveIterator<dealii::TriaAccessor<1, 3, spacedim>>
-        active_line_iterator;
-
-      typedef TriaRawIterator<dealii::TriaAccessor<2, 3, spacedim>>
-                                                                 raw_quad_iterator;
-      typedef TriaIterator<dealii::TriaAccessor<2, 3, spacedim>> quad_iterator;
-      typedef TriaActiveIterator<dealii::TriaAccessor<2, 3, spacedim>>
-        active_quad_iterator;
-
-      typedef TriaRawIterator<dealii::CellAccessor<3, spacedim>>
-                                                              raw_hex_iterator;
-      typedef TriaIterator<dealii::CellAccessor<3, spacedim>> hex_iterator;
-      typedef TriaActiveIterator<dealii::CellAccessor<3, spacedim>>
-        active_hex_iterator;
+      using raw_line_iterator =
+        TriaRawIterator<dealii::TriaAccessor<1, 3, spacedim>>;
+      using line_iterator = TriaIterator<dealii::TriaAccessor<1, 3, spacedim>>;
+      using active_line_iterator =
+        TriaActiveIterator<dealii::TriaAccessor<1, 3, spacedim>>;
+
+      using raw_quad_iterator =
+        TriaRawIterator<dealii::TriaAccessor<2, 3, spacedim>>;
+      using quad_iterator = TriaIterator<dealii::TriaAccessor<2, 3, spacedim>>;
+      using active_quad_iterator =
+        TriaActiveIterator<dealii::TriaAccessor<2, 3, spacedim>>;
+
+      using raw_hex_iterator =
+        TriaRawIterator<dealii::CellAccessor<3, spacedim>>;
+      using hex_iterator = TriaIterator<dealii::CellAccessor<3, spacedim>>;
+      using active_hex_iterator =
+        TriaActiveIterator<dealii::CellAccessor<3, spacedim>>;
     };
 
   } // namespace TriangulationImplementation
index 3fc75a63438bc5b8b9d4bee02b202f121e14440a..40fb02cfd18a8223a348705af674e98dfc803f84 100644 (file)
@@ -168,68 +168,64 @@ namespace hp
   template <int dim, int spacedim = dim>
   class DoFHandler : public Subscriptor
   {
-    typedef dealii::internal::DoFHandlerImplementation::
-      Iterators<DoFHandler<dim, spacedim>, false>
-        ActiveSelector;
-    typedef dealii::internal::DoFHandlerImplementation::
-      Iterators<DoFHandler<dim, spacedim>, true>
-        LevelSelector;
+    using ActiveSelector = dealii::internal::DoFHandlerImplementation::
+      Iterators<DoFHandler<dim, spacedim>, false>;
+    using LevelSelector = dealii::internal::DoFHandlerImplementation::
+      Iterators<DoFHandler<dim, spacedim>, true>;
 
   public:
-    typedef typename ActiveSelector::CellAccessor cell_accessor;
-    typedef typename ActiveSelector::FaceAccessor face_accessor;
+    using cell_accessor = typename ActiveSelector::CellAccessor;
+    using face_accessor = typename ActiveSelector::FaceAccessor;
 
-    typedef typename ActiveSelector::line_iterator        line_iterator;
-    typedef typename ActiveSelector::active_line_iterator active_line_iterator;
+    using line_iterator        = typename ActiveSelector::line_iterator;
+    using active_line_iterator = typename ActiveSelector::active_line_iterator;
 
-    typedef typename ActiveSelector::quad_iterator        quad_iterator;
-    typedef typename ActiveSelector::active_quad_iterator active_quad_iterator;
+    using quad_iterator        = typename ActiveSelector::quad_iterator;
+    using active_quad_iterator = typename ActiveSelector::active_quad_iterator;
 
-    typedef typename ActiveSelector::hex_iterator        hex_iterator;
-    typedef typename ActiveSelector::active_hex_iterator active_hex_iterator;
+    using hex_iterator        = typename ActiveSelector::hex_iterator;
+    using active_hex_iterator = typename ActiveSelector::active_hex_iterator;
 
     /**
      * @copydoc ::DoFHandler::active_cell_iterator
      * @ingroup Iterators
      */
 #ifndef _MSC_VER
-    typedef typename ActiveSelector::active_cell_iterator active_cell_iterator;
+    using active_cell_iterator = typename ActiveSelector::active_cell_iterator;
 #else
-    typedef TriaActiveIterator<
-      dealii::DoFCellAccessor<DoFHandler<dim, spacedim>, false>>
-      active_cell_iterator;
+    using active_cell_iterator = TriaActiveIterator<
+      dealii::DoFCellAccessor<DoFHandler<dim, spacedim>, false>>;
 #endif
 
-    typedef typename LevelSelector::cell_iterator level_cell_iterator;
+    using level_cell_iterator = typename LevelSelector::cell_iterator;
 
     /**
      * @copydoc ::DoFHandler::cell_iterator
      * @ingroup Iterators
      */
 #ifndef _MSC_VER
-    typedef typename ActiveSelector::cell_iterator cell_iterator;
+    using cell_iterator = typename ActiveSelector::cell_iterator;
 #else
-    typedef TriaIterator<
-      dealii::DoFCellAccessor<DoFHandler<dim, spacedim>, false>>
-      cell_iterator;
+    using cell_iterator =
+      TriaIterator<dealii::DoFCellAccessor<DoFHandler<dim, spacedim>, false>>;
 #endif
 
     /**
      * @copydoc ::DoFHandler::face_iterator
      * @ingroup Iterators
      */
-    typedef typename ActiveSelector::face_iterator face_iterator;
+    using face_iterator = typename ActiveSelector::face_iterator;
 
     /**
      * @copydoc ::DoFHandler::active_face_iterator
      * @ingroup Iterators
      */
-    typedef typename ActiveSelector::active_face_iterator active_face_iterator;
+    using active_face_iterator = typename ActiveSelector::active_face_iterator;
 
-    typedef typename LevelSelector::CellAccessor level_cell_accessor;
-    typedef typename LevelSelector::FaceAccessor level_face_accessor;
+    using level_cell_accessor = typename LevelSelector::CellAccessor;
+    using level_face_accessor = typename LevelSelector::FaceAccessor;
 
-    typedef typename LevelSelector::face_iterator level_face_iterator;
+    using level_face_iterator = typename LevelSelector::face_iterator;
 
     /**
      * Make the dimension available in function templates.
index 858c88fb13453704f4583fe7ad9c5ef3cc0511b9..d2ecbe2c249fd459f6d5266d8535e00c3cd939d3 100644 (file)
@@ -109,18 +109,18 @@ namespace internal
       /**
        * The type in which we store the offsets into the dof_indices array.
        */
-      typedef unsigned int offset_type;
+      using offset_type = unsigned int;
 
       /**
        * The type in which we store the active FE index.
        */
-      typedef unsigned short int active_fe_index_type;
+      using active_fe_index_type = unsigned short int;
 
       /**
        * A signed type that matches the type in which we store the active FE
        * index. We use this in computing binary complements.
        */
-      typedef signed short int signed_active_fe_index_type;
+      using signed_active_fe_index_type = signed short int;
 
       /**
        * Given an active_fe_index, return whether the corresponding
index 5e32702a8261b10f471c6be7bc4458c181ca7b1e..73efb18ece0a89f84cc3baf81f07903eae6abac6 100644 (file)
@@ -250,7 +250,7 @@ namespace hp
      * FECollection, namely 2.
      *
      * For the purpose of this function by domination we consider either
-     * this_element_dominate or either_element_can_dominate ; therefore the
+     * this_element_dominate or either_element_can_dominate; therefore the
      * element can dominate itself. Thus if FECollection contains
      * {Q1,Q2,Q4,Q3} and @p fes = {3}, the function returns 3.
      *
index 5bae87d79fca4d26829f3154bf3a376fec14de15..a8605817c9c039a7194ef1618b0a7b9cc0b7386f 100644 (file)
@@ -58,12 +58,12 @@ class AffineConstraints;
 
 /**
  * ConstraintMatrix has been renamed to AffineConstraints. Provide a
- * compatibility typedef that defaults to AffineConstraints<double>.
+ * compatibility alias that defaults to AffineConstraints<double>.
  *
  * @deprecated Use AffineConstraints<double> instead of ConstraintMatrix
  */
 using ConstraintMatrix DEAL_II_DEPRECATED = AffineConstraints<double>;
-// Note: Unfortunately, we cannot move this compatibility typedef into
+// Note: Unfortunately, we cannot move this compatibility alias into
 // constraint_matrix.h directly. This would break a lot of user projects
 // that include constraint_matrix.h transitively due to various deal.II
 // headers that include the file.
@@ -159,7 +159,7 @@ public:
   /**
    * Declare the type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * An enum that describes what should happen if the two AffineConstraints
@@ -1190,7 +1190,7 @@ public:
      * A data type in which we store the list of entries that make up the
      * homogenous part of a constraint.
      */
-    typedef std::vector<std::pair<size_type, number>> Entries;
+    using Entries = std::vector<std::pair<size_type, number>>;
 
     /**
      * Global DoF index of this line. Since only very few lines are stored,
@@ -1250,14 +1250,14 @@ public:
   };
 
   /**
-   * Typedef for the iterator type that is used in the LineRange container.
+   * Alias for the iterator type that is used in the LineRange container.
    */
-  typedef typename std::vector<ConstraintLine>::const_iterator const_iterator;
+  using const_iterator = typename std::vector<ConstraintLine>::const_iterator;
 
   /**
-   * Typedef for the return type used by get_lines().
+   * Alias for the return type used by get_lines().
    */
-  typedef boost::iterator_range<const_iterator> LineRange;
+  using LineRange = boost::iterator_range<const_iterator>;
 
   /**
    * Return a range object containing (const) iterators to all line entries
index 7cd691b39b9f1a98ea5439b56101194f5dc46a17..6dca46a955af5fc57b1f93656ed61d062426f139 100644 (file)
@@ -1905,7 +1905,7 @@ namespace internal
 {
   namespace AffineConstraintsImplementation
   {
-    typedef types::global_dof_index size_type;
+    using size_type = types::global_dof_index;
 
     template <class VectorType>
     void
@@ -2301,8 +2301,8 @@ AffineConstraints<number>::distribute(VectorType &vec) const
       // following.
       IndexSet needed_elements = vec_owned_elements;
 
-      typedef typename std::vector<ConstraintLine>::const_iterator
-        constraint_iterator;
+      using constraint_iterator =
+        typename std::vector<ConstraintLine>::const_iterator;
       for (constraint_iterator it = lines.begin(); it != lines.end(); ++it)
         if (vec_owned_elements.is_element(it->index))
           for (unsigned int i = 0; i < it->entries.size(); ++i)
@@ -2367,7 +2367,7 @@ AffineConstraints<number>::distribute(VectorType &vec) const
 // Some helper definitions for the local_to_global functions.
 namespace internals
 {
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   // this struct contains all the information we need to store about each of
   // the global entries (global_row): are they obtained directly by some local
@@ -2742,9 +2742,9 @@ namespace internals
                                             const size_type local_row,
                                             const number    constraint_value)
   {
-    typedef std::vector<Distributing>::iterator index_iterator;
-    index_iterator                              pos, pos1;
-    Distributing                                row_value(global_row);
+    using index_iterator = std::vector<Distributing>::iterator;
+    index_iterator               pos, pos1;
+    Distributing                 row_value(global_row);
     std::pair<size_type, number> constraint(local_row, constraint_value);
 
     // check whether the list was really sorted before entering here
@@ -2972,7 +2972,7 @@ namespace internals
   {
     AssertDimension(block_starts.size(), block_object.n_block_rows() + 1);
 
-    typedef std::vector<Distributing>::iterator row_iterator;
+    using row_iterator         = std::vector<Distributing>::iterator;
     row_iterator block_indices = global_rows.total_row_indices.begin();
 
     const size_type num_blocks    = block_object.n_block_rows();
@@ -3008,8 +3008,8 @@ namespace internals
   {
     AssertDimension(block_starts.size(), block_object.n_block_rows() + 1);
 
-    typedef std::vector<size_type>::iterator row_iterator;
-    row_iterator                             col_indices = row_indices.begin();
+    using row_iterator       = std::vector<size_type>::iterator;
+    row_iterator col_indices = row_indices.begin();
 
     const size_type num_blocks = block_object.n_block_rows();
 
index af87f1df30fdb168a5ac0989ae7ed9cd355bd877..49664906f4f5ba716a95b1c1f058e944e17f5e2e 100644 (file)
@@ -172,7 +172,7 @@ public:
   /**
    * Declare the type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
 
   /**
index c0e9ca908bd9040c9b5d6219004ec9599da7953b..4860a039b9fda1c25f049fb2340de7647f84f0b6 100644 (file)
@@ -63,7 +63,7 @@ public:
   /**
    * Declare the type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * Default constructor. Initialize for zero blocks.
index 2fe0b3b098e6f0f81b12cdcb59733b840e722b99..80f456bf2242fe72e4bd6374600b0f811182ff86 100644 (file)
@@ -201,10 +201,9 @@ class BlockLinearOperator
   : public LinearOperator<Range, Domain, typename BlockPayload::BlockType>
 {
 public:
-  typedef LinearOperator<typename Range::BlockType,
-                         typename Domain::BlockType,
-                         typename BlockPayload::BlockType>
-    BlockType;
+  using BlockType = LinearOperator<typename Range::BlockType,
+                                   typename Domain::BlockType,
+                                   typename BlockPayload::BlockType>;
 
   /**
    * Create an empty BlockLinearOperator object.
@@ -578,7 +577,7 @@ namespace internal
       /**
        * Type of payload held by each subblock
        */
-      typedef PayloadBlockType BlockType;
+      using BlockType = PayloadBlockType;
 
       /**
        * Default constructor
@@ -620,8 +619,8 @@ template <typename Range,
 BlockLinearOperator<Range, Domain, BlockPayload>
 block_operator(const BlockMatrixType &block_matrix)
 {
-  typedef typename BlockLinearOperator<Range, Domain, BlockPayload>::BlockType
-    BlockType;
+  using BlockType =
+    typename BlockLinearOperator<Range, Domain, BlockPayload>::BlockType;
 
   BlockLinearOperator<Range, Domain, BlockPayload> return_op(
     BlockPayload(block_matrix, block_matrix));
@@ -695,8 +694,8 @@ block_operator(
   static_assert(m > 0 && n > 0,
                 "a blocked LinearOperator must consist of at least one block");
 
-  typedef typename BlockLinearOperator<Range, Domain, BlockPayload>::BlockType
-    BlockType;
+  using BlockType =
+    typename BlockLinearOperator<Range, Domain, BlockPayload>::BlockType;
 
   BlockLinearOperator<Range, Domain, BlockPayload> return_op(
     (BlockPayload())); // TODO: Create block payload so that this can be
@@ -741,8 +740,8 @@ template <typename Range,
 BlockLinearOperator<Range, Domain, BlockPayload>
 block_diagonal_operator(const BlockMatrixType &block_matrix)
 {
-  typedef typename BlockLinearOperator<Range, Domain, BlockPayload>::BlockType
-    BlockType;
+  using BlockType =
+    typename BlockLinearOperator<Range, Domain, BlockPayload>::BlockType;
 
   BlockLinearOperator<Range, Domain, BlockPayload> return_op(
     BlockPayload(block_matrix, block_matrix));
@@ -804,8 +803,8 @@ block_diagonal_operator(
   static_assert(
     m > 0, "a blockdiagonal LinearOperator must consist of at least one block");
 
-  typedef typename BlockLinearOperator<Range, Domain, BlockPayload>::BlockType
-    BlockType;
+  using BlockType =
+    typename BlockLinearOperator<Range, Domain, BlockPayload>::BlockType;
 
   std::array<std::array<BlockType, m>, m> new_ops;
 
@@ -853,8 +852,8 @@ block_diagonal_operator(
                 "a blockdiagonal LinearOperator must consist of at least "
                 "one block");
 
-  typedef typename BlockLinearOperator<Range, Domain, BlockPayload>::BlockType
-                           BlockType;
+  using BlockType =
+    typename BlockLinearOperator<Range, Domain, BlockPayload>::BlockType;
   std::array<BlockType, m> new_ops;
   new_ops.fill(op);
 
index bad0dc6eb480b757572d8e18c6705b8ac812dbd9..3adb25c46e69f210daa4f28e26f4a31d4b574b1f 100644 (file)
@@ -121,7 +121,7 @@ public:
   /**
    * Declare the type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * Default constructor creating a useless object. initialize() must be
@@ -425,7 +425,7 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * Default constructor creating a useless object. initialize() must be
@@ -584,10 +584,9 @@ BlockMatrixArray<number, BlockVectorType>::print_latex(StreamType &out) const
 
   Table<2, std::string> array(n_block_rows(), n_block_cols());
 
-  typedef std::map<
-    const PointerMatrixBase<typename BlockVectorType::BlockType> *,
-    std::string>
-          NameMap;
+  using NameMap =
+    std::map<const PointerMatrixBase<typename BlockVectorType::BlockType> *,
+             std::string>;
   NameMap matrix_names;
 
   typename std::vector<Entry>::const_iterator m   = entries.begin();
index f21847beff6c3efd2bc919b8dc7dcf097fa9b9e1..a12cec0ddc626ec0fcb0e9fea2ab307488b4e370 100644 (file)
@@ -64,12 +64,12 @@ namespace BlockMatrixIterators
     /**
      * Declare type for container size.
      */
-    typedef types::global_dof_index size_type;
+    using size_type = types::global_dof_index;
 
     /**
      * Typedef the value type of the matrix we point into.
      */
-    typedef typename BlockMatrixType::value_type value_type;
+    using value_type = typename BlockMatrixType::value_type;
 
     /**
      * Initialize data fields to default values.
@@ -125,17 +125,17 @@ namespace BlockMatrixIterators
     /**
      * Declare type for container size.
      */
-    typedef types::global_dof_index size_type;
+    using size_type = types::global_dof_index;
 
     /**
      * Type of the matrix used in this accessor.
      */
-    typedef BlockMatrixType MatrixType;
+    using MatrixType = BlockMatrixType;
 
     /**
      * Typedef the value type of the matrix we point into.
      */
-    typedef typename BlockMatrixType::value_type value_type;
+    using value_type = typename BlockMatrixType::value_type;
 
     /**
      * Constructor. Since we use accessors only for read access, a const
@@ -210,17 +210,17 @@ namespace BlockMatrixIterators
     /**
      * Declare type for container size.
      */
-    typedef types::global_dof_index size_type;
+    using size_type = types::global_dof_index;
 
     /**
      * Type of the matrix used in this accessor.
      */
-    typedef const BlockMatrixType MatrixType;
+    using MatrixType = const BlockMatrixType;
 
     /**
      * Typedef the value type of the matrix we point into.
      */
-    typedef typename BlockMatrixType::value_type value_type;
+    using value_type = typename BlockMatrixType::value_type;
 
     /**
      * Constructor. Since we use accessors only for read access, a const
@@ -357,24 +357,24 @@ public:
   /**
    * Typedef the type of the underlying matrix.
    */
-  typedef MatrixType BlockType;
+  using BlockType = MatrixType;
 
   /**
-   * Type of matrix entries. These are analogous to typedefs in the standard
+   * Type of matrix entries. These are analogous to alias in the standard
    * library containers.
    */
-  typedef typename BlockType::value_type value_type;
-  typedef value_type *                   pointer;
-  typedef const value_type *             const_pointer;
-  typedef value_type &                   reference;
-  typedef const value_type &             const_reference;
-  typedef types::global_dof_index        size_type;
+  using value_type      = typename BlockType::value_type;
+  using pointer         = value_type *;
+  using const_pointer   = const value_type *;
+  using reference       = value_type &;
+  using const_reference = const value_type &;
+  using size_type       = types::global_dof_index;
 
-  typedef MatrixIterator<BlockMatrixIterators::Accessor<BlockMatrixBase, false>>
-    iterator;
+  using iterator =
+    MatrixIterator<BlockMatrixIterators::Accessor<BlockMatrixBase, false>>;
 
-  typedef MatrixIterator<BlockMatrixIterators::Accessor<BlockMatrixBase, true>>
-    const_iterator;
+  using const_iterator =
+    MatrixIterator<BlockMatrixIterators::Accessor<BlockMatrixBase, true>>;
 
 
   /**
@@ -1830,7 +1830,7 @@ BlockMatrixBase<MatrixType>::add(const size_type  i,
   // save some cycles for zero additions, but
   // only if it is safe for the matrix we are
   // working with
-  typedef typename MatrixType::Traits MatrixTraits;
+  using MatrixTraits = typename MatrixType::Traits;
   if ((MatrixTraits::zero_addition_can_be_elided == true) &&
       (value == value_type()))
     return;
@@ -2086,7 +2086,7 @@ BlockMatrixBase<MatrixType>::add(const value_type                   factor,
   // save some cycles for zero additions, but
   // only if it is safe for the matrix we are
   // working with
-  typedef typename MatrixType::Traits MatrixTraits;
+  using MatrixTraits = typename MatrixType::Traits;
   if ((MatrixTraits::zero_addition_can_be_elided == true) && (factor == 0))
     return;
 
index 69dabde96ad50f17b64776501a85317d6dfa7c4d..0dd83bd0a59000f91672e3d503714864517c1098 100644 (file)
@@ -53,26 +53,26 @@ class BlockSparseMatrix : public BlockMatrixBase<SparseMatrix<number>>
 {
 public:
   /**
-   * Typedef the base class for simpler access to its own typedefs.
+   * Typedef the base class for simpler access to its own alias.
    */
-  typedef BlockMatrixBase<SparseMatrix<number>> BaseClass;
+  using BaseClass = BlockMatrixBase<SparseMatrix<number>>;
 
   /**
    * Typedef the type of the underlying matrix.
    */
-  typedef typename BaseClass::BlockType BlockType;
+  using BlockType = typename BaseClass::BlockType;
 
   /**
-   * Import the typedefs from the base class.
+   * Import the alias from the base class.
    */
-  typedef typename BaseClass::value_type      value_type;
-  typedef typename BaseClass::pointer         pointer;
-  typedef typename BaseClass::const_pointer   const_pointer;
-  typedef typename BaseClass::reference       reference;
-  typedef typename BaseClass::const_reference const_reference;
-  typedef typename BaseClass::size_type       size_type;
-  typedef typename BaseClass::iterator        iterator;
-  typedef typename BaseClass::const_iterator  const_iterator;
+  using value_type      = typename BaseClass::value_type;
+  using pointer         = typename BaseClass::pointer;
+  using const_pointer   = typename BaseClass::const_pointer;
+  using reference       = typename BaseClass::reference;
+  using const_reference = typename BaseClass::const_reference;
+  using size_type       = typename BaseClass::size_type;
+  using iterator        = typename BaseClass::iterator;
+  using const_iterator  = typename BaseClass::const_iterator;
 
   /**
    * @name Constructors and initialization
index db880b35a7892d6aa55dbf4c7b8eef6d04d96e3c..225033023950b4db3906afdde1f79dbdd39b5439 100644 (file)
@@ -61,7 +61,7 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * Default constructor. The result is an empty object with zero dimensions.
index 11df312a7be0374bc49ad1a861971c9f21dab62f..4968a6ad7a236d300b61efaae57c027d0f2f8ea7 100644 (file)
@@ -80,7 +80,7 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * Define a value which is used to indicate that a certain value in the @p
@@ -468,7 +468,7 @@ public:
  * This class extends the base class to implement an array of compressed
  * sparsity patterns that can be used to initialize objects of type
  * BlockSparsityPattern. It does not add additional member functions, but
- * rather acts as a @p typedef to introduce the name of this class, without
+ * rather acts as an @p alias to introduce the name of this class, without
  * requiring the user to specify the templated name of the base class. For
  * information on the interface of this class refer to the base class. The
  * individual blocks are based on the DynamicSparsityPattern class.
index 3d721fb8b4a0f286f1b8f381063a454444760ab7..24e5757efb8e95ffa6d2ebff4a9705f3ce9e920e 100644 (file)
@@ -69,27 +69,27 @@ class BlockVector : public BlockVectorBase<Vector<Number>>
 {
 public:
   /**
-   * Typedef the base class for simpler access to its own typedefs.
+   * Typedef the base class for simpler access to its own alias.
    */
-  typedef BlockVectorBase<Vector<Number>> BaseClass;
+  using BaseClass = BlockVectorBase<Vector<Number>>;
 
   /**
    * Typedef the type of the underlying vector.
    */
-  typedef typename BaseClass::BlockType BlockType;
+  using BlockType = typename BaseClass::BlockType;
 
   /**
-   * Import the typedefs from the base class.
+   * Import the alias from the base class.
    */
-  typedef typename BaseClass::value_type      value_type;
-  typedef typename BaseClass::real_type       real_type;
-  typedef typename BaseClass::pointer         pointer;
-  typedef typename BaseClass::const_pointer   const_pointer;
-  typedef typename BaseClass::reference       reference;
-  typedef typename BaseClass::const_reference const_reference;
-  typedef typename BaseClass::size_type       size_type;
-  typedef typename BaseClass::iterator        iterator;
-  typedef typename BaseClass::const_iterator  const_iterator;
+  using value_type      = typename BaseClass::value_type;
+  using real_type       = typename BaseClass::real_type;
+  using pointer         = typename BaseClass::pointer;
+  using const_pointer   = typename BaseClass::const_pointer;
+  using reference       = typename BaseClass::reference;
+  using const_reference = typename BaseClass::const_reference;
+  using size_type       = typename BaseClass::size_type;
+  using iterator        = typename BaseClass::iterator;
+  using const_iterator  = typename BaseClass::const_iterator;
 
   /**
    * Constructor. There are three ways to use this constructor. First, without
index 78abfe73ee5c68c295c4d8a43f199d6d5c001a49..d2b521755463ec81aa6f3db1e5224cf082dbe40a 100644 (file)
@@ -138,24 +138,24 @@ namespace internal
        * Type of the vector underlying the block vector used in non-const
        * iterators. There, the vector must not be constant.
        */
-      typedef typename BlockVectorType::BlockType Vector;
+      using Vector = typename BlockVectorType::BlockType;
 
       /**
        * Type of the block vector used in non-const iterators. There, the
        * block vector must not be constant.
        */
-      typedef BlockVectorType BlockVector;
+      using BlockVector = BlockVectorType;
 
       /**
        * Type of the numbers we point to. Here, they are not constant.
        */
-      typedef typename BlockVector::value_type value_type;
+      using value_type = typename BlockVector::value_type;
 
       /**
        * Typedef the result of a dereferencing operation for an iterator of
        * the underlying iterator.
        */
-      typedef typename Vector::reference dereference_type;
+      using dereference_type = typename Vector::reference;
     };
 
 
@@ -173,26 +173,26 @@ namespace internal
        * Type of the vector underlying the block vector used in
        * const_iterator. There, the vector must be constant.
        */
-      typedef const typename BlockVectorType::BlockType Vector;
+      using Vector = const typename BlockVectorType::BlockType;
 
       /**
        * Type of the block vector used in const_iterator. There, the block
        * vector must be constant.
        */
-      typedef const BlockVectorType BlockVector;
+      using BlockVector = const BlockVectorType;
 
       /**
        * Type of the numbers we point to. Here, they are constant since the
        * block vector we use is constant.
        */
-      typedef const typename BlockVector::value_type value_type;
+      using value_type = const typename BlockVector::value_type;
 
       /**
        * Typedef the result of a dereferencing operation for an iterator of
        * the underlying iterator. Since this is for constant iterators, we can
        * only return values, not actual references.
        */
-      typedef value_type dereference_type;
+      using dereference_type = value_type;
     };
 
 
@@ -220,34 +220,34 @@ namespace internal
       /**
        * Declare the type for container size.
        */
-      typedef types::global_dof_index size_type;
+      using size_type = types::global_dof_index;
 
       /**
        * Type of the number this iterator points to. Depending on the value of
        * the second template parameter, this is either a constant or non-const
        * number.
        */
-      typedef typename Types<BlockVectorType, Constness>::value_type value_type;
+      using value_type = typename Types<BlockVectorType, Constness>::value_type;
 
       /**
-       * Declare some typedefs which are standard for iterators and are used
+       * Declare some alias which are standard for iterators and are used
        * by algorithms to enquire about the specifics of the iterators they
        * work on.
        */
-      typedef std::random_access_iterator_tag     iterator_category;
-      typedef std::ptrdiff_t                      difference_type;
-      typedef typename BlockVectorType::reference reference;
-      typedef value_type *                        pointer;
+      using iterator_category = std::random_access_iterator_tag;
+      using difference_type   = std::ptrdiff_t;
+      using reference         = typename BlockVectorType::reference;
+      using pointer           = value_type *;
 
-      typedef typename Types<BlockVectorType, Constness>::dereference_type
-        dereference_type;
+      using dereference_type =
+        typename Types<BlockVectorType, Constness>::dereference_type;
 
       /**
        * Typedef the type of the block vector (which differs in constness,
        * depending on the second template parameter).
        */
-      typedef
-        typename Types<BlockVectorType, Constness>::BlockVector BlockVector;
+      using BlockVector =
+        typename Types<BlockVectorType, Constness>::BlockVector;
 
       /**
        * Construct an iterator from a vector to which we point and the global
@@ -529,7 +529,7 @@ public:
   /**
    * Typedef the type of the underlying vector.
    */
-  typedef VectorType BlockType;
+  using BlockType = VectorType;
 
   /*
    * Declare standard types used in
@@ -541,18 +541,16 @@ public:
    * class. This includes iterator
    * types.
    */
-  typedef typename BlockType::value_type value_type;
-  typedef value_type *                   pointer;
-  typedef const value_type *             const_pointer;
-  typedef dealii::internal::BlockVectorIterators::Iterator<BlockVectorBase,
-                                                           false>
-    iterator;
-  typedef dealii::internal::BlockVectorIterators::Iterator<BlockVectorBase,
-                                                           true>
-                                              const_iterator;
-  typedef typename BlockType::reference       reference;
-  typedef typename BlockType::const_reference const_reference;
-  typedef types::global_dof_index             size_type;
+  using value_type    = typename BlockType::value_type;
+  using pointer       = value_type *;
+  using const_pointer = const value_type *;
+  using iterator =
+    dealii::internal::BlockVectorIterators::Iterator<BlockVectorBase, false>;
+  using const_iterator =
+    dealii::internal::BlockVectorIterators::Iterator<BlockVectorBase, true>;
+  using reference       = typename BlockType::reference;
+  using const_reference = typename BlockType::const_reference;
+  using size_type       = types::global_dof_index;
 
   /**
    * Declare a type that has holds real-valued numbers with the same precision
@@ -561,9 +559,9 @@ public:
    * If the template argument is a std::complex type then real_type equals the
    * type underlying the complex numbers.
    *
-   * This typedef is used to represent the return type of norms.
+   * This alias is used to represent the return type of norms.
    */
-  typedef typename BlockType::real_type real_type;
+  using real_type = typename BlockType::real_type;
 
   /**
    * Default constructor.
index a2859f41eca072bb18dfa2489e392a7970d632c7..0121c4cfd93ded81ce6729ba1d4bfe503c01ddf5 100644 (file)
@@ -100,7 +100,7 @@ namespace ChunkSparseMatrixIterators
      * Typedef for the type (including constness) of the matrix to be used
      * here.
      */
-    typedef const ChunkSparseMatrix<number> MatrixType;
+    using MatrixType = const ChunkSparseMatrix<number>;
 
     /**
      * Constructor.
@@ -238,7 +238,7 @@ namespace ChunkSparseMatrixIterators
      * Typedef for the type (including constness) of the matrix to be used
      * here.
      */
-    typedef ChunkSparseMatrix<number> MatrixType;
+    using MatrixType = ChunkSparseMatrix<number>;
 
     /**
      * Constructor.
@@ -300,13 +300,13 @@ namespace ChunkSparseMatrixIterators
     /**
      * Typedef for the matrix type (including constness) we are to operate on.
      */
-    typedef typename Accessor<number, Constness>::MatrixType MatrixType;
+    using MatrixType = typename Accessor<number, Constness>::MatrixType;
 
     /**
-     * A typedef for the type you get when you dereference an iterator of the
+     * An alias for the type you get when you dereference an iterator of the
      * current kind.
      */
-    typedef const Accessor<number, Constness> &value_type;
+    using value_type = const Accessor<number, Constness> &;
 
     /**
      * Constructor. Create an iterator into the matrix @p matrix for the given
@@ -427,13 +427,13 @@ public:
   /**
    * Declare the type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
-   * Type of matrix entries. This typedef is analogous to <tt>value_type</tt>
+   * Type of matrix entries. This alias is analogous to <tt>value_type</tt>
    * in the standard library containers.
    */
-  typedef number value_type;
+  using value_type = number;
 
   /**
    * Declare a type that has holds real-valued numbers with the same precision
@@ -442,15 +442,15 @@ public:
    * If the template argument is a std::complex type then real_type equals the
    * type underlying the complex numbers.
    *
-   * This typedef is used to represent the return type of norms.
+   * This alias is used to represent the return type of norms.
    */
-  typedef typename numbers::NumberTraits<number>::real_type real_type;
+  using real_type = typename numbers::NumberTraits<number>::real_type;
 
   /**
    * Typedef of an iterator class walking over all the nonzero entries of this
    * matrix. This iterator cannot change the values of the matrix.
    */
-  typedef ChunkSparseMatrixIterators::Iterator<number, true> const_iterator;
+  using const_iterator = ChunkSparseMatrixIterators::Iterator<number, true>;
 
   /**
    * Typedef of an iterator class walking over all the nonzero entries of this
@@ -458,7 +458,7 @@ public:
    * course can't change the sparsity pattern as this is fixed once a sparse
    * matrix is attached to it.
    */
-  typedef ChunkSparseMatrixIterators::Iterator<number, false> iterator;
+  using iterator = ChunkSparseMatrixIterators::Iterator<number, false>;
 
   /**
    * A structure that describes some of the traits of this class in terms of
@@ -1642,11 +1642,10 @@ ChunkSparseMatrix<number>::copy_from(const ForwardIterator begin,
   Assert(static_cast<size_type>(std::distance(begin, end)) == m(),
          ExcIteratorRange(std::distance(begin, end), m()));
 
-  // for use in the inner loop, we define a typedef to the type of the inner
+  // for use in the inner loop, we define an alias to the type of the inner
   // iterators
-  typedef
-    typename std::iterator_traits<ForwardIterator>::value_type::const_iterator
-            inner_iterator;
+  using inner_iterator =
+    typename std::iterator_traits<ForwardIterator>::value_type::const_iterator;
   size_type row = 0;
   for (ForwardIterator i = begin; i != end; ++i, ++row)
     {
index 5b6ee7e718af96a319896ca13b647250823f377e..7ba9fb78152d3f5bf42d5b67ed8c70d4a317398a 100644 (file)
@@ -47,7 +47,7 @@ namespace internal
     /**
      * Declare type for container size.
      */
-    typedef types::global_dof_index size_type;
+    using size_type = types::global_dof_index;
 
     /**
      * Add the result of multiplying a chunk of size chunk_size times
index 9320e4b0fb61aec8e8a01d368a9ee9d5b9162419..7c70aa9c5a5ff575884a8c9e6389765d6d37419a 100644 (file)
@@ -241,12 +241,12 @@ public:
   /**
    * Declare the type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
   /**
    * Typedef an iterator class that allows to walk over all nonzero elements
    * of a sparsity pattern.
    */
-  typedef ChunkSparsityPatternIterators::Iterator const_iterator;
+  using const_iterator = ChunkSparsityPatternIterators::Iterator;
 
   /**
    * Typedef an iterator class that allows to walk over all nonzero elements
@@ -255,7 +255,7 @@ public:
    * Since the iterator does not allow to modify the sparsity pattern, this
    * type is the same as that for @p const_iterator.
    */
-  typedef ChunkSparsityPatternIterators::Iterator iterator;
+  using iterator = ChunkSparsityPatternIterators::Iterator;
 
   /**
    * Define a value which is used to indicate that a certain value in the
@@ -1192,9 +1192,8 @@ ChunkSparsityPattern::copy_from(const size_type       n_rows,
 
   // now enter all the elements into the matrix
   size_type row = 0;
-  typedef
-    typename std::iterator_traits<ForwardIterator>::value_type::const_iterator
-      inner_iterator;
+  using inner_iterator =
+    typename std::iterator_traits<ForwardIterator>::value_type::const_iterator;
   for (ForwardIterator i = begin; i != end; ++i, ++row)
     {
       const inner_iterator end_of_row = i->end();
index b005dfbd7ec3d3c820ed05eb0cf80154b168ffa3..60ff84d7d2d4f514908e1e48ffe88ecfd7280578 100644 (file)
@@ -51,18 +51,18 @@ namespace CUDAWrappers
     /**
      * Declare type for container size.
      */
-    typedef unsigned int size_type;
+    using size_type = unsigned int;
 
     /**
      * Type of the matrix entries.
      */
-    typedef Number value_type;
+    using value_type = Number;
 
     /**
      * Declare a type that holds real-valued numbers with the same precision
      * as the template argument to this class.
      */
-    typedef Number real_type;
+    using real_type = Number;
 
     /**
      * @name Constructors and initialization
index c2d07a0df3fef982de033dc81f9cdba6cad32595..4f946f6cf37143da981fbecc4005be3176a6c301 100644 (file)
@@ -53,9 +53,9 @@ namespace LinearAlgebra
     class Vector : public VectorSpaceVector<Number>
     {
     public:
-      typedef typename VectorSpaceVector<Number>::value_type value_type;
-      typedef typename VectorSpaceVector<Number>::size_type  size_type;
-      typedef typename VectorSpaceVector<Number>::real_type  real_type;
+      using value_type = typename VectorSpaceVector<Number>::value_type;
+      using size_type  = typename VectorSpaceVector<Number>::size_type;
+      using real_type  = typename VectorSpaceVector<Number>::real_type;
 
       /**
        * Constructor. Create a vector of dimension zero.
index eb746755d0168c631696f1de820b671399affa10..08573e8218d360653a9eff32af474706235d0f00 100644 (file)
@@ -47,8 +47,8 @@ template <typename VectorType = Vector<double>>
 class DiagonalMatrix : public Subscriptor
 {
 public:
-  typedef typename VectorType::value_type value_type;
-  typedef typename VectorType::size_type  size_type;
+  using value_type = typename VectorType::value_type;
+  using size_type  = typename VectorType::size_type;
 
   /**
    * Constructor.
index fd276668a477b26b0c41ae6ef7a2646116f21b0e..b7496bfb0fb14625659b5303aedb257ad3083979 100644 (file)
@@ -50,7 +50,7 @@ namespace DynamicSparsityPatternIterators
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * Accessor class for iterators into objects of type DynamicSparsityPattern.
@@ -306,7 +306,7 @@ public:
   /**
    * Declare the type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * Typedef an for iterator class that allows to walk over all nonzero
@@ -315,13 +315,13 @@ public:
    * Since the iterator does not allow to modify the sparsity pattern, this
    * type is the same as that for @p const_iterator.
    */
-  typedef DynamicSparsityPatternIterators::Iterator iterator;
+  using iterator = DynamicSparsityPatternIterators::Iterator;
 
   /**
    * Typedef for an iterator class that allows to walk over all nonzero
    * elements of a sparsity pattern.
    */
-  typedef DynamicSparsityPatternIterators::Iterator const_iterator;
+  using const_iterator = DynamicSparsityPatternIterators::Iterator;
 
   /**
    * Initialize as an empty object. This is useful if you want such objects as
index 37f4fa39bda87117725e61b92069a9ade450d64d..ec1bc54888ae6362d8d7ace75b1c350de4a03c06 100644 (file)
@@ -58,7 +58,7 @@ public:
   /**
    * Declare type of container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * Standardized data struct to pipe additional data to the solver.
@@ -137,7 +137,7 @@ public:
   /**
    * Declare type of container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * Standardized data struct to pipe additional data to the solver.
index 6cd6b71116410a05e60d5de3fe6b184f44f08853..730bd23ef64cf1a21f52ff09bf1cbf22e0f243af 100644 (file)
@@ -204,7 +204,7 @@ public:
   /**
    * Declare the type of container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * Accessor class for iterators
@@ -329,7 +329,7 @@ public:
    * Typedef defining a type that represents a pair of degree of freedom index
    * and the value it shall have.
    */
-  typedef std::pair<size_type, double> IndexValuePair;
+  using IndexValuePair = std::pair<size_type, double>;
 
   /**
    * @name Constructors and initialization
@@ -520,8 +520,8 @@ private:
    * since that data type is so often used and is rather awkward to write out
    * each time.
    */
-  typedef typename std::vector<IndexValuePair>::const_iterator
-    const_index_value_iterator;
+  using const_index_value_iterator =
+    typename std::vector<IndexValuePair>::const_iterator;
 
   /**
    * Helper class used to sort pairs of indices and values. Only the index is
index 58852e01cc4c54fac41aae25b129609c2eb4227a..fc2cb0f76ab9252f811d7e47e95399833daa25ef 100644 (file)
@@ -71,13 +71,13 @@ public:
   /**
    * A type of used to index into this container.
    */
-  typedef std::size_t size_type;
+  using size_type = std::size_t;
 
   /**
-   * Type of matrix entries. This typedef is analogous to <tt>value_type</tt>
+   * Type of matrix entries. This alias is analogous to <tt>value_type</tt>
    * in the standard library containers.
    */
-  typedef number value_type;
+  using value_type = number;
 
 
   /**
@@ -87,9 +87,9 @@ public:
    * If the template argument is a std::complex type then real_type equals the
    * type underlying the complex numbers.
    *
-   * This typedef is used to represent the return type of norms.
+   * This alias is used to represent the return type of norms.
    */
-  typedef typename numbers::NumberTraits<number>::real_type real_type;
+  using real_type = typename numbers::NumberTraits<number>::real_type;
 
 
   class const_iterator;
index a18b2b2c2174b148dc2d09e6964683c127849286..5187bb79a6576d9b12de61312841b17aa96065a7 100644 (file)
@@ -28,19 +28,19 @@ DEAL_II_NAMESPACE_OPEN
 
 
 /**
- * A namespace in which the deal.II linear algebra classes are typedef'ed to
+ * A namespace in which the deal.II linear algebra classes are aliased to
  * generic names. There are similar namespaces LinearAlgebraPETSc and
- * LinearAlgebraTrilinos for typedefs to classes that interface with the PETSc
+ * LinearAlgebraTrilinos for alias to classes that interface with the PETSc
  * and Trilinos libraries.
  */
 namespace LinearAlgebraDealII
 {
-  typedef Vector<double>      Vector;
-  typedef BlockVector<double> BlockVector;
+  using Vector      = Vector<double>;
+  using BlockVector = BlockVector<double>;
 
-  typedef SparseMatrix<double> SparseMatrix;
+  using SparseMatrix = SparseMatrix<double>;
 
-  typedef PreconditionSSOR<SparseMatrix> PreconditionSSOR;
+  using PreconditionSSOR = PreconditionSSOR<SparseMatrix>;
 } // namespace LinearAlgebraDealII
 
 
@@ -59,19 +59,19 @@ DEAL_II_NAMESPACE_OPEN
 
 /**
  * A namespace in which the wrappers to the PETSc linear algebra classes are
- * typedef'ed to generic names. There are similar namespaces
- * LinearAlgebraDealII and LinearAlgebraTrilinos for typedefs to deal.II's own
+ * aliased to generic names. There are similar namespaces
+ * LinearAlgebraDealII and LinearAlgebraTrilinos for alias to deal.II's own
  * classes and classes that interface with Trilinos.
  */
 namespace LinearAlgebraPETSc
 {
   using namespace dealii;
 
-  typedef PETScWrappers::SolverCG    SolverCG;
-  typedef PETScWrappers::SolverGMRES SolverGMRES;
+  using SolverCG    = PETScWrappers::SolverCG;
+  using SolverGMRES = PETScWrappers::SolverGMRES;
 
   /**
-   * A namespace with typedefs to generic names for parallel PETSc linear
+   * A namespace with alias to generic names for parallel PETSc linear
    * algebra objects.
    */
   namespace MPI
@@ -79,51 +79,51 @@ namespace LinearAlgebraPETSc
     /**
      * Typedef for the vector type used.
      */
-    typedef PETScWrappers::MPI::Vector Vector;
+    using Vector = PETScWrappers::MPI::Vector;
 
     /**
      * Typedef for the type used to describe vectors that consist of multiple
      * blocks.
      */
-    typedef PETScWrappers::MPI::BlockVector BlockVector;
+    using BlockVector = PETScWrappers::MPI::BlockVector;
 
     /**
      * Typedef for the sparse matrix type used.
      */
-    typedef PETScWrappers::MPI::SparseMatrix SparseMatrix;
+    using SparseMatrix = PETScWrappers::MPI::SparseMatrix;
 
     /**
      * Typedef for the type used to describe sparse matrices that consist of
      * multiple blocks.
      */
-    typedef PETScWrappers::MPI::BlockSparseMatrix BlockSparseMatrix;
+    using BlockSparseMatrix = PETScWrappers::MPI::BlockSparseMatrix;
 
-    typedef dealii::BlockDynamicSparsityPattern BlockCompressedSparsityPattern;
+    using BlockCompressedSparsityPattern = dealii::BlockDynamicSparsityPattern;
 
     /**
      * Typedef for the AMG preconditioner type.
      */
-    typedef PETScWrappers::PreconditionBoomerAMG PreconditionAMG;
+    using PreconditionAMG = PETScWrappers::PreconditionBoomerAMG;
 
     /**
      * Typedef for the Incomplete Cholesky preconditioner.
      */
-    typedef PETScWrappers::PreconditionICC PreconditionIC;
+    using PreconditionIC = PETScWrappers::PreconditionICC;
 
     /**
      * Typedef for the Incomplete LU decomposition preconditioner.
      */
-    typedef PETScWrappers::PreconditionILU PreconditionILU;
+    using PreconditionILU = PETScWrappers::PreconditionILU;
 
     /**
      * Typedef for the Incomplete Jacobi decomposition preconditioner.
      */
-    typedef PETScWrappers::PreconditionJacobi PreconditionJacobi;
+    using PreconditionJacobi = PETScWrappers::PreconditionJacobi;
 
     /**
      * Typedef for the SSOR preconditioner.
      */
-    typedef PETScWrappers::PreconditionSSOR PreconditionSSOR;
+    using PreconditionSSOR = PETScWrappers::PreconditionSSOR;
 
   } // namespace MPI
 
@@ -145,19 +145,19 @@ DEAL_II_NAMESPACE_OPEN
 
 /**
  * A namespace in which the wrappers to the Trilinos linear algebra classes
- * are typedef'ed to generic names. There are similar namespaces
- * LinearAlgebraDealII and LinearAlgebraPETSc for typedefs to deal.II's own
+ * are aliased to generic names. There are similar namespaces
+ * LinearAlgebraDealII and LinearAlgebraPETSc for alias to deal.II's own
  * classes and classes that interface with PETSc.
  */
 namespace LinearAlgebraTrilinos
 {
   using namespace dealii;
 
-  typedef TrilinosWrappers::SolverCG    SolverCG;
-  typedef TrilinosWrappers::SolverGMRES SolverGMRES;
+  using SolverCG    = TrilinosWrappers::SolverCG;
+  using SolverGMRES = TrilinosWrappers::SolverGMRES;
 
   /**
-   * A namespace with typedefs to generic names for parallel Trilinos linear
+   * A namespace with alias to generic names for parallel Trilinos linear
    * algebra objects.
    */
   namespace MPI
@@ -165,52 +165,52 @@ namespace LinearAlgebraTrilinos
     /**
      * Typedef for the vector type used.
      */
-    typedef TrilinosWrappers::MPI::Vector Vector;
+    using Vector = TrilinosWrappers::MPI::Vector;
 
     /**
      * Typedef for the type used to describe vectors that consist of multiple
      * blocks.
      */
-    typedef TrilinosWrappers::MPI::BlockVector BlockVector;
+    using BlockVector = TrilinosWrappers::MPI::BlockVector;
 
     /**
      * Typedef for the sparse matrix type used.
      */
-    typedef TrilinosWrappers::SparseMatrix SparseMatrix;
+    using SparseMatrix = TrilinosWrappers::SparseMatrix;
 
     /**
      * Typedef for the type used to describe sparse matrices that consist of
      * multiple blocks.
      */
-    typedef TrilinosWrappers::BlockSparseMatrix BlockSparseMatrix;
+    using BlockSparseMatrix = TrilinosWrappers::BlockSparseMatrix;
 
-    typedef TrilinosWrappers::BlockSparsityPattern
-      BlockCompressedSparsityPattern;
+    using BlockCompressedSparsityPattern =
+      TrilinosWrappers::BlockSparsityPattern;
 
     /**
      * Typedef for the AMG preconditioner type.
      */
-    typedef TrilinosWrappers::PreconditionAMG PreconditionAMG;
+    using PreconditionAMG = TrilinosWrappers::PreconditionAMG;
 
     /**
      * Typedef for the Incomplete Cholesky preconditioner.
      */
-    typedef TrilinosWrappers::PreconditionIC PreconditionIC;
+    using PreconditionIC = TrilinosWrappers::PreconditionIC;
 
     /**
      * Typedef for the Incomplete LU decomposition preconditioner.
      */
-    typedef TrilinosWrappers::PreconditionILU PreconditionILU;
+    using PreconditionILU = TrilinosWrappers::PreconditionILU;
 
     /**
      * Typedef for the Incomplete Jacobi decomposition preconditioner.
      */
-    typedef TrilinosWrappers::PreconditionJacobi PreconditionJacobi;
+    using PreconditionJacobi = TrilinosWrappers::PreconditionJacobi;
 
     /**
      * Typedef for the SSOR preconditioner
      */
-    typedef TrilinosWrappers::PreconditionSSOR PreconditionSSOR;
+    using PreconditionSSOR = TrilinosWrappers::PreconditionSSOR;
 
 
   } // namespace MPI
index 855563ba9564fb5b971944e8cfabec8880c15f02..6de6024ecebf3ba3456ebf2578bc477ceb4e9e27 100644 (file)
@@ -83,7 +83,7 @@ public:
   /**
    * Declare type of container size type.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * Create an empty object.
index f54c34b7015289f957ed528d540b2501bb6cedbc..0c1bdb85e625ded44eaa2e90caac04c1aa15b24d 100644 (file)
@@ -74,7 +74,7 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * Default constructor. Creates a zero-sized matrix that should be resized
index 9080d4ae91e35ced4fabf4bcc832efca5b47700c..4ad684f7711da3271955bb6430af14893a13f9e4 100644 (file)
@@ -98,27 +98,27 @@ namespace LinearAlgebra
       static constexpr unsigned int communication_block_size = 20;
 
       /**
-       * Typedef the base class for simpler access to its own typedefs.
+       * Typedef the base class for simpler access to its own alias.
        */
-      typedef BlockVectorBase<Vector<Number>> BaseClass;
+      using BaseClass = BlockVectorBase<Vector<Number>>;
 
       /**
        * Typedef the type of the underlying vector.
        */
-      typedef typename BaseClass::BlockType BlockType;
+      using BlockType = typename BaseClass::BlockType;
 
       /**
-       * Import the typedefs from the base class.
+       * Import the alias from the base class.
        */
-      typedef typename BaseClass::value_type      value_type;
-      typedef typename BaseClass::real_type       real_type;
-      typedef typename BaseClass::pointer         pointer;
-      typedef typename BaseClass::const_pointer   const_pointer;
-      typedef typename BaseClass::reference       reference;
-      typedef typename BaseClass::const_reference const_reference;
-      typedef typename BaseClass::size_type       size_type;
-      typedef typename BaseClass::iterator        iterator;
-      typedef typename BaseClass::const_iterator  const_iterator;
+      using value_type      = typename BaseClass::value_type;
+      using real_type       = typename BaseClass::real_type;
+      using pointer         = typename BaseClass::pointer;
+      using const_pointer   = typename BaseClass::const_pointer;
+      using reference       = typename BaseClass::reference;
+      using const_reference = typename BaseClass::const_reference;
+      using size_type       = typename BaseClass::size_type;
+      using iterator        = typename BaseClass::iterator;
+      using const_iterator  = typename BaseClass::const_iterator;
 
       /**
        * @name 1: Basic operations
index 819d88cb5ea4302f4e6cd465f7ca72aa513f4590..72d001cce35c885bf77dbfd7e005f8115967a861 100644 (file)
@@ -182,15 +182,15 @@ namespace LinearAlgebra
                    public Subscriptor
     {
     public:
-      typedef Number                                            value_type;
-      typedef value_type *                                      pointer;
-      typedef const value_type *                                const_pointer;
-      typedef value_type *                                      iterator;
-      typedef const value_type *                                const_iterator;
-      typedef value_type &                                      reference;
-      typedef const value_type &                                const_reference;
-      typedef types::global_dof_index                           size_type;
-      typedef typename numbers::NumberTraits<Number>::real_type real_type;
+      using value_type      = Number;
+      using pointer         = value_type *;
+      using const_pointer   = const value_type *;
+      using iterator        = value_type *;
+      using const_iterator  = const value_type *;
+      using reference       = value_type &;
+      using const_reference = const value_type &;
+      using size_type       = types::global_dof_index;
+      using real_type       = typename numbers::NumberTraits<Number>::real_type;
 
       /**
        * @name 1: Basic Object-handling
index e27d9030142722e5d256559061355e4664cb4308..c5299acb4b8bb86a258cd17cc152d9437255eb39 100644 (file)
@@ -66,8 +66,8 @@ namespace LinearAlgebra
                  public VectorSpaceVector<Number>
   {
   public:
-    typedef types::global_dof_index                      size_type;
-    typedef typename ReadWriteVector<Number>::value_type value_type;
+    using size_type  = types::global_dof_index;
+    using value_type = typename ReadWriteVector<Number>::value_type;
 
     /**
      * Constructor. Create a vector of dimension zero.
index 98ce6922d7c11841e7b3f8d24be8d4db3bea52ab..61436ffc2778f3a9d028b9df8f536e8b97abf5eb 100644 (file)
@@ -430,9 +430,9 @@ namespace LinearAlgebra
   {
     Assert(this->size(), ExcEmptyObject());
 
-    typedef typename VectorSpaceVector<Number>::real_type real_type;
-    value_type                                            sum;
-    internal::VectorOperations::MeanValue<Number>         mean_value(
+    using real_type = typename VectorSpaceVector<Number>::real_type;
+    value_type                                    sum;
+    internal::VectorOperations::MeanValue<Number> mean_value(
       this->values.get());
     internal::VectorOperations::parallel_reduce(
       mean_value, 0, this->size(), sum, this->thread_loop_partitioner);
@@ -448,9 +448,9 @@ namespace LinearAlgebra
   {
     Assert(this->size(), ExcEmptyObject());
 
-    typedef typename VectorSpaceVector<Number>::real_type real_type;
-    real_type                                             sum;
-    internal::VectorOperations::Norm1<Number, real_type>  norm1(
+    using real_type = typename VectorSpaceVector<Number>::real_type;
+    real_type                                            sum;
+    internal::VectorOperations::Norm1<Number, real_type> norm1(
       this->values.get());
     internal::VectorOperations::parallel_reduce(
       norm1, 0, this->size(), sum, this->thread_loop_partitioner);
@@ -471,9 +471,9 @@ namespace LinearAlgebra
     // might still be finite. In that case, recompute ig (this is a rare case,
     // so working on the vector twice is uncritical and paid off by the extended
     // precision) using the BLAS approach with a weight, see e.g. dnrm2.f.
-    typedef typename VectorSpaceVector<Number>::real_type real_type;
-    real_type                                             norm_square;
-    internal::VectorOperations::Norm2<Number, real_type>  norm2(
+    using real_type = typename VectorSpaceVector<Number>::real_type;
+    real_type                                            norm_square;
+    internal::VectorOperations::Norm2<Number, real_type> norm2(
       this->values.get());
     internal::VectorOperations::parallel_reduce(
       norm2, 0, this->size(), norm_square, this->thread_loop_partitioner);
index d7ffcedb232bd65399a458effa32a7cac2e79830..a38caaf24d62cd3249b3172565210a728f58b80b 100644 (file)
@@ -62,7 +62,7 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef std::make_unsigned<types::blas_int>::type size_type;
+  using size_type = std::make_unsigned<types::blas_int>::type;
 
   /**
    * Constructor. Initialize the matrix as a square matrix with dimension
index b975ba2a9f1801124fed056e15b9a5c3917f54c2..2deea33fd4e1ae80e1e3526aaa290b94ce943f6e 100644 (file)
@@ -29,12 +29,12 @@ namespace types
   /**
    * Integer type in BLAS.
    */
-  typedef long long blas_int;
+  using blas_int = long long;
 #else
   /**
    * Integer type in BLAS.
    */
-  typedef int blas_int;
+  using blas_int = int;
 #endif
 } // namespace types
 
index cdd0d34764e5e3e4a0fa587963b0ae0e96c904ca..1cbe5b4ac02d011bf9acc0bb96d30f43d136e242 100644 (file)
@@ -1056,7 +1056,7 @@ namespace internal
       // type is std::true_type if Matrix provides vmult_add and Tvmult_add,
       // otherwise it is std::false_type
 
-      typedef decltype(test<T>(nullptr, nullptr)) type;
+      using type = decltype(test<T>(nullptr, nullptr));
     };
 
 
index fae68b2ae9a55dd7732d4a980faefdcb3c452aa6..e4baaffd452fd7ddb253baa2f8aa15a71db03421 100644 (file)
@@ -112,12 +112,12 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * Declare a type for matrix entries.
    */
-  typedef typename MatrixType::value_type value_type;
+  using value_type = typename MatrixType::value_type;
 
   /**
    * Constructor rendering an uninitialized object.
@@ -348,18 +348,18 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * The type of object stored.
    */
-  typedef MatrixBlock<MatrixType> value_type;
+  using value_type = MatrixBlock<MatrixType>;
 
   /**
    * The pointer type used for storing the objects. We use a shard pointer,
    * such that they get deleted automatically when not used anymore.
    */
-  typedef std::shared_ptr<value_type> ptr_type;
+  using ptr_type = std::shared_ptr<value_type>;
 
   /**
    * Add a new matrix block at the position <tt>(row,column)</tt> in the block
@@ -438,12 +438,12 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * The type of object stored.
    */
-  typedef MGLevelObject<MatrixBlock<MatrixType>> value_type;
+  using value_type = MGLevelObject<MatrixBlock<MatrixType>>;
   /**
    * Constructor, determining which matrices should be stored.
    *
index 33e1c115a615c6312d5af102675e176a9ba6ba77..1dc1520193735dc51cbb14bbbf343c405e087199 100644 (file)
@@ -38,12 +38,12 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * Typedef for the matrix type (including constness) we are to operate on.
    */
-  typedef typename ACCESSOR::MatrixType MatrixType;
+  using MatrixType = typename ACCESSOR::MatrixType;
 
   /**
    * Constructor. Create an iterator into the matrix <tt>matrix</tt> for the
index be8e8ba2e13a50d6b69d0872577dc14b23397642..836159eb6f101172ba388323dd291a70f41b0bb7 100644 (file)
@@ -61,7 +61,7 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * Constructor, optionally selecting a component.
index d100a3bdd7e907f80278e6e75095d3c5ba78a0f2..2f4a1c4f618e9733bfe4aba2e02f22c5d3a274bb 100644 (file)
@@ -74,7 +74,7 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * Class holding various variables which are used to modify the output of
@@ -146,7 +146,7 @@ private:
    * Abbreviate the somewhat lengthy name for the dealii::DataOutBase::Patch
    * class.
    */
-  typedef DataOutBase::Patch<2, 2> Patch;
+  using Patch = DataOutBase::Patch<2, 2>;
 
   /**
    * This is a list of patches that is created each time build_patches() is
index dd0f847919a4292433e7495545f3b7dfe9fd6cff..8c73828e2ad1a48b3e95db44b56b8a5a4c431af5 100644 (file)
@@ -497,7 +497,7 @@ namespace internal
       // type is std::true_type if Matrix provides vmult_add and Tvmult_add,
       // otherwise it is std::false_type
 
-      typedef decltype(test<T>(nullptr, nullptr, nullptr)) type;
+      using type = decltype(test<T>(nullptr, nullptr, nullptr));
     }; // namespace
   }    // namespace PackagedOperationImplementation
 } // namespace internal
index 13e17c6331da151641296db6ce517036ebcca0d5..2225ae43fc9304106ba6124145677c3b9b517950 100644 (file)
@@ -216,7 +216,7 @@ public:
   /**
    * Declare the type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * An enum that lists the possible choices for which eigenvalues to compute
index a5b9647a1fb4b3e23419ad7682bd7851689ae4b7..47b1f58a56f79773c6493cb56907f8b3ee56166e 100644 (file)
@@ -52,7 +52,7 @@ namespace PETScWrappers
     /**
      * Declare type for container size.
      */
-    typedef types::global_dof_index size_type;
+    using size_type = types::global_dof_index;
 
 
     /**
index 0f6364e61107f6dd56a817559c367c03c34080e1..91b3f8a77def76c61ea1b6cc375e8feeb309c319 100644 (file)
@@ -74,7 +74,7 @@ namespace PETScWrappers
         /**
          * Declare type for container size.
          */
-        typedef types::global_dof_index size_type;
+        using size_type = types::global_dof_index;
 
         /**
          * Constructor. Since we use accessors only for read access, a const
@@ -177,7 +177,7 @@ namespace PETScWrappers
       /**
        * Declare type for container size.
        */
-      typedef types::global_dof_index size_type;
+      using size_type = types::global_dof_index;
 
       /**
        * Constructor. Create an iterator into the matrix @p matrix for the
@@ -284,19 +284,19 @@ namespace PETScWrappers
   {
   public:
     /**
-     * Declare a typedef for the iterator class.
+     * Declare an alias for the iterator class.
      */
-    typedef MatrixIterators::const_iterator const_iterator;
+    using const_iterator = MatrixIterators::const_iterator;
 
     /**
      * Declare type for container size.
      */
-    typedef types::global_dof_index size_type;
+    using size_type = types::global_dof_index;
 
     /**
-     * Declare a typedef in analogy to all the other container classes.
+     * Declare an alias in analogy to all the other container classes.
      */
-    typedef PetscScalar value_type;
+    using value_type = PetscScalar;
 
     /**
      * Default constructor.
index efdd65c1ea1e04da5eca41fdff147cf54a614904..4502c924c152eccc1880f13df20bde17745490fa 100644 (file)
@@ -70,26 +70,26 @@ namespace PETScWrappers
     {
     public:
       /**
-       * Typedef the base class for simpler access to its own typedefs.
+       * Typedef the base class for simpler access to its own alias.
        */
-      typedef BlockMatrixBase<SparseMatrix> BaseClass;
+      using BaseClass = BlockMatrixBase<SparseMatrix>;
 
       /**
        * Typedef the type of the underlying matrix.
        */
-      typedef BaseClass::BlockType BlockType;
+      using BlockType = BaseClass::BlockType;
 
       /**
-       * Import the typedefs from the base class.
+       * Import the alias from the base class.
        */
-      typedef BaseClass::value_type      value_type;
-      typedef BaseClass::pointer         pointer;
-      typedef BaseClass::const_pointer   const_pointer;
-      typedef BaseClass::reference       reference;
-      typedef BaseClass::const_reference const_reference;
-      typedef BaseClass::size_type       size_type;
-      typedef BaseClass::iterator        iterator;
-      typedef BaseClass::const_iterator  const_iterator;
+      using value_type      = BaseClass::value_type;
+      using pointer         = BaseClass::pointer;
+      using const_pointer   = BaseClass::const_pointer;
+      using reference       = BaseClass::reference;
+      using const_reference = BaseClass::const_reference;
+      using size_type       = BaseClass::size_type;
+      using iterator        = BaseClass::iterator;
+      using const_iterator  = BaseClass::const_iterator;
 
       /**
        * Constructor; initializes the matrix to be empty, without any
index fec1b750087b9585e4c0911d98d04ebd98d39b00..56206b91e88795982df466ee8c8868572c3cabdd 100644 (file)
@@ -62,26 +62,26 @@ namespace PETScWrappers
     {
     public:
       /**
-       * Typedef the base class for simpler access to its own typedefs.
+       * Typedef the base class for simpler access to its own alias.
        */
-      typedef BlockVectorBase<Vector> BaseClass;
+      using BaseClass = BlockVectorBase<Vector>;
 
       /**
        * Typedef the type of the underlying vector.
        */
-      typedef BaseClass::BlockType BlockType;
+      using BlockType = BaseClass::BlockType;
 
       /**
-       * Import the typedefs from the base class.
+       * Import the alias from the base class.
        */
-      typedef BaseClass::value_type      value_type;
-      typedef BaseClass::pointer         pointer;
-      typedef BaseClass::const_pointer   const_pointer;
-      typedef BaseClass::reference       reference;
-      typedef BaseClass::const_reference const_reference;
-      typedef BaseClass::size_type       size_type;
-      typedef BaseClass::iterator        iterator;
-      typedef BaseClass::const_iterator  const_iterator;
+      using value_type      = BaseClass::value_type;
+      using pointer         = BaseClass::pointer;
+      using const_pointer   = BaseClass::const_pointer;
+      using reference       = BaseClass::reference;
+      using const_reference = BaseClass::const_reference;
+      using size_type       = BaseClass::size_type;
+      using iterator        = BaseClass::iterator;
+      using const_iterator  = BaseClass::const_iterator;
 
       /**
        * Default constructor. Generate an empty vector without any blocks.
index 36ec27b3a38f6313582fd56a42f33c6cdaf8591c..f193d02373c50d0e60c6ac0760134ce5078e8a1c 100644 (file)
@@ -121,7 +121,7 @@ namespace PETScWrappers
       /**
        * Declare type for container size.
        */
-      typedef types::global_dof_index size_type;
+      using size_type = types::global_dof_index;
 
       /**
        * A structure that describes some of the traits of this class in terms
index 6e366cdf1bca022619d78196de2d8868b9f163da..12c4bc2cd615f09a2fe441f1bf3aec6bdd771e17 100644 (file)
@@ -161,7 +161,7 @@ namespace PETScWrappers
       /**
        * Declare type for container size.
        */
-      typedef types::global_dof_index size_type;
+      using size_type = types::global_dof_index;
 
       /**
        * Default constructor. Initialize the vector as empty.
index 5dde843a666f799f7eb06fc576d6492935cf296a..c2706b096ac7b1e3c0a7ca14880944c30c021a78 100644 (file)
@@ -81,7 +81,7 @@ namespace PETScWrappers
       /**
        * Declare type for container size.
        */
-      typedef types::global_dof_index size_type;
+      using size_type = types::global_dof_index;
 
     private:
       /**
@@ -244,11 +244,11 @@ namespace PETScWrappers
      * parallel those in the <tt>C++</tt> standard libraries
      * <tt>vector<...></tt> class.
      */
-    typedef PetscScalar                     value_type;
-    typedef PetscReal                       real_type;
-    typedef types::global_dof_index         size_type;
-    typedef internal::VectorReference       reference;
-    typedef const internal::VectorReference const_reference;
+    using value_type      = PetscScalar;
+    using real_type       = PetscReal;
+    using size_type       = types::global_dof_index;
+    using reference       = internal::VectorReference;
+    using const_reference = const internal::VectorReference;
 
     /**
      * Default constructor. It doesn't do anything, derived classes will have
index 59c6cf46072444b9a3cecda7d376966a5af4f3ee..7457d82cbd92d30fb6bd97cc0db93b618e8550d6 100644 (file)
@@ -71,7 +71,7 @@ public:
    * This was defined to make this matrix a possible template argument to
    * BlockMatrixArray.
    */
-  typedef typename VectorType::value_type value_type;
+  using value_type = typename VectorType::value_type;
 
   /**
    * Virtual destructor.  Does nothing except making sure that the destructor
index 1776ec2cd652a0f62d1b5c5925ed88024862b1fd..f21dbd2799bc1be69879dc942bfd01d50e124863 100644 (file)
@@ -81,7 +81,7 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * This function is only present to provide the interface of a
@@ -200,7 +200,7 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * Parameters for Richardson preconditioner.
@@ -367,8 +367,8 @@ public:
   /**
    * Type of the preconditioning function of the matrix.
    */
-  typedef void (MatrixType::*function_ptr)(VectorType &,
-                                           const VectorType &) const;
+  using function_ptr = void (MatrixType::*)(VectorType &,
+                                            const VectorType &) const;
 
   /**
    * Constructor.  This constructor stores a reference to the matrix object
@@ -413,7 +413,7 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef typename MatrixType::size_type size_type;
+  using size_type = typename MatrixType::size_type;
 
   /**
    * Class for parameters.
@@ -508,10 +508,10 @@ class PreconditionJacobi : public PreconditionRelaxation<MatrixType>
 {
 public:
   /**
-   * A typedef to the base class AdditionalData.
+   * An alias to the base class AdditionalData.
    */
-  typedef
-    typename PreconditionRelaxation<MatrixType>::AdditionalData AdditionalData;
+  using AdditionalData =
+    typename PreconditionRelaxation<MatrixType>::AdditionalData;
 
   /**
    * Apply preconditioner.
@@ -596,10 +596,10 @@ class PreconditionSOR : public PreconditionRelaxation<MatrixType>
 {
 public:
   /**
-   * A typedef to the base class AdditionalData.
+   * An alias to the base class AdditionalData.
    */
-  typedef
-    typename PreconditionRelaxation<MatrixType>::AdditionalData AdditionalData;
+  using AdditionalData =
+    typename PreconditionRelaxation<MatrixType>::AdditionalData;
 
   /**
    * Apply preconditioner.
@@ -665,20 +665,20 @@ class PreconditionSSOR : public PreconditionRelaxation<MatrixType>
 {
 public:
   /**
-   * A typedef to the base class AdditionalData.
+   * An alias to the base class AdditionalData.
    */
-  typedef
-    typename PreconditionRelaxation<MatrixType>::AdditionalData AdditionalData;
+  using AdditionalData =
+    typename PreconditionRelaxation<MatrixType>::AdditionalData;
 
   /**
    * Declare type for container size.
    */
-  typedef typename MatrixType::size_type size_type;
+  using size_type = typename MatrixType::size_type;
 
   /**
-   * A typedef to the base class.
+   * An alias to the base class.
    */
-  typedef PreconditionRelaxation<MatrixType> BaseClass;
+  using BaseClass = PreconditionRelaxation<MatrixType>;
 
 
   /**
@@ -769,7 +769,7 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef typename MatrixType::size_type size_type;
+  using size_type = typename MatrixType::size_type;
 
   /**
    * Parameters for PreconditionPSOR.
@@ -964,7 +964,7 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   // avoid warning about use of deprecated variables
 
index a48b27553d53ca751511261b1025e06e6d61b9ae..b23bd2b9a6b2d6564406b69b061e2180efa7e991 100644 (file)
@@ -88,18 +88,18 @@ private:
   /**
    * Define number type of matrix.
    */
-  typedef typename MatrixType::value_type number;
+  using number = typename MatrixType::value_type;
 
   /**
    * Value type for inverse matrices.
    */
-  typedef inverse_type value_type;
+  using value_type = inverse_type;
 
 public:
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * Parameters for block preconditioners.
@@ -387,13 +387,13 @@ private:
   /**
    * Define number type of matrix.
    */
-  typedef typename MatrixType::value_type number;
+  using number = typename MatrixType::value_type;
 
 public:
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * Standard-conforming iterator.
@@ -666,7 +666,7 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * Default constructor.
@@ -676,7 +676,7 @@ public:
   /**
    * Define number type of matrix.
    */
-  typedef typename MatrixType::value_type number;
+  using number = typename MatrixType::value_type;
 
   /**
    * import types and functions from protected base class.
@@ -831,12 +831,12 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * Define number type of matrix.
    */
-  typedef typename MatrixType::value_type number;
+  using number = typename MatrixType::value_type;
 
   /**
    * Constructor.
index a6afe45769eca91844ec28ce22573ea034f643e5..53a83ec975ebd7a79e16921e54337f482dee09bd 100644 (file)
@@ -61,7 +61,7 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * Choose a method for inverting the blocks, and thus the data type for the
index 694028a02b8f8d183c8dc181951085bd6f6dfe96..7b6b2f27edd3c69a5ca13c8d37260574acb34c25 100644 (file)
@@ -102,7 +102,7 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef typename MatrixType::size_type size_type;
+  using size_type = typename MatrixType::size_type;
 
   /**
    * Constructor. @p omega denotes the damping parameter of the
index 54e21e83ffdeafeeb37575d6cbabd8487a299820..9a3a1529abd547e398b3c623ad955c0078fd2c3c 100644 (file)
@@ -133,15 +133,15 @@ namespace LinearAlgebra
      * those in the <tt>C++</tt> standard libraries <tt>vector<...></tt>
      * class.
      */
-    typedef Number                                            value_type;
-    typedef value_type *                                      pointer;
-    typedef const value_type *                                const_pointer;
-    typedef value_type *                                      iterator;
-    typedef const value_type *                                const_iterator;
-    typedef value_type &                                      reference;
-    typedef const value_type &                                const_reference;
-    typedef types::global_dof_index                           size_type;
-    typedef typename numbers::NumberTraits<Number>::real_type real_type;
+    using value_type      = Number;
+    using pointer         = value_type *;
+    using const_pointer   = const value_type *;
+    using iterator        = value_type *;
+    using const_iterator  = const value_type *;
+    using reference       = value_type &;
+    using const_reference = const value_type &;
+    using size_type       = types::global_dof_index;
+    using real_type       = typename numbers::NumberTraits<Number>::real_type;
 
     /**
      * @name 1: Basic Object-handling
index 8bd94bc1dffb40180961373c0b001458823ad490..f04df68326236b490a7b9a8494524e57e3f15170 100644 (file)
@@ -60,18 +60,18 @@ private:
   /**
    * Define number type of matrix.
    */
-  typedef typename MatrixType::value_type number;
+  using number = typename MatrixType::value_type;
 
   /**
    * Value type for inverse matrices.
    */
-  typedef InverseNumberType value_type;
+  using value_type = InverseNumberType;
 
 public:
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * Parameters for block relaxation methods. In addition to typical control
@@ -299,7 +299,7 @@ public:
   /**
    * Define number type of matrix.
    */
-  typedef typename MatrixType::value_type number;
+  using number = typename MatrixType::value_type;
 
   /**
    * Make type publicly available.
@@ -397,7 +397,7 @@ public:
   /**
    * Define number type of matrix.
    */
-  typedef typename MatrixType::value_type number;
+  using number = typename MatrixType::value_type;
 
   /**
    * Make type publicly available.
@@ -490,7 +490,7 @@ public:
   /**
    * Define number type of matrix.
    */
-  typedef typename MatrixType::value_type number;
+  using number = typename MatrixType::value_type;
 
   /**
    * Make type publicly available.
index e86c8b6cdd44b6f89cd42ff22eeb425fc8c158f0..721dad3f80cc5b95e6a79d993c3a9e8a72b24d56 100644 (file)
@@ -110,7 +110,7 @@ public:
   /**
    * Declare the type for container size.
    */
-  typedef unsigned int size_type;
+  using size_type = unsigned int;
 
   /**
    * Constructor for a rectangular matrix with @p n_rows and @p n_cols
index 6d258a5d5568fdacf47d7027bd830eb57aebe962..4b0b3108fc81170ab99513ca8fcac276ef39dfc5 100644 (file)
@@ -328,9 +328,9 @@ class Solver : public Subscriptor
 {
 public:
   /**
-   * A typedef for the underlying vector type
+   * An alias for the underlying vector type
    */
-  typedef VectorType vector_type;
+  using vector_type = VectorType;
 
   /**
    * Constructor. Takes a control object which evaluates the conditions for
@@ -417,7 +417,7 @@ private:
    */
   struct StateCombiner
   {
-    typedef SolverControl::State result_type;
+    using result_type = SolverControl::State;
 
     SolverControl::State
     operator()(const SolverControl::State state1,
index 658645bd76148a2e0da114d1334d169b2bd0b8e3..9d1656ca87680ed0f78bc0798b4a2251b3885def 100644 (file)
@@ -99,7 +99,7 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * Standardized data struct to pipe additional data to the solver.
index 309efd32558a87a5ad92159fa1512e757d4447a7..cda91557577610f7c6a392c59a08a852126e8dec 100644 (file)
@@ -210,10 +210,10 @@ SolverMinRes<VectorType>::solve(const MatrixType &        A,
   typename VectorMemory<VectorType>::Pointer Vv(this->memory);
 
   // define some aliases for simpler access
-  typedef VectorType *vecptr;
-  vecptr              u[3] = {Vu0.get(), Vu1.get(), Vu2.get()};
-  vecptr              m[3] = {Vm0.get(), Vm1.get(), Vm2.get()};
-  VectorType &        v    = *Vv;
+  using vecptr     = VectorType *;
+  vecptr      u[3] = {Vu0.get(), Vu1.get(), Vu2.get()};
+  vecptr      m[3] = {Vm0.get(), Vm1.get(), Vm2.get()};
+  VectorType &v    = *Vv;
 
   // resize the vectors, but do not set the values since they'd be overwritten
   // soon anyway.
index 0c884510ca9ee28707f547a9939f194ecd55f018..893e3d294ab38841c4c6aa6153801bf40d6faaaf 100644 (file)
@@ -100,9 +100,9 @@ class SolverSelector : public Subscriptor
 {
 public:
   /**
-   * A typedef for the underlying vector type
+   * An alias for the underlying vector type
    */
-  typedef VectorType vector_type;
+  using vector_type = VectorType;
 
   /**
    * Constructor, filling in default values
index d89d692319164eccbc65d97316d95728adfebf53..3c774c8aeefed607f4785c14d9c08350cf176a24 100644 (file)
@@ -123,7 +123,7 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef typename SparseMatrix<number>::size_type size_type;
+  using size_type = typename SparseMatrix<number>::size_type;
 
   /**
    * Destruction. Mark the destructor pure to ensure that this class isn't
index d33b0187302854f492d0bae29abd71f3c51870ce..2ceeaba60ae0f7532097dff5f476f277bf70dcd6 100644 (file)
@@ -87,7 +87,7 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * Dummy class needed for the usual initialization interface of
index c82faa7c6c6bcbaee605d4e9f234d1d4b0d1b15b..b8e824d212bb591261f6dcf29ac09dbd4cb0b8e3 100644 (file)
@@ -64,7 +64,7 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef typename SparseLUDecomposition<number>::size_type size_type;
+  using size_type = typename SparseLUDecomposition<number>::size_type;
 
   /**
    * Constructor. Does nothing.
@@ -78,7 +78,7 @@ public:
    * Make SparseLUDecomposition::AdditionalData accessible to this class as
    * well.
    */
-  typedef typename SparseLUDecomposition<number>::AdditionalData AdditionalData;
+  using AdditionalData = typename SparseLUDecomposition<number>::AdditionalData;
 
   /**
    * Perform the incomplete LU factorization of the given matrix.
index 9b67d8c24bdbe6d136f896c15a9fba5f3d9d2fad..6c804e899f4c19d87dbc6139d0e14809b77b99dd 100644 (file)
@@ -76,7 +76,7 @@ namespace SparseMatrixIterators
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   // forward declaration
   template <typename number, bool Constness>
@@ -132,7 +132,7 @@ namespace SparseMatrixIterators
      * Typedef for the type (including constness) of the matrix to be used
      * here.
      */
-    typedef const SparseMatrix<number> MatrixType;
+    using MatrixType = const SparseMatrix<number>;
 
     /**
      * Constructor.
@@ -272,7 +272,7 @@ namespace SparseMatrixIterators
      * Typedef for the type (including constness) of the matrix to be used
      * here.
      */
-    typedef SparseMatrix<number> MatrixType;
+    using MatrixType = SparseMatrix<number>;
 
     /**
      * Constructor.
@@ -353,13 +353,13 @@ namespace SparseMatrixIterators
     /**
      * Typedef for the matrix type (including constness) we are to operate on.
      */
-    typedef typename Accessor<number, Constness>::MatrixType MatrixType;
+    using MatrixType = typename Accessor<number, Constness>::MatrixType;
 
     /**
-     * A typedef for the type you get when you dereference an iterator of the
+     * An alias for the type you get when you dereference an iterator of the
      * current kind.
      */
-    typedef const Accessor<number, Constness> &value_type;
+    using value_type = const Accessor<number, Constness> &;
 
     /**
      * Constructor. Create an iterator into the matrix @p matrix for the given
@@ -495,13 +495,13 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
-   * Type of the matrix entries. This typedef is analogous to
+   * Type of the matrix entries. This alias is analogous to
    * <tt>value_type</tt> in the standard library containers.
    */
-  typedef number value_type;
+  using value_type = number;
 
   /**
    * Declare a type that has holds real-valued numbers with the same precision
@@ -510,15 +510,15 @@ public:
    * If the template argument is a std::complex type then real_type equals the
    * type underlying the complex numbers.
    *
-   * This typedef is used to represent the return type of norms.
+   * This alias is used to represent the return type of norms.
    */
-  typedef typename numbers::NumberTraits<number>::real_type real_type;
+  using real_type = typename numbers::NumberTraits<number>::real_type;
 
   /**
    * Typedef of an iterator class walking over all the nonzero entries of this
    * matrix. This iterator cannot change the values of the matrix.
    */
-  typedef SparseMatrixIterators::Iterator<number, true> const_iterator;
+  using const_iterator = SparseMatrixIterators::Iterator<number, true>;
 
   /**
    * Typedef of an iterator class walking over all the nonzero entries of this
@@ -526,7 +526,7 @@ public:
    * course can't change the sparsity pattern as this is fixed once a sparse
    * matrix is attached to it.
    */
-  typedef SparseMatrixIterators::Iterator<number, false> iterator;
+  using iterator = SparseMatrixIterators::Iterator<number, false>;
 
   /**
    * A structure that describes some of the traits of this class in terms of
@@ -2061,11 +2061,10 @@ SparseMatrix<number>::copy_from(const ForwardIterator begin,
   Assert(static_cast<size_type>(std::distance(begin, end)) == m(),
          ExcIteratorRange(std::distance(begin, end), m()));
 
-  // for use in the inner loop, we define a typedef to the type of the inner
+  // for use in the inner loop, we define an alias to the type of the inner
   // iterators
-  typedef
-    typename std::iterator_traits<ForwardIterator>::value_type::const_iterator
-            inner_iterator;
+  using inner_iterator =
+    typename std::iterator_traits<ForwardIterator>::value_type::const_iterator;
   size_type row = 0;
   for (ForwardIterator i = begin; i != end; ++i, ++row)
     {
index 446436123bfb7412797bfdc4382cf9464a9f9ade..2566bb0cb9a60a7ac45b3e4280d3e132e72c252f 100644 (file)
@@ -165,7 +165,7 @@ namespace internal
 {
   namespace SparseMatrixImplementation
   {
-    typedef types::global_dof_index size_type;
+    using size_type = types::global_dof_index;
 
     template <typename T>
     typename std::enable_if<std::is_trivial<T>::value>::type
index 2b0871ae27f19fd41ce3f0a95c0f1ce92cc836fe..9a219f8db8b49c7b674989e4b3285fc00233c455 100644 (file)
@@ -107,7 +107,7 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * The class for storing the column number of an entry together with its
@@ -296,10 +296,10 @@ public:
   };
 
   /**
-   * Type of matrix entries. This typedef is analogous to <tt>value_type</tt>
+   * Type of matrix entries. This alias is analogous to <tt>value_type</tt>
    * in the standard library containers.
    */
-  typedef number value_type;
+  using value_type = number;
 
   /**
    * @name Constructors and initialization
index 1b0cecf8a1916d9eac34873ff19b8ff2f4f94abb..3a1a1660f7a9f7aaad213c566be669b18fea7fdf 100644 (file)
@@ -50,7 +50,7 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * Constructor. Does nothing, so you have to call @p decompose sometimes
@@ -74,7 +74,7 @@ public:
    * Make the @p AdditionalData type in the base class accessible to this
    * class as well.
    */
-  typedef typename SparseLUDecomposition<number>::AdditionalData AdditionalData;
+  using AdditionalData = typename SparseLUDecomposition<number>::AdditionalData;
 
   /**
    * Perform the incomplete LU factorization of the given matrix.
index 87b803b35e0ef3888e1384c9edb1f3e149ba1bad..96f4a66b5ecedad5a757ea5e204b42d1a38251b3 100644 (file)
@@ -140,7 +140,7 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * Constructor. Does nothing.
@@ -523,7 +523,7 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * Enumeration of the different methods by which the DoFs are distributed to
index a83f567d50ecc7072f26499a407bf8214da698e3..030899d631fa7d8695812f4ace80c13c0aaa6aae 100644 (file)
@@ -152,7 +152,8 @@ SparseVanka<number>::compute_inverses()
     };
   blocking[n_threads - 1].second = matrix->m();
 
-  typedef void (SparseVanka<number>::*FunPtr)(const size_type, const size_type);
+  using FunPtr =
+    void (SparseVanka<number>::*)(const size_type, const size_type);
   const FunPtr fun_ptr = &SparseVanka<number>::compute_inverses;
 
   // Now spawn the threads
@@ -612,31 +613,22 @@ SparseBlockVanka<number>::vmult(Vector<number2> &      dst,
 {
   dst = 0;
 
-  // if no blocking is required, pass
-  // down to the underlying class
+  // if no blocking is required, pass down to the underlying class
   if (n_blocks == 1)
     this->apply_preconditioner(dst, src);
   else
     // otherwise: blocking requested
     {
 #ifdef DEAL_II_WITH_THREADS
-      // spawn threads. since
-      // some compilers have
-      // trouble finding out
-      // which 'encapsulate'
-      // function to take of all
-      // those possible ones if
-      // we simply drop in the
-      // address of an overloaded
-      // template member
-      // function, make it
-      // simpler for the compiler
-      // by giving it the correct
-      // type right away:
-      typedef void (
-        SparseVanka<number>::*mem_fun_p)(Vector<number2> &,
-                                         const Vector<number2> &,
-                                         const std::vector<bool> *const) const;
+      // spawn threads. since some compilers have trouble finding out which
+      // 'encapsulate' function to take of all those possible ones if we simply
+      // idrop in the address of an overloaded template member function, make it
+      // simpler for the compiler by giving it the correct type right away:
+      using mem_fun_p =
+        void (SparseVanka<number>::*)(Vector<number2> &,
+                                      const Vector<number2> &,
+                                      const std::vector<bool> *const) const;
+
       const mem_fun_p comp =
         &SparseVanka<number>::template apply_preconditioner<number2>;
       Threads::ThreadGroup<> threads;
index 3141362836cdc9df95c84646dd5c5aa704d31d17..ada2a4dd332adec88ef7c9599ffca8fc08d873f4 100644 (file)
@@ -70,7 +70,7 @@ namespace internals
     /**
      * Declare type for container size.
      */
-    typedef types::global_dof_index size_type;
+    using size_type = types::global_dof_index;
 
     /**
      * Helper function to get the column index from a dereferenced iterator in
@@ -113,7 +113,7 @@ namespace SparsityPatternIterators
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * Accessor class for iterators into sparsity patterns. This class is also
@@ -376,13 +376,13 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * Typedef an iterator class that allows to walk over all nonzero elements
    * of a sparsity pattern.
    */
-  typedef SparsityPatternIterators::Iterator const_iterator;
+  using const_iterator = SparsityPatternIterators::Iterator;
 
   /**
    * Typedef an iterator class that allows to walk over all nonzero elements
@@ -391,7 +391,7 @@ public:
    * Since the iterator does not allow to modify the sparsity pattern, this
    * type is the same as that for @p const_iterator.
    */
-  typedef SparsityPatternIterators::Iterator iterator;
+  using iterator = SparsityPatternIterators::Iterator;
 
 
   /**
@@ -1536,7 +1536,7 @@ namespace internal
     /**
      * Declare type for container size.
      */
-    typedef types::global_dof_index size_type;
+    using size_type = types::global_dof_index;
 
     inline size_type
     get_column_index_from_iterator(const size_type i)
@@ -1591,12 +1591,11 @@ SparsityPattern::copy_from(const size_type       n_rows,
   // now enter all the elements into the matrix. note that if the matrix is
   // quadratic, then we already have the diagonal element preallocated
   //
-  // for use in the inner loop, we define a typedef to the type of the inner
+  // for use in the inner loop, we define an alias to the type of the inner
   // iterators
   size_type row = 0;
-  typedef
-    typename std::iterator_traits<ForwardIterator>::value_type::const_iterator
-      inner_iterator;
+  using inner_iterator =
+    typename std::iterator_traits<ForwardIterator>::value_type::const_iterator;
   for (ForwardIterator i = begin; i != end; ++i, ++row)
     {
       size_type *          cols = &colnums[rowstart[row]] + (is_square ? 1 : 0);
index 72f8bdeb648a7e0fcc8f82b686c2459de05b2b4c..9ccff0c068c1296e8556a3d8c9abd1d061194b41 100644 (file)
@@ -57,7 +57,7 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * @name Constructors and initialization.
index 5d9d5091af65a61bfd7aa45b59c7f2fac44f5d62..5babf1cd791aeb3f5e61ba3bba4c11bda0a27de0 100644 (file)
@@ -73,26 +73,26 @@ namespace TrilinosWrappers
   {
   public:
     /**
-     * Typedef the base class for simpler access to its own typedefs.
+     * Typedef the base class for simpler access to its own alias.
      */
-    typedef BlockMatrixBase<SparseMatrix> BaseClass;
+    using BaseClass = BlockMatrixBase<SparseMatrix>;
 
     /**
      * Typedef the type of the underlying matrix.
      */
-    typedef BaseClass::BlockType BlockType;
+    using BlockType = BaseClass::BlockType;
 
     /**
-     * Import the typedefs from the base class.
+     * Import the alias from the base class.
      */
-    typedef BaseClass::value_type      value_type;
-    typedef BaseClass::pointer         pointer;
-    typedef BaseClass::const_pointer   const_pointer;
-    typedef BaseClass::reference       reference;
-    typedef BaseClass::const_reference const_reference;
-    typedef BaseClass::size_type       size_type;
-    typedef BaseClass::iterator        iterator;
-    typedef BaseClass::const_iterator  const_iterator;
+    using value_type      = BaseClass::value_type;
+    using pointer         = BaseClass::pointer;
+    using const_pointer   = BaseClass::const_pointer;
+    using reference       = BaseClass::reference;
+    using const_reference = BaseClass::const_reference;
+    using size_type       = BaseClass::size_type;
+    using iterator        = BaseClass::iterator;
+    using const_iterator  = BaseClass::const_iterator;
 
     /**
      * Constructor; initializes the matrix to be empty, without any structure,
@@ -625,7 +625,7 @@ namespace TrilinosWrappers
         /**
          * Type of payload held by each subblock
          */
-        typedef PayloadBlockType BlockType;
+        using BlockType = PayloadBlockType;
 
         /**
          * Default constructor
index 7a3af8bc25d2300ec5566e8670247d2bdb5b085d..65a5916b96df77fef776e11744ed12b092ff3965 100644 (file)
@@ -76,9 +76,9 @@ namespace TrilinosWrappers
   linear_operator(const TrilinosWrappers::SparseMatrix &operator_exemplar,
                   const Matrix &                        matrix)
   {
-    typedef TrilinosWrappers::SparseMatrix OperatorExemplar;
-    typedef TrilinosWrappers::internal::LinearOperatorImplementation::
-      TrilinosPayload Payload;
+    using OperatorExemplar = TrilinosWrappers::SparseMatrix;
+    using Payload =
+      TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload;
     return dealii::
       linear_operator<Range, Domain, Payload, OperatorExemplar, Matrix>(
         operator_exemplar, matrix);
@@ -106,9 +106,9 @@ namespace TrilinosWrappers
     TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload>
   linear_operator(const TrilinosWrappers::SparseMatrix &matrix)
   {
-    typedef TrilinosWrappers::SparseMatrix Matrix;
-    typedef TrilinosWrappers::internal::LinearOperatorImplementation::
-      TrilinosPayload Payload;
+    using Matrix = TrilinosWrappers::SparseMatrix;
+    using Payload =
+      TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload;
     return dealii::linear_operator<Range, Domain, Payload, Matrix, Matrix>(
       matrix, matrix);
   }
@@ -143,12 +143,11 @@ namespace TrilinosWrappers
                              LinearOperatorImplementation::TrilinosPayload>>
   block_operator(const TrilinosWrappers::BlockSparseMatrix &block_matrix)
   {
-    typedef TrilinosWrappers::BlockSparseMatrix BlockMatrix;
-    typedef TrilinosWrappers::internal::LinearOperatorImplementation::
-      TrilinosPayload PayloadBlockType;
-    typedef TrilinosWrappers::internal::BlockLinearOperatorImplementation::
-      TrilinosBlockPayload<PayloadBlockType>
-        BlockPayload;
+    using BlockMatrix = TrilinosWrappers::BlockSparseMatrix;
+    using PayloadBlockType =
+      TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload;
+    using BlockPayload = TrilinosWrappers::internal::
+      BlockLinearOperatorImplementation::TrilinosBlockPayload<PayloadBlockType>;
     return dealii::block_operator<Range, Domain, BlockPayload, BlockMatrix>(
       block_matrix);
   }
@@ -186,11 +185,10 @@ namespace TrilinosWrappers
         n>,
       m> &ops)
   {
-    typedef TrilinosWrappers::internal::LinearOperatorImplementation::
-      TrilinosPayload PayloadBlockType;
-    typedef TrilinosWrappers::internal::BlockLinearOperatorImplementation::
-      TrilinosBlockPayload<PayloadBlockType>
-        BlockPayload;
+    using PayloadBlockType =
+      TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload;
+    using BlockPayload = TrilinosWrappers::internal::
+      BlockLinearOperatorImplementation::TrilinosBlockPayload<PayloadBlockType>;
     return dealii::block_operator<m, n, Range, Domain, BlockPayload>(ops);
   }
 
@@ -222,12 +220,11 @@ namespace TrilinosWrappers
   block_diagonal_operator(
     const TrilinosWrappers::BlockSparseMatrix &block_matrix)
   {
-    typedef TrilinosWrappers::BlockSparseMatrix BlockMatrix;
-    typedef TrilinosWrappers::internal::LinearOperatorImplementation::
-      TrilinosPayload PayloadBlockType;
-    typedef TrilinosWrappers::internal::BlockLinearOperatorImplementation::
-      TrilinosBlockPayload<PayloadBlockType>
-        BlockPayload;
+    using BlockMatrix = TrilinosWrappers::BlockSparseMatrix;
+    using PayloadBlockType =
+      TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload;
+    using BlockPayload = TrilinosWrappers::internal::
+      BlockLinearOperatorImplementation::TrilinosBlockPayload<PayloadBlockType>;
     return dealii::
       block_diagonal_operator<Range, Domain, BlockPayload, BlockMatrix>(
         block_matrix);
@@ -264,11 +261,10 @@ namespace TrilinosWrappers
                        TrilinosPayload>,
       m> &ops)
   {
-    typedef TrilinosWrappers::internal::LinearOperatorImplementation::
-      TrilinosPayload PayloadBlockType;
-    typedef TrilinosWrappers::internal::BlockLinearOperatorImplementation::
-      TrilinosBlockPayload<PayloadBlockType>
-        BlockPayload;
+    using PayloadBlockType =
+      TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload;
+    using BlockPayload = TrilinosWrappers::internal::
+      BlockLinearOperatorImplementation::TrilinosBlockPayload<PayloadBlockType>;
     return dealii::block_diagonal_operator<m, Range, Domain, BlockPayload>(ops);
   }
 
index ae356ac7e3b63cea722be04decb3386f808a5bfc..7977620e193352672660bc441d0f00a551fbcacc 100644 (file)
@@ -72,26 +72,26 @@ namespace TrilinosWrappers
     {
     public:
       /**
-       * Typedef the base class for simpler access to its own typedefs.
+       * Typedef the base class for simpler access to its own alias.
        */
-      typedef dealii::BlockVectorBase<MPI::Vector> BaseClass;
+      using BaseClass = dealii::BlockVectorBase<MPI::Vector>;
 
       /**
        * Typedef the type of the underlying vector.
        */
-      typedef BaseClass::BlockType BlockType;
+      using BlockType = BaseClass::BlockType;
 
       /**
-       * Import the typedefs from the base class.
+       * Import the alias from the base class.
        */
-      typedef BaseClass::value_type      value_type;
-      typedef BaseClass::pointer         pointer;
-      typedef BaseClass::const_pointer   const_pointer;
-      typedef BaseClass::reference       reference;
-      typedef BaseClass::const_reference const_reference;
-      typedef BaseClass::size_type       size_type;
-      typedef BaseClass::iterator        iterator;
-      typedef BaseClass::const_iterator  const_iterator;
+      using value_type      = BaseClass::value_type;
+      using pointer         = BaseClass::pointer;
+      using const_pointer   = BaseClass::const_pointer;
+      using reference       = BaseClass::reference;
+      using const_reference = BaseClass::const_reference;
+      using size_type       = BaseClass::size_type;
+      using iterator        = BaseClass::iterator;
+      using const_iterator  = BaseClass::const_iterator;
 
       /**
        * Default constructor. Generate an empty vector without any blocks.
index a75ca3187f23abdf00f3806bc87161b408e51a2d..81a00643c96dc44c8a254baee45277dd3eb78223 100644 (file)
@@ -81,7 +81,7 @@ namespace TrilinosWrappers
     /**
      * Declare the type for container size.
      */
-    typedef dealii::types::global_dof_index size_type;
+    using size_type = dealii::types::global_dof_index;
 
     /**
      * Standardized data struct to pipe additional flags to the
index 75bbeb11b696cddc9a3f454af128f2506f41f52b..8beb62a1ec04aaa7b14cc1eb74b0d2c46631ea80 100644 (file)
@@ -111,7 +111,7 @@ namespace TrilinosWrappers
       /**
        * Declare the type for container size.
        */
-      typedef dealii::types::global_dof_index size_type;
+      using size_type = dealii::types::global_dof_index;
 
       /**
        * Constructor.
@@ -221,7 +221,7 @@ namespace TrilinosWrappers
        * Typedef for the type (including constness) of the matrix to be used
        * here.
        */
-      typedef const SparseMatrix MatrixType;
+      using MatrixType = const SparseMatrix;
 
       /**
        * Constructor. Since we use accessors only for read access, a const
@@ -312,7 +312,7 @@ namespace TrilinosWrappers
        * Typedef for the type (including constness) of the matrix to be used
        * here.
        */
-      typedef SparseMatrix MatrixType;
+      using MatrixType = SparseMatrix;
 
       /**
        * Constructor. Since we use accessors only for read access, a const
@@ -359,13 +359,13 @@ namespace TrilinosWrappers
       /**
        * Declare type for container size.
        */
-      typedef dealii::types::global_dof_index size_type;
+      using size_type = dealii::types::global_dof_index;
 
       /**
        * Typedef for the matrix type (including constness) we are to operate
        * on.
        */
-      typedef typename Accessor<Constness>::MatrixType MatrixType;
+      using MatrixType = typename Accessor<Constness>::MatrixType;
 
       /**
        * Constructor. Create an iterator into the matrix @p matrix for the
@@ -517,7 +517,7 @@ namespace TrilinosWrappers
     /**
      * Declare the type for container size.
      */
-    typedef dealii::types::global_dof_index size_type;
+    using size_type = dealii::types::global_dof_index;
 
     /**
      * Exception
@@ -546,19 +546,19 @@ namespace TrilinosWrappers
     };
 
     /**
-     * Declare a typedef for the iterator class.
+     * Declare an alias for the iterator class.
      */
-    typedef SparseMatrixIterators::Iterator<false> iterator;
+    using iterator = SparseMatrixIterators::Iterator<false>;
 
     /**
-     * Declare a typedef for the const iterator class.
+     * Declare an alias for the const iterator class.
      */
-    typedef SparseMatrixIterators::Iterator<true> const_iterator;
+    using const_iterator = SparseMatrixIterators::Iterator<true>;
 
     /**
-     * Declare a typedef in analogy to all the other container classes.
+     * Declare an alias in analogy to all the other container classes.
      */
-    typedef TrilinosScalar value_type;
+    using value_type = TrilinosScalar;
 
     /**
      * @name Constructors and initialization.
@@ -2244,17 +2244,17 @@ namespace TrilinosWrappers
         /**
          * Definition for the internally supported vector type.
          */
-        typedef Epetra_MultiVector VectorType;
+        using VectorType = Epetra_MultiVector;
 
         /**
          * Definition for the vector type for the domain space of the operator.
          */
-        typedef VectorType Range;
+        using Range = VectorType;
 
         /**
          * Definition for the vector type for the range space of the operator.
          */
-        typedef VectorType Domain;
+        using Domain = VectorType;
 
         /**
          * @name Constructors / destructor
index 3d81c0d0113f37b48c5de49381f56d683e0a4ca2..a61b358c21d063afc6fd49928ba8b325e69fe665 100644 (file)
@@ -76,7 +76,7 @@ namespace TrilinosWrappers
       /**
        * Declare type for container size.
        */
-      typedef dealii::types::global_dof_index size_type;
+      using size_type = dealii::types::global_dof_index;
 
       /**
        * Constructor.
@@ -175,7 +175,7 @@ namespace TrilinosWrappers
       /**
        * Declare type for container size.
        */
-      typedef dealii::types::global_dof_index size_type;
+      using size_type = dealii::types::global_dof_index;
 
       /**
        * Constructor. Create an iterator into the matrix @p matrix for the
@@ -278,12 +278,12 @@ namespace TrilinosWrappers
     /**
      * Declare type for container size.
      */
-    typedef dealii::types::global_dof_index size_type;
+    using size_type = dealii::types::global_dof_index;
 
     /**
-     * Declare a typedef for the iterator class.
+     * Declare an alias for the iterator class.
      */
-    typedef SparsityPatternIterators::Iterator const_iterator;
+    using const_iterator = SparsityPatternIterators::Iterator;
 
     /**
      * @name Basic constructors and initialization.
index 481a3f49a4ef8f92567211ad8e865353385bdda3..865159f3e0ac93bce5e96cc388e9470a2baaa168 100644 (file)
@@ -77,7 +77,7 @@ namespace TrilinosWrappers
     /**
      * Declare type for container size.
      */
-    typedef dealii::types::global_dof_index size_type;
+    using size_type = dealii::types::global_dof_index;
 
     /**
      * This class implements a wrapper for accessing the Trilinos vector in
@@ -398,13 +398,13 @@ namespace TrilinosWrappers
        * parallel those in the <tt>C</tt> standard libraries
        * <tt>vector<...></tt> class.
        */
-      typedef TrilinosScalar                  value_type;
-      typedef TrilinosScalar                  real_type;
-      typedef dealii::types::global_dof_index size_type;
-      typedef value_type *                    iterator;
-      typedef const value_type *              const_iterator;
-      typedef internal::VectorReference       reference;
-      typedef const internal::VectorReference const_reference;
+      using value_type      = TrilinosScalar;
+      using real_type       = TrilinosScalar;
+      using size_type       = dealii::types::global_dof_index;
+      using iterator        = value_type *;
+      using const_iterator  = const value_type *;
+      using reference       = internal::VectorReference;
+      using const_reference = const internal::VectorReference;
 
       /**
        * @name 1: Basic Object-handling
index 8752c9142ace0b13b2b250e930321c84426e9e2d..13c67eeaaa8944585fafa45b94d9bd65bc447ea6 100644 (file)
@@ -112,14 +112,14 @@ public:
    * Declare standard types used in all containers. These types parallel those
    * in the <tt>C++</tt> standard libraries <tt>vector<...></tt> class.
    */
-  typedef Number                  value_type;
-  typedef value_type *            pointer;
-  typedef const value_type *      const_pointer;
-  typedef value_type *            iterator;
-  typedef const value_type *      const_iterator;
-  typedef value_type &            reference;
-  typedef const value_type &      const_reference;
-  typedef types::global_dof_index size_type;
+  using value_type      = Number;
+  using pointer         = value_type *;
+  using const_pointer   = const value_type *;
+  using iterator        = value_type *;
+  using const_iterator  = const value_type *;
+  using reference       = value_type &;
+  using const_reference = const value_type &;
+  using size_type       = types::global_dof_index;
 
   /**
    * Declare a type that has holds real-valued numbers with the same precision
@@ -128,9 +128,9 @@ public:
    * If the template argument is a std::complex type then real_type equals the
    * type underlying the complex numbers.
    *
-   * This typedef is used to represent the return type of norms.
+   * This alias is used to represent the return type of norms.
    */
-  typedef typename numbers::NumberTraits<Number>::real_type real_type;
+  using real_type = typename numbers::NumberTraits<Number>::real_type;
 
 public:
   /**
index 4a215f0da17c9130c0966fa10b54547901004742..669e15e80fa6641d37cf8899725986c30964e31f 100644 (file)
@@ -323,7 +323,7 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * Constructor.  The argument allows to preallocate a certain number of
@@ -400,7 +400,7 @@ private:
    * is be a flag telling whether the vector is used, the second
    * a pointer to the vector itself.
    */
-  typedef std::pair<bool, std::unique_ptr<VectorType>> entry_type;
+  using entry_type = std::pair<bool, std::unique_ptr<VectorType>>;
 
   /**
    * The class providing the actual storage for the memory pool.
index d8bf91cc9112e7266874eb46e7e082e75e14688d..9fd318574f84d465f2d60a821b3f1f2b2d6aa7ba 100644 (file)
@@ -31,7 +31,7 @@ namespace internal
 {
   namespace VectorOperations
   {
-    typedef types::global_dof_index size_type;
+    using size_type = types::global_dof_index;
 
     template <typename T>
     bool
index 1611220474249c4f06fa1d508c056e1f1c9bf353..aaf985b09fb6fbae63ba6320aa1f90bf4b31f4e0 100644 (file)
@@ -54,9 +54,9 @@ namespace LinearAlgebra
   class VectorSpaceVector
   {
   public:
-    typedef Number                                            value_type;
-    typedef types::global_dof_index                           size_type;
-    typedef typename numbers::NumberTraits<Number>::real_type real_type;
+    using value_type = Number;
+    using size_type  = types::global_dof_index;
+    using real_type  = typename numbers::NumberTraits<Number>::real_type;
 
     /**
      * Change the dimension to that of the vector V. The elements of V are not
index 684c8d6fe48dc09595083c0300a5bc8c65138230..79e272891b962c20e1e2dde9e6d87eafc37ea295 100644 (file)
@@ -138,7 +138,7 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef types::global_dof_index size_type;
+  using size_type = types::global_dof_index;
 
   /**
    * Read write constructor. Takes the size of the vector, just like the
index 1eec59510e0687bf978b2f28008dbaac9d8366b7..4fd2ab7dad878e3ae04a7d7829bc874461a55271 100644 (file)
@@ -79,12 +79,12 @@ namespace CUDAWrappers
   class FEEvaluation
   {
   public:
-    typedef Number                                 value_type;
-    typedef Tensor<1, dim, Number>                 gradient_type;
-    typedef typename MatrixFree<dim, Number>::Data data_type;
-    static constexpr unsigned int                  dimension    = dim;
-    static constexpr unsigned int                  n_components = n_components_;
-    static constexpr unsigned int                  n_q_points =
+    using value_type    = Number;
+    using gradient_type = Tensor<1, dim, Number>;
+    using data_type     = typename MatrixFree<dim, Number>::Data;
+    static constexpr unsigned int dimension    = dim;
+    static constexpr unsigned int n_components = n_components_;
+    static constexpr unsigned int n_q_points =
       Utilities::pow(n_q_points_1d, dim);
     static constexpr unsigned int tensor_dofs_per_cell =
       Utilities::pow(fe_degree + 1, dim);
index 22b339e3f090163f3ac5735c481a1d494d2cde49..c790337846fb995d34139ad7d1b4ea13eb7ce159 100644 (file)
@@ -77,9 +77,9 @@ namespace CUDAWrappers
   class MatrixFree : public Subscriptor
   {
   public:
-    typedef Tensor<2, dim, Tensor<1, dim, Number>> jacobian_type;
+    using jacobian_type = Tensor<2, dim, Tensor<1, dim, Number>>;
     // TODO this should really be a CUDAWrappers::Point
-    typedef Tensor<1, dim, Number> point_type;
+    using point_type = Tensor<1, dim, Number>;
 
     // Use Number2 so we don't hide the template parameter Number
     template <typename Number2>
index a35b69434d5c81b1302c3a03bc337c996561e29c..c6979dba52390768c16303aa081734c8c7d6cfc7 100644 (file)
@@ -549,14 +549,13 @@ namespace CUDAWrappers
       this, mapping, fe, quad, shape_info, update_flags);
 
     // Create a graph coloring
-    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());
-    typedef std::function<std::vector<types::global_dof_index>(
-      CellFilter const &)>
-               fun_type;
+    using fun_type =
+      std::function<std::vector<types::global_dof_index>(CellFilter const &)>;
     const auto fun = [&](const CellFilter &filter) {
       return internal::get_conflict_indices<dim, Number>(filter, constraints);
     };
index af495f46ea68672c2c42591e4382fdc28a34595f..d093c47b7c9b6eb28edccbd548a493ad749bdb3b 100644 (file)
@@ -157,12 +157,11 @@ namespace internal
 
     const EvaluatorVariant variant =
       EvaluatorSelector<type, (fe_degree + n_q_points_1d > 4)>::variant;
-    typedef EvaluatorTensorProduct<variant,
-                                   dim,
-                                   fe_degree + 1,
-                                   n_q_points_1d,
-                                   Number>
-         Eval;
+    using Eval = EvaluatorTensorProduct<variant,
+                                        dim,
+                                        fe_degree + 1,
+                                        n_q_points_1d,
+                                        Number>;
     Eval eval(variant == evaluate_evenodd ? shape_info.shape_values_eo :
                                             shape_info.shape_values,
               variant == evaluate_evenodd ? shape_info.shape_gradients_eo :
@@ -429,12 +428,11 @@ namespace internal
   {
     const EvaluatorVariant variant =
       EvaluatorSelector<type, (fe_degree + n_q_points_1d > 4)>::variant;
-    typedef EvaluatorTensorProduct<variant,
-                                   dim,
-                                   fe_degree + 1,
-                                   n_q_points_1d,
-                                   Number>
-         Eval;
+    using Eval = EvaluatorTensorProduct<variant,
+                                        dim,
+                                        fe_degree + 1,
+                                        n_q_points_1d,
+                                        Number>;
     Eval eval(variant == evaluate_evenodd ? shape_info.shape_values_eo :
                                             shape_info.shape_values,
               variant == evaluate_evenodd ? shape_info.shape_gradients_eo :
@@ -1365,14 +1363,14 @@ namespace internal
              data.shape_gradients :
              data.gradients_within_subface[subface_index / 2]);
 
-      typedef internal::EvaluatorTensorProduct<symmetric_evaluate ?
-                                                 internal::evaluate_evenodd :
-                                                 internal::evaluate_general,
-                                               dim - 1,
-                                               fe_degree + 1,
-                                               n_q_points_1d,
-                                               Number>
-           Eval;
+      using Eval =
+        internal::EvaluatorTensorProduct<symmetric_evaluate ?
+                                           internal::evaluate_evenodd :
+                                           internal::evaluate_general,
+                                         dim - 1,
+                                         fe_degree + 1,
+                                         n_q_points_1d,
+                                         Number>;
       Eval eval1(val1,
                  grad1,
                  AlignedVector<Number>(),
@@ -1526,14 +1524,14 @@ namespace internal
              data.shape_gradients :
              data.gradients_within_subface[subface_index / 2]);
 
-      typedef internal::EvaluatorTensorProduct<symmetric_evaluate ?
-                                                 internal::evaluate_evenodd :
-                                                 internal::evaluate_general,
-                                               dim - 1,
-                                               fe_degree + 1,
-                                               n_q_points_1d,
-                                               Number>
-           Eval;
+      using Eval =
+        internal::EvaluatorTensorProduct<symmetric_evaluate ?
+                                           internal::evaluate_evenodd :
+                                           internal::evaluate_general,
+                                         dim - 1,
+                                         fe_degree + 1,
+                                         n_q_points_1d,
+                                         Number>;
       Eval eval1(val1, grad1, val1, data.fe_degree + 1, data.n_q_points_1d);
       Eval eval2(val2, grad2, val1, data.fe_degree + 1, data.n_q_points_1d);
 
index e677010dd6c304217d2e5a42a41d92b6cd6dfb95..1459d498d88f2766f36af2b54b79cf093b81e8f0 100644 (file)
@@ -91,10 +91,10 @@ template <int dim, int n_components_, typename Number, bool is_face = false>
 class FEEvaluationBase
 {
 public:
-  typedef Number                                            number_type;
-  typedef Tensor<1, n_components_, VectorizedArray<Number>> value_type;
-  typedef Tensor<1, n_components_, Tensor<1, dim, VectorizedArray<Number>>>
-                                gradient_type;
+  using number_type = Number;
+  using value_type  = Tensor<1, n_components_, VectorizedArray<Number>>;
+  using gradient_type =
+    Tensor<1, n_components_, Tensor<1, dim, VectorizedArray<Number>>>;
   static constexpr unsigned int dimension    = dim;
   static constexpr unsigned int n_components = n_components_;
 
@@ -1109,13 +1109,13 @@ class FEEvaluationAccess
   : public FEEvaluationBase<dim, n_components_, Number, is_face>
 {
 public:
-  typedef Number                                            number_type;
-  typedef Tensor<1, n_components_, VectorizedArray<Number>> value_type;
-  typedef Tensor<1, n_components_, Tensor<1, dim, VectorizedArray<Number>>>
-                                gradient_type;
+  using number_type = Number;
+  using value_type  = Tensor<1, n_components_, VectorizedArray<Number>>;
+  using gradient_type =
+    Tensor<1, n_components_, Tensor<1, dim, VectorizedArray<Number>>>;
   static constexpr unsigned int dimension    = dim;
   static constexpr unsigned int n_components = n_components_;
-  typedef FEEvaluationBase<dim, n_components_, Number, is_face> BaseClass;
+  using BaseClass = FEEvaluationBase<dim, n_components_, Number, is_face>;
 
 protected:
   /**
@@ -1175,11 +1175,11 @@ class FEEvaluationAccess<dim, 1, Number, is_face>
   : public FEEvaluationBase<dim, 1, Number, is_face>
 {
 public:
-  typedef Number                                    number_type;
-  typedef VectorizedArray<Number>                   value_type;
-  typedef Tensor<1, dim, VectorizedArray<Number>>   gradient_type;
-  static constexpr unsigned int                     dimension = dim;
-  typedef FEEvaluationBase<dim, 1, Number, is_face> BaseClass;
+  using number_type   = Number;
+  using value_type    = VectorizedArray<Number>;
+  using gradient_type = Tensor<1, dim, VectorizedArray<Number>>;
+  static constexpr unsigned int dimension = dim;
+  using BaseClass = FEEvaluationBase<dim, 1, Number, is_face>;
 
   /** @copydoc FEEvaluationBase<dim,1,Number,is_face>::get_dof_value()
    */
@@ -1307,12 +1307,12 @@ class FEEvaluationAccess<dim, dim, Number, is_face>
   : public FEEvaluationBase<dim, dim, Number, is_face>
 {
 public:
-  typedef Number                                      number_type;
-  typedef Tensor<1, dim, VectorizedArray<Number>>     value_type;
-  typedef Tensor<2, dim, VectorizedArray<Number>>     gradient_type;
-  static constexpr unsigned int                       dimension    = dim;
-  static constexpr unsigned int                       n_components = dim;
-  typedef FEEvaluationBase<dim, dim, Number, is_face> BaseClass;
+  using number_type   = Number;
+  using value_type    = Tensor<1, dim, VectorizedArray<Number>>;
+  using gradient_type = Tensor<2, dim, VectorizedArray<Number>>;
+  static constexpr unsigned int dimension    = dim;
+  static constexpr unsigned int n_components = dim;
+  using BaseClass = FEEvaluationBase<dim, dim, Number, is_face>;
 
   /** @copydoc FEEvaluationBase<dim,dim,Number,is_face>::get_gradient()
    */
@@ -1462,11 +1462,11 @@ class FEEvaluationAccess<1, 1, Number, is_face>
   : public FEEvaluationBase<1, 1, Number, is_face>
 {
 public:
-  typedef Number                                  number_type;
-  typedef VectorizedArray<Number>                 value_type;
-  typedef Tensor<1, 1, VectorizedArray<Number>>   gradient_type;
-  static constexpr unsigned int                   dimension = 1;
-  typedef FEEvaluationBase<1, 1, Number, is_face> BaseClass;
+  using number_type   = Number;
+  using value_type    = VectorizedArray<Number>;
+  using gradient_type = Tensor<1, 1, VectorizedArray<Number>>;
+  static constexpr unsigned int dimension = 1;
+  using BaseClass = FEEvaluationBase<1, 1, Number, is_face>;
 
   /** @copydoc FEEvaluationBase<1,1,Number,is_face>::get_dof_value()
    */
@@ -2147,28 +2147,28 @@ class FEEvaluation
 {
 public:
   /**
-   * A typedef to the base class.
+   * An alias to the base class.
    */
-  typedef FEEvaluationAccess<dim, n_components_, Number, false> BaseClass;
+  using BaseClass = FEEvaluationAccess<dim, n_components_, Number, false>;
 
   /**
    * An underlying number type specified as template argument.
    */
-  typedef Number number_type;
+  using number_type = Number;
 
   /**
    * The type of function values, e.g. `VectorizedArray<Number>` for
    * `n_components=1` or `Tensor<1,dim,VectorizedArray<Number> >` for
    * `n_components=dim`.
    */
-  typedef typename BaseClass::value_type value_type;
+  using value_type = typename BaseClass::value_type;
 
   /**
    * The type of gradients, e.g. `Tensor<1,dim,VectorizedArray<Number>>` for
    * `n_components=1` or `Tensor<2,dim,VectorizedArray<Number> >` for
    * `n_components=dim`.
    */
-  typedef typename BaseClass::gradient_type gradient_type;
+  using gradient_type = typename BaseClass::gradient_type;
 
   /**
    * The dimension given as template argument.
@@ -2550,28 +2550,28 @@ class FEFaceEvaluation
 {
 public:
   /**
-   * A typedef to the base class.
+   * An alias to the base class.
    */
-  typedef FEEvaluationAccess<dim, n_components_, Number, true> BaseClass;
+  using BaseClass = FEEvaluationAccess<dim, n_components_, Number, true>;
 
   /**
    * A underlying number type specified as template argument.
    */
-  typedef Number number_type;
+  using number_type = Number;
 
   /**
    * The type of function values, e.g. `VectorizedArray<Number>` for
    * `n_components=1` or `Tensor<1,dim,VectorizedArray<Number> >` for
    * `n_components=dim`.
    */
-  typedef typename BaseClass::value_type value_type;
+  using value_type = typename BaseClass::value_type;
 
   /**
    * The type of gradients, e.g. `Tensor<1,dim,VectorizedArray<Number>>` for
    * `n_components=1` or `Tensor<2,dim,VectorizedArray<Number> >` for
    * `n_components=dim`.
    */
-  typedef typename BaseClass::gradient_type gradient_type;
+  using gradient_type = typename BaseClass::gradient_type;
 
   /**
    * The dimension given as template argument.
@@ -3760,7 +3760,7 @@ namespace internal
   template <typename VectorType>
   struct BlockVectorSelector<VectorType, true>
   {
-    typedef typename VectorType::BlockType BaseVectorType;
+    using BaseVectorType = typename VectorType::BlockType;
 
     static BaseVectorType *
     get_vector_component(VectorType &vec, const unsigned int component)
@@ -3773,7 +3773,7 @@ namespace internal
   template <typename VectorType>
   struct BlockVectorSelector<VectorType, false>
   {
-    typedef VectorType BaseVectorType;
+    using BaseVectorType = VectorType;
 
     static BaseVectorType *
     get_vector_component(VectorType &vec, const unsigned int component)
@@ -3798,7 +3798,7 @@ namespace internal
   template <typename VectorType>
   struct BlockVectorSelector<std::vector<VectorType>, false>
   {
-    typedef VectorType BaseVectorType;
+    using BaseVectorType = VectorType;
 
     static BaseVectorType *
     get_vector_component(std::vector<VectorType> &vec,
@@ -3812,7 +3812,7 @@ namespace internal
   template <typename VectorType>
   struct BlockVectorSelector<std::vector<VectorType *>, false>
   {
-    typedef VectorType BaseVectorType;
+    using BaseVectorType = VectorType;
 
     static BaseVectorType *
     get_vector_component(std::vector<VectorType *> &vec,
index 47ae5585b977b981f0438cddbc80ca7b39941591..b460a34f485038b1507bbe5db2e46e6a9fdcee4a 100644 (file)
@@ -1534,10 +1534,8 @@ namespace internal
                         face_data.quadrature_points[q]);
                 }
 
-              typedef Tensor<1,
-                             VectorizedArray<Number>::n_array_elements,
-                             Number>
-                           VEC_ARRAY;
+              using VEC_ARRAY =
+                Tensor<1, VectorizedArray<Number>::n_array_elements, Number>;
               unsigned int insert_position = data.first[my_q].JxW_values.size();
 
               // Fill in JxW values, apply compression
index 33aa2c3bd5a30c94b3297f8ab27cc7e7c8f8d793..5b00e2f701807723f37473799e3fa31205d637c2 100644 (file)
@@ -113,10 +113,10 @@ class MatrixFree : public Subscriptor
 {
 public:
   /**
-   * A typedef for the underlying number type specified by the template
+   * An alias for the underlying number type specified by the template
    * argument.
    */
-  typedef Number value_type;
+  using value_type = Number;
 
   /**
    * The dimension set by the template argument `dim`.
@@ -2311,8 +2311,8 @@ template <int dim, typename Number>
 AlignedVector<VectorizedArray<Number>> *
 MatrixFree<dim, Number>::acquire_scratch_data() const
 {
-  typedef std::list<std::pair<bool, AlignedVector<VectorizedArray<Number>>>>
-             list_type;
+  using list_type =
+    std::list<std::pair<bool, AlignedVector<VectorizedArray<Number>>>>;
   list_type &data = scratch_pad.get();
   for (typename list_type::iterator it = data.begin(); it != data.end(); ++it)
     if (it->first == false)
@@ -2332,8 +2332,8 @@ void
 MatrixFree<dim, Number>::release_scratch_data(
   const AlignedVector<VectorizedArray<Number>> *scratch) const
 {
-  typedef std::list<std::pair<bool, AlignedVector<VectorizedArray<Number>>>>
-             list_type;
+  using list_type =
+    std::list<std::pair<bool, AlignedVector<VectorizedArray<Number>>>>;
   list_type &data = scratch_pad.get();
   for (typename list_type::iterator it = data.begin(); it != data.end(); ++it)
     if (&it->second == scratch)
@@ -3600,14 +3600,14 @@ namespace internal
     struct InterfaceSelector
     {};
 
-    // Version of constant functions
+    // Version for constant functions
     template <typename MF,
               typename InVector,
               typename OutVector,
               typename Container>
     struct InterfaceSelector<MF, InVector, OutVector, Container, true>
     {
-      typedef void (Container::*function_type)(
+      using function_type = void (Container::*)(
         const MF &,
         OutVector &,
         const InVector &,
@@ -3621,11 +3621,11 @@ namespace internal
               typename Container>
     struct InterfaceSelector<MF, InVector, OutVector, Container, false>
     {
-      typedef void (Container::*function_type)(
-        const MF &,
-        OutVector &,
-        const InVector &,
-        const std::pair<unsigned int, unsigned int> &);
+      using function_type =
+        void (Container::*)(const MF &,
+                            OutVector &,
+                            const InVector &,
+                            const std::pair<unsigned int, unsigned int> &);
     };
   } // namespace MatrixFreeFunctions
 
@@ -3641,10 +3641,10 @@ namespace internal
   class MFWorker : public MFWorkerInterface
   {
   public:
-    // A typedef to make the arguments further down more readable
-    typedef typename MatrixFreeFunctions::
+    // An alias to make the arguments further down more readable
+    using function_type = typename MatrixFreeFunctions::
       InterfaceSelector<MF, InVector, OutVector, Container, is_constant>::
-        function_type function_type;
+        function_type;
 
     // constructor, binds all the arguments to this class
     MFWorker(const MF &                           matrix_free,
@@ -3777,11 +3777,11 @@ namespace internal
   template <class MF, typename InVector, typename OutVector>
   struct MFClassWrapper
   {
-    typedef std::function<void(const MF &,
-                               OutVector &,
-                               const InVector &,
-                               const std::pair<unsigned int, unsigned int> &)>
-      function_type;
+    using function_type =
+      std::function<void(const MF &,
+                         OutVector &,
+                         const InVector &,
+                         const std::pair<unsigned int, unsigned int> &)>;
 
     MFClassWrapper(const function_type cell,
                    const function_type face,
@@ -3844,8 +3844,8 @@ MatrixFree<dim, Number>::cell_loop(
   const InVector &src,
   const bool      zero_dst_vector) const
 {
-  typedef internal::MFClassWrapper<MatrixFree<dim, Number>, InVector, OutVector>
-          Wrapper;
+  using Wrapper =
+    internal::MFClassWrapper<MatrixFree<dim, Number>, InVector, OutVector>;
   Wrapper wrap(cell_operation, nullptr, nullptr);
   internal::
     MFWorker<MatrixFree<dim, Number>, InVector, OutVector, Wrapper, true>
@@ -3888,8 +3888,8 @@ MatrixFree<dim, Number>::loop(
   const DataAccessOnFaces dst_vector_face_access,
   const DataAccessOnFaces src_vector_face_access) const
 {
-  typedef internal::MFClassWrapper<MatrixFree<dim, Number>, InVector, OutVector>
-          Wrapper;
+  using Wrapper =
+    internal::MFClassWrapper<MatrixFree<dim, Number>, InVector, OutVector>;
   Wrapper wrap(cell_operation, face_operation, boundary_operation);
   internal::
     MFWorker<MatrixFree<dim, Number>, InVector, OutVector, Wrapper, true>
index 897506eda7ee4996e1d6b7745f7aac2ffd2e3bdb..29f4b75b230399da29da7cce966365644ad5be97 100644 (file)
@@ -188,14 +188,14 @@ namespace MatrixFreeOperators
   {
   public:
     /**
-     * Number typedef.
+     * Number alias.
      */
-    typedef typename VectorType::value_type value_type;
+    using value_type = typename VectorType::value_type;
 
     /**
      * size_type needed for preconditioner classes.
      */
-    typedef typename VectorType::size_type size_type;
+    using size_type = typename VectorType::size_type;
 
     /**
      * Default constructor.
@@ -532,14 +532,14 @@ namespace MatrixFreeOperators
   {
   public:
     /**
-     * Number typedef.
+     * Number alias.
      */
-    typedef typename OperatorType::value_type value_type;
+    using value_type = typename OperatorType::value_type;
 
     /**
      * Size type.
      */
-    typedef typename OperatorType::size_type size_type;
+    using size_type = typename OperatorType::size_type;
 
     /**
      * Default constructor.
@@ -677,14 +677,14 @@ namespace MatrixFreeOperators
   {
   public:
     /**
-     * Number typedef.
+     * Number alias.
      */
-    typedef typename Base<dim, VectorType>::value_type value_type;
+    using value_type = typename Base<dim, VectorType>::value_type;
 
     /**
      * size_type needed for preconditioner classes.
      */
-    typedef typename Base<dim, VectorType>::size_type size_type;
+    using size_type = typename Base<dim, VectorType>::size_type;
 
     /**
      * Constructor.
@@ -741,14 +741,14 @@ namespace MatrixFreeOperators
   {
   public:
     /**
-     * Number typedef.
+     * Number alias.
      */
-    typedef typename Base<dim, VectorType>::value_type value_type;
+    using value_type = typename Base<dim, VectorType>::value_type;
 
     /**
      * size_type needed for preconditioner classes.
      */
-    typedef typename Base<dim, VectorType>::size_type size_type;
+    using size_type = typename Base<dim, VectorType>::size_type;
 
     /**
      * Constructor.
@@ -1233,8 +1233,8 @@ namespace MatrixFreeOperators
   void
   Base<dim, VectorType>::vmult(VectorType &dst, const VectorType &src) const
   {
-    typedef typename Base<dim, VectorType>::value_type Number;
-    dst = Number(0.);
+    using Number = typename Base<dim, VectorType>::value_type;
+    dst          = Number(0.);
     vmult_add(dst, src);
   }
 
@@ -1265,7 +1265,7 @@ namespace MatrixFreeOperators
     const VectorType &src,
     const bool        is_row) const
   {
-    typedef typename Base<dim, VectorType>::value_type Number;
+    using Number = typename Base<dim, VectorType>::value_type;
     for (unsigned int i = 0; i < BlockHelper::n_blocks(src); ++i)
       {
         const unsigned int mf_component =
@@ -1301,7 +1301,7 @@ namespace MatrixFreeOperators
   Base<dim, VectorType>::preprocess_constraints(VectorType &      dst,
                                                 const VectorType &src) const
   {
-    typedef typename Base<dim, VectorType>::value_type Number;
+    using Number = typename Base<dim, VectorType>::value_type;
     adjust_ghost_range_if_necessary(src, false);
     adjust_ghost_range_if_necessary(dst, true);
 
@@ -1381,7 +1381,7 @@ namespace MatrixFreeOperators
   Base<dim, VectorType>::vmult_interface_down(VectorType &      dst,
                                               const VectorType &src) const
   {
-    typedef typename Base<dim, VectorType>::value_type Number;
+    using Number = typename Base<dim, VectorType>::value_type;
     AssertDimension(dst.size(), src.size());
     adjust_ghost_range_if_necessary(src, false);
     adjust_ghost_range_if_necessary(dst, true);
@@ -1433,7 +1433,7 @@ namespace MatrixFreeOperators
   Base<dim, VectorType>::vmult_interface_up(VectorType &      dst,
                                             const VectorType &src) const
   {
-    typedef typename Base<dim, VectorType>::value_type Number;
+    using Number = typename Base<dim, VectorType>::value_type;
     AssertDimension(dst.size(), src.size());
     adjust_ghost_range_if_necessary(src, false);
     adjust_ghost_range_if_necessary(dst, true);
@@ -1471,8 +1471,8 @@ namespace MatrixFreeOperators
   void
   Base<dim, VectorType>::Tvmult(VectorType &dst, const VectorType &src) const
   {
-    typedef typename Base<dim, VectorType>::value_type Number;
-    dst = Number(0.);
+    using Number = typename Base<dim, VectorType>::value_type;
+    dst          = Number(0.);
     Tvmult_add(dst, src);
   }
 
@@ -1651,7 +1651,7 @@ namespace MatrixFreeOperators
   MassOperator<dim, fe_degree, n_q_points_1d, n_components, VectorType>::
     compute_diagonal()
   {
-    typedef typename Base<dim, VectorType>::value_type Number;
+    using Number = typename Base<dim, VectorType>::value_type;
     Assert((Base<dim, VectorType>::data.get() != nullptr), ExcNotInitialized());
 
     this->inverse_diagonal_entries.reset(new DiagonalMatrix<VectorType>());
@@ -1708,7 +1708,7 @@ namespace MatrixFreeOperators
       const VectorType &                                                 src,
       const std::pair<unsigned int, unsigned int> &cell_range) const
   {
-    typedef typename Base<dim, VectorType>::value_type                Number;
+    using Number = typename Base<dim, VectorType>::value_type;
     FEEvaluation<dim, fe_degree, n_q_points_1d, n_components, Number> phi(
       data, this->selected_rows[0]);
     for (unsigned int cell = cell_range.first; cell < cell_range.second; ++cell)
@@ -1800,7 +1800,7 @@ namespace MatrixFreeOperators
   LaplaceOperator<dim, fe_degree, n_q_points_1d, n_components, VectorType>::
     compute_diagonal()
   {
-    typedef typename Base<dim, VectorType>::value_type Number;
+    using Number = typename Base<dim, VectorType>::value_type;
     Assert((Base<dim, VectorType>::data.get() != nullptr), ExcNotInitialized());
 
     unsigned int dummy = 0;
@@ -1918,7 +1918,7 @@ namespace MatrixFreeOperators
       const VectorType &                                                 src,
       const std::pair<unsigned int, unsigned int> &cell_range) const
   {
-    typedef typename Base<dim, VectorType>::value_type                Number;
+    using Number = typename Base<dim, VectorType>::value_type;
     FEEvaluation<dim, fe_degree, n_q_points_1d, n_components, Number> phi(
       data, this->selected_rows[0]);
     for (unsigned int cell = cell_range.first; cell < cell_range.second; ++cell)
@@ -1944,7 +1944,7 @@ namespace MatrixFreeOperators
       const unsigned int &,
       const std::pair<unsigned int, unsigned int> &cell_range) const
   {
-    typedef typename Base<dim, VectorType>::value_type                Number;
+    using Number = typename Base<dim, VectorType>::value_type;
     FEEvaluation<dim, fe_degree, n_q_points_1d, n_components, Number> phi(
       data, this->selected_rows[0]);
     for (unsigned int cell = cell_range.first; cell < cell_range.second; ++cell)
index 6c4b23b4abb4493298f91069d51a82c1da6f4e8a..7bbc939cf6a02b29edc9cf4378cbb59c4edd04f7 100644 (file)
@@ -581,8 +581,7 @@ namespace internal
     /**
      * Typedef to deprecated name.
      */
-    DEAL_II_DEPRECATED
-    typedef TaskInfo SizeInfo;
+    using SizeInfo DEAL_II_DEPRECATED = TaskInfo;
 
   } // end of namespace MatrixFreeFunctions
 } // end of namespace internal
index 0522d7f21f469c55bb63e51c6b40011261911d6f..3d6d0697d63bdff10e4e69ca1f65395eea54bc9f 100644 (file)
@@ -327,11 +327,10 @@ namespace MeshWorker
     class MGMatrixLocalBlocksToGlobalBlocks
     {
     public:
-      typedef MGMatrixBlockVector<MatrixType> MatrixPtrVector;
-      typedef SmartPointer<
-        MatrixPtrVector,
-        MGMatrixLocalBlocksToGlobalBlocks<MatrixType, number>>
-        MatrixPtrVectorPtr;
+      using MatrixPtrVector = MGMatrixBlockVector<MatrixType>;
+      using MatrixPtrVectorPtr =
+        SmartPointer<MatrixPtrVector,
+                     MGMatrixLocalBlocksToGlobalBlocks<MatrixType, number>>;
 
       /**
        * Constructor, initializing the #threshold, which limits how small
index 2e9d083016f318c134c5d26825305433b912f69e..0b0f41bf6fe64dbe070a4284f787263b92f2af5f 100644 (file)
@@ -302,7 +302,7 @@ namespace MeshWorker
     /**
      * The type of the @p info object for cells.
      */
-    typedef IntegrationInfo<dim, spacedim> CellInfo;
+    using CellInfo = IntegrationInfo<dim, spacedim>;
 
     /**
      * Default constructor.
index 7f1b9db8603184767626d7052cfb400ffbdb6512..a0d130cbd86db75454ee4d5484450e349bcf6be5 100644 (file)
@@ -42,7 +42,7 @@ class DoFHandler;
 class MGConstrainedDoFs : public Subscriptor
 {
 public:
-  typedef std::vector<std::set<types::global_dof_index>>::size_type size_dof;
+  using size_dof = std::vector<std::set<types::global_dof_index>>::size_type;
   /**
    * Fill the internal data structures with hanging node constraints extracted
    * from the dof handler object. Works with natural boundary conditions only.
index d04eb083f4e705e1dec6dce53408e71501517aca..e5f1752785e3c0361df88f7dfe139b0d743c6642 100644 (file)
@@ -46,8 +46,8 @@ namespace internal
   template <typename VectorType>
   struct MatrixSelector
   {
-    typedef ::dealii::SparsityPattern                               Sparsity;
-    typedef ::dealii::SparseMatrix<typename VectorType::value_type> Matrix;
+    using Sparsity = ::dealii::SparsityPattern;
+    using Matrix   = ::dealii::SparseMatrix<typename VectorType::value_type>;
 
     static const bool requires_distributed_sparsity_pattern = false;
 
@@ -69,8 +69,8 @@ namespace internal
   template <typename Number>
   struct MatrixSelector<LinearAlgebra::distributed::Vector<Number>>
   {
-    typedef ::dealii::TrilinosWrappers::SparsityPattern Sparsity;
-    typedef ::dealii::TrilinosWrappers::SparseMatrix    Matrix;
+    using Sparsity = ::dealii::TrilinosWrappers::SparsityPattern;
+    using Matrix   = ::dealii::TrilinosWrappers::SparseMatrix;
 
     static const bool requires_distributed_sparsity_pattern = false;
 
@@ -102,8 +102,8 @@ namespace internal
   template <>
   struct MatrixSelector<dealii::TrilinosWrappers::MPI::Vector>
   {
-    typedef ::dealii::TrilinosWrappers::SparsityPattern Sparsity;
-    typedef ::dealii::TrilinosWrappers::SparseMatrix    Matrix;
+    using Sparsity = ::dealii::TrilinosWrappers::SparsityPattern;
+    using Matrix   = ::dealii::TrilinosWrappers::SparseMatrix;
 
     static const bool requires_distributed_sparsity_pattern = false;
 
@@ -135,8 +135,8 @@ namespace internal
   template <>
   struct MatrixSelector<dealii::LinearAlgebra::EpetraWrappers::Vector>
   {
-    typedef ::dealii::TrilinosWrappers::SparsityPattern Sparsity;
-    typedef ::dealii::TrilinosWrappers::SparseMatrix    Matrix;
+    using Sparsity = ::dealii::TrilinosWrappers::SparsityPattern;
+    using Matrix   = ::dealii::TrilinosWrappers::SparseMatrix;
 
     static const bool requires_distributed_sparsity_pattern = false;
 
@@ -170,8 +170,8 @@ namespace internal
   template <typename Number>
   struct MatrixSelector<LinearAlgebra::distributed::Vector<Number>>
   {
-    typedef ::dealii::SparsityPattern      Sparsity;
-    typedef ::dealii::SparseMatrix<Number> Matrix;
+    using Sparsity = ::dealii::SparsityPattern;
+    using Matrix   = ::dealii::SparseMatrix<Number>;
 
     static const bool requires_distributed_sparsity_pattern = false;
 
@@ -197,8 +197,8 @@ namespace internal
   template <>
   struct MatrixSelector<dealii::PETScWrappers::MPI::Vector>
   {
-    typedef ::dealii::DynamicSparsityPattern           Sparsity;
-    typedef ::dealii::PETScWrappers::MPI::SparseMatrix Matrix;
+    using Sparsity = ::dealii::DynamicSparsityPattern;
+    using Matrix   = ::dealii::PETScWrappers::MPI::SparseMatrix;
 
     static const bool requires_distributed_sparsity_pattern = true;
 
index 7c5a13bbc53e3c8ad823c1003ecc69f2c16321c5..da3c695f76dcc73eac68a127405f2478a3921aed 100644 (file)
@@ -273,9 +273,9 @@ MGLevelGlobalTransfer<VectorType>::copy_to_mg(
       AssertThrowMPI(ierr);
 #endif
 
-      typedef std::vector<std::pair<types::global_dof_index,
-                                    types::global_dof_index>>::const_iterator
-                  dof_pair_iterator;
+      using dof_pair_iterator =
+        std::vector<std::pair<types::global_dof_index,
+                              types::global_dof_index>>::const_iterator;
       VectorType &dst_level = dst[level];
 
       // first copy local unknowns
@@ -340,9 +340,9 @@ MGLevelGlobalTransfer<VectorType>::copy_from_mg(
       AssertThrowMPI(ierr);
 #endif
 
-      typedef std::vector<std::pair<types::global_dof_index,
-                                    types::global_dof_index>>::const_iterator
-                        dof_pair_iterator;
+      using dof_pair_iterator =
+        std::vector<std::pair<types::global_dof_index,
+                              types::global_dof_index>>::const_iterator;
       const VectorType &src_level = src[level];
 
       // First copy all indices local to this process
@@ -391,9 +391,9 @@ MGLevelGlobalTransfer<VectorType>::copy_from_mg_add(
   // basis functions
   for (unsigned int level = src.min_level(); level <= src.max_level(); ++level)
     {
-      typedef std::vector<std::pair<types::global_dof_index,
-                                    types::global_dof_index>>::const_iterator
-                        dof_pair_iterator;
+      using dof_pair_iterator =
+        std::vector<std::pair<types::global_dof_index,
+                              types::global_dof_index>>::const_iterator;
       const VectorType &src_level = src[level];
 
       // First add all indices local to this process
@@ -495,8 +495,8 @@ MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<Number>>::copy_to_mg(
     {
       --level;
 
-      typedef std::vector<std::pair<unsigned int, unsigned int>>::const_iterator
-                                                  dof_pair_iterator;
+      using dof_pair_iterator =
+        std::vector<std::pair<unsigned int, unsigned int>>::const_iterator;
       LinearAlgebra::distributed::Vector<Number> &dst_level = dst[level];
 
       // first copy local unknowns
@@ -560,8 +560,8 @@ MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<Number>>::copy_from_mg(
   dst = 0;
   for (unsigned int level = src.min_level(); level <= src.max_level(); ++level)
     {
-      typedef std::vector<std::pair<unsigned int, unsigned int>>::const_iterator
-        dof_pair_iterator;
+      using dof_pair_iterator =
+        std::vector<std::pair<unsigned int, unsigned int>>::const_iterator;
 
       // the ghosted vector should already have the correct local size (but
       // different parallel layout)
@@ -609,8 +609,8 @@ MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<Number>>::
   dst.zero_out_ghosts();
   for (unsigned int level = src.min_level(); level <= src.max_level(); ++level)
     {
-      typedef std::vector<std::pair<unsigned int, unsigned int>>::const_iterator
-        dof_pair_iterator;
+      using dof_pair_iterator =
+        std::vector<std::pair<unsigned int, unsigned int>>::const_iterator;
 
       // the ghosted vector should already have the correct local size (but
       // different parallel layout)
index 580d1dd9f01a322747aac94a5a7fbc5e92c25052..0fc8e32575110f9e6bd5bf94998deb945f3026d9 100644 (file)
@@ -37,7 +37,7 @@ DEAL_II_NAMESPACE_OPEN
 /* --------------------- MGTransferBlockSelect -------------- */
 
 // Simplify some things below
-typedef std::vector<std::pair<unsigned int, unsigned int>>::const_iterator IT;
+using IT = std::vector<std::pair<unsigned int, unsigned int>>::const_iterator;
 
 
 template <typename number>
index 5871a95e7ef153afb2bbd4583e0517bcae88bd2a..edff053b673dc786bdf58eaf60ea3edceed4d7a9 100644 (file)
@@ -175,8 +175,8 @@ MGTransferSelect<number>::do_copy_from_mg(
   for (; level_cell != endc; ++level_cell)
     {
       const unsigned int level = level_cell->level();
-      typedef std::vector<
-        std::pair<types::global_dof_index, unsigned int>>::const_iterator IT;
+      using IT                 = std::vector<
+        std::pair<types::global_dof_index, unsigned int>>::const_iterator;
       for (IT i = copy_to_and_from_indices[level].begin();
            i != copy_to_and_from_indices[level].end();
            ++i)
@@ -207,8 +207,8 @@ MGTransferSelect<number>::do_copy_from_mg_add(
   for (; level_cell != endc; ++level_cell)
     {
       const unsigned int level = level_cell->level();
-      typedef std::vector<
-        std::pair<types::global_dof_index, unsigned int>>::const_iterator IT;
+      using IT                 = std::vector<
+        std::pair<types::global_dof_index, unsigned int>>::const_iterator;
       for (IT i = copy_to_and_from_indices[level].begin();
            i != copy_to_and_from_indices[level].end();
            ++i)
index 39a5b537d8fd39d1abf6ede55ffc53057c2f4721..97e8e54390a15beb88a5561344d0d070399219b4 100644 (file)
@@ -150,8 +150,8 @@ public:
     f_cycle
   };
 
-  typedef VectorType       vector_type;
-  typedef const VectorType const_vector_type;
+  using vector_type       = VectorType;
+  using const_vector_type = const VectorType;
 
   /**
    * Constructor. The DoFHandler is used to check whether the provided
index 899473b8f4f1f5ed282bb3fb361aa748323ad827..3a797f4e6bcd72be83bd34f0b942576277500e2b 100644 (file)
@@ -166,15 +166,14 @@ public:
    * Typedef to the iterator type of the dof handler class under
    * consideration.
    */
-  typedef
+  using cell_iterator =
     typename DataOut_DoFData<DoFHandlerType,
                              DoFHandlerType::dimension,
-                             DoFHandlerType::space_dimension>::cell_iterator
-      cell_iterator;
-  typedef typename DataOut_DoFData<
+                             DoFHandlerType::space_dimension>::cell_iterator;
+  using active_cell_iterator = typename DataOut_DoFData<
     DoFHandlerType,
     DoFHandlerType::dimension,
-    DoFHandlerType::space_dimension>::active_cell_iterator active_cell_iterator;
+    DoFHandlerType::space_dimension>::active_cell_iterator;
 
   /**
    * Enumeration describing the part of the domain in which cells
index d715c1c6953656811a53b9d837c6c2b76dbc03d9..88e0bca5990c5b35847a97f063e2e1108aee5576 100644 (file)
@@ -588,12 +588,12 @@ public:
    * Typedef to the iterator type of the dof handler class under
    * consideration.
    */
-  typedef typename Triangulation<DoFHandlerType::dimension,
-                                 DoFHandlerType::space_dimension>::cell_iterator
-    cell_iterator;
-  typedef typename Triangulation<
+  using cell_iterator =
+    typename Triangulation<DoFHandlerType::dimension,
+                           DoFHandlerType::space_dimension>::cell_iterator;
+  using active_cell_iterator = typename Triangulation<
     DoFHandlerType::dimension,
-    DoFHandlerType::space_dimension>::active_cell_iterator active_cell_iterator;
+    DoFHandlerType::space_dimension>::active_cell_iterator;
 
 public:
   /**
@@ -914,7 +914,7 @@ protected:
   /**
    * Abbreviate the somewhat lengthy name for the Patch class.
    */
-  typedef dealii::DataOutBase::Patch<patch_dim, patch_space_dim> Patch;
+  using Patch = dealii::DataOutBase::Patch<patch_dim, patch_space_dim>;
 
   /**
    * Pointer to the triangulation object.
index 558ee23a3eb17f133927421e69e40d4fdb4a34ee..e93ef62ac7077b7beb628c1c975ec7581cae965b 100644 (file)
@@ -1292,9 +1292,9 @@ DataOut_DoFData<DoFHandlerType, patch_dim, patch_space_dim>::get_dataset_names()
 {
   std::vector<std::string> names;
   // collect the names of dof and cell data
-  typedef typename std::vector<std::shared_ptr<
+  using data_iterator = typename std::vector<std::shared_ptr<
     internal::DataOutImplementation::DataEntryBase<DoFHandlerType>>>::
-    const_iterator data_iterator;
+    const_iterator;
 
   for (data_iterator d = dof_data.begin(); d != dof_data.end(); ++d)
     for (unsigned int i = 0; i < (*d)->names.size(); ++i)
@@ -1339,9 +1339,9 @@ DataOut_DoFData<DoFHandlerType, patch_dim, patch_space_dim>::
     ranges;
 
   // collect the ranges of dof and cell data
-  typedef typename std::vector<std::shared_ptr<
+  using data_iterator = typename std::vector<std::shared_ptr<
     internal::DataOutImplementation::DataEntryBase<DoFHandlerType>>>::
-    const_iterator data_iterator;
+    const_iterator;
 
   unsigned int output_component = 0;
   for (data_iterator d = dof_data.begin(); d != dof_data.end(); ++d)
index 7e994bdbd4cb71e2a52dd8741260cf258da74b0b..b0f69fa63412fbdd6ce30df0c7e486b044c35f97 100644 (file)
@@ -85,7 +85,7 @@ namespace internal
  * face (think of discontinuous finite elements, where the value of the finite
  * element field depend on the direction from which you approach a face, thus
  * it is necessary to use a pair of cell and face, rather than only a face
- * iterator). Therefore, this class defines a @p typedef which creates a type
+ * iterator). Therefore, this class defines an @p alias which creates a type
  * @p FaceDescriptor that is an abbreviation for a pair of cell iterator and
  * face number. The functions @p first_face and @p next_face operate on
  * objects of this type.
@@ -132,11 +132,12 @@ public:
   static const unsigned int space_dimension = DoFHandlerType::space_dimension;
 
   /**
-   * Typedef to the iterator type of the dof handler class under
+   * Alias to the iterator type of the dof handler class under
    * consideration.
    */
-  typedef typename DataOut_DoFData<DoFHandlerType, dimension - 1, dimension>::
-    cell_iterator cell_iterator;
+  using cell_iterator = typename DataOut_DoFData<DoFHandlerType,
+                                                 dimension - 1,
+                                                 dimension>::cell_iterator;
 
   /**
    * Constructor determining whether a surface mesh (default) or the whole
@@ -193,7 +194,7 @@ public:
    * of a cell and the number of the face. This pair is here aliased to a name
    * that is better to type.
    */
-  typedef typename std::pair<cell_iterator, unsigned int> FaceDescriptor;
+  using FaceDescriptor = typename std::pair<cell_iterator, unsigned int>;
 
 
   /**
index e443976f1c389553dc7b6119ca9437a9f9167f3b..c60051b9e9a19743b110b9a32f5b9541c7e3385d 100644 (file)
@@ -140,8 +140,8 @@ public:
    * Typedef to the iterator type of the dof handler class under
    * consideration.
    */
-  typedef typename DataOut_DoFData<DoFHandlerType, dimension + 1>::cell_iterator
-    cell_iterator;
+  using cell_iterator =
+    typename DataOut_DoFData<DoFHandlerType, dimension + 1>::cell_iterator;
 
   /**
    * This is the central function of this class since it builds the list of
index 1612d98b0369cacc2c2c45fff3a048e02cc92001..93e5884b0ee8f2a451309a7f99f8f7b20232b752 100644 (file)
@@ -149,7 +149,7 @@ DEAL_II_NAMESPACE_OPEN
  * order derivatives than are presently implemented. Basically, only an
  * additional class along the lines of the derivative descriptor classes @p
  * Gradient and @p SecondDerivative has to be implemented, with the respective
- * typedefs and functions replaced by the appropriate analogues for the
+ * alias and functions replaced by the appropriate analogues for the
  * derivative that is to be approximated.
  *
  * @ingroup numerics
index 54eaba085ebbd4d3e42a10d4ab24bdbb4d5b7f73..dcc06916ce889d1dbafd017a18b58c0c55089e72 100644 (file)
@@ -440,9 +440,8 @@ namespace Functions
     /**
      * Typedef holding the local cell_hint.
      */
-    typedef Threads::ThreadLocalStorage<
-      typename DoFHandlerType::active_cell_iterator>
-      cell_hint_t;
+    using cell_hint_t = Threads::ThreadLocalStorage<
+      typename DoFHandlerType::active_cell_iterator>;
 
     /**
      * Pointer to the dof handler.
index acb2865efc182aa7b2117ca59e434ff385b5e871..6da62da896a29c7ed28c04eb137b373c66866c79 100644 (file)
@@ -131,7 +131,7 @@ namespace Functions
     std::vector<Tensor<1, dim, typename VectorType::value_type>> &gradients)
     const
   {
-    typedef typename VectorType::value_type number;
+    using number = typename VectorType::value_type;
     Assert(gradients.size() == this->n_components,
            ExcDimensionMismatch(gradients.size(), this->n_components));
     typename DoFHandlerType::active_cell_iterator cell = cell_hint.get();
index 16400fd9bf610f2802363c0c0fede3ba68d92b80..81a83da777110ebd8b1bb52529e350c7203254f1 100644 (file)
@@ -101,9 +101,9 @@ public:
   struct PointCloudAdaptor
   {
     /**
-     * A typedef used by nanoflann.
+     * An alias used by nanoflann.
      */
-    typedef double coord_t;
+    using coord_t = double;
 
 
     /**
@@ -157,14 +157,13 @@ public:
 
 
   /**
-   * A typedef for the actual KDTree object.
+   * An alias for the actual KDTree object.
    */
-  typedef typename nanoflann::KDTreeSingleIndexAdaptor<
+  using NanoFlannKDTree = typename nanoflann::KDTreeSingleIndexAdaptor<
     nanoflann::L2_Simple_Adaptor<double, PointCloudAdaptor>,
     PointCloudAdaptor,
     dim,
-    unsigned int>
-    NanoFlannKDTree;
+    unsigned int>;
 
 
   /**
index e11890cd7c7445e0383825dc9d529b963e385da7..43addb419bc3e16d208a88f148dfe515ee521c9b 100644 (file)
@@ -82,14 +82,14 @@ namespace MatrixCreator
       /**
        * Typedef for the iterator type.
        */
-      typedef
-        typename DoFHandlerType::active_cell_iterator active_cell_iterator;
+      using active_cell_iterator =
+        typename DoFHandlerType::active_cell_iterator;
 
       /**
        * Abbreviation for a pair of iterators.
        */
-      typedef std::pair<active_cell_iterator, active_cell_iterator>
-        iterator_pair;
+      using iterator_pair =
+        std::pair<active_cell_iterator, active_cell_iterator>;
 
       /**
        * Constructor. Initialize the two values by the given values.
index 477c9161ea7366e12d06a15f653f25ae5825b72e..e95a8ffd8d7242baa4c5e6598a550d8dc0130751 100644 (file)
@@ -1134,8 +1134,8 @@ namespace TimeStepBase_Tria_Flags
      * process. See the general description of this class for more
      * information.
      */
-    typedef std::vector<std::vector<std::pair<unsigned int, double>>>
-      CorrectionRelaxations;
+    using CorrectionRelaxations =
+      std::vector<std::vector<std::pair<unsigned int, double>>>;
 
     /**
      * Default values for the relaxations: no relaxations.
@@ -1310,10 +1310,10 @@ public:
    * Typedef the data types of the TimeStepBase_Tria_Flags() namespace into
    * local scope.
    */
-  typedef typename TimeStepBase_Tria_Flags::Flags<dim> Flags;
-  typedef typename TimeStepBase_Tria_Flags::RefinementFlags<dim>
-                                                                RefinementFlags;
-  typedef typename TimeStepBase_Tria_Flags::RefinementData<dim> RefinementData;
+  using Flags = typename TimeStepBase_Tria_Flags::Flags<dim>;
+  using RefinementFlags =
+    typename TimeStepBase_Tria_Flags::RefinementFlags<dim>;
+  using RefinementData = typename TimeStepBase_Tria_Flags::RefinementData<dim>;
 
 
   /**
index 9a3bee73dad23930f374729c846491667aeac108..d43169b8fdb4ad6cf794c3a512560c2e61e5aef5 100644 (file)
@@ -329,7 +329,7 @@ namespace VectorTools
       // to the JxW values.
       //
 
-      typedef typename VectorType::value_type number;
+      using number = typename VectorType::value_type;
 
       const hp::FECollection<dim, spacedim> &fe(
         dof_handler.get_fe_collection());
@@ -590,7 +590,7 @@ namespace VectorTools
               const InVector &                 data_1,
               OutVector &                      data_2)
   {
-    typedef typename OutVector::value_type number;
+    using number = typename OutVector::value_type;
     Vector<number> cell_data_1(dof_1.get_fe().dofs_per_cell);
     Vector<number> cell_data_2(dof_2.get_fe().dofs_per_cell);
 
@@ -634,8 +634,8 @@ namespace VectorTools
     for (unsigned int i = 0; i < dof_2.n_dofs(); ++i)
       {
         Assert(touch_count[i] != 0, ExcInternalError());
-        typedef typename OutVector::value_type value_type;
-        const value_type                       val =
+        using value_type = typename OutVector::value_type;
+        const value_type val =
           ::dealii::internal::ElementAccess<OutVector>::get(data_2, i);
 
         ::dealii::internal::ElementAccess<OutVector>::set(
@@ -1017,7 +1017,7 @@ namespace VectorTools
       const Q_or_QC<dim - 1> &q_boundary,
       const bool              project_to_boundary_first)
     {
-      typedef typename VectorType::value_type number;
+      using number = typename VectorType::value_type;
       Assert(dof.get_fe(0).n_components() == function.n_components,
              ExcDimensionMismatch(dof.get_fe(0).n_components(),
                                   function.n_components));
@@ -1150,13 +1150,12 @@ namespace VectorTools
                           constraints,
                           QGauss<1>(dof.get_fe().degree + 2),
                           additional_data);
-      typedef MatrixFreeOperators::MassOperator<
+      using MatrixType = MatrixFreeOperators::MassOperator<
         dim,
         fe_degree,
         fe_degree + 2,
         components,
-        LinearAlgebra::distributed::Vector<Number>>
-                 MatrixType;
+        LinearAlgebra::distributed::Vector<Number>>;
       MatrixType mass_matrix;
       mass_matrix.initialize(matrix_free);
       mass_matrix.compute_diagonal();
@@ -1473,7 +1472,7 @@ namespace VectorTools
         const unsigned int)> &                                  func,
       VectorType &                                              vec_result)
     {
-      typedef typename VectorType::value_type Number;
+      using Number = typename VectorType::value_type;
       Assert(dof.get_fe(0).n_components() == 1,
              ExcDimensionMismatch(dof.get_fe(0).n_components(), 1));
       Assert(vec_result.size() == dof.n_dofs(),
@@ -1495,18 +1494,17 @@ namespace VectorTools
                           constraints,
                           QGauss<1>(dof.get_fe().degree + 2),
                           additional_data);
-      typedef MatrixFreeOperators::MassOperator<
+      using MatrixType = MatrixFreeOperators::MassOperator<
         dim,
         fe_degree,
         fe_degree + 2,
         1,
-        LinearAlgebra::distributed::Vector<Number>>
-                 MatrixType;
+        LinearAlgebra::distributed::Vector<Number>>;
       MatrixType mass_matrix;
       mass_matrix.initialize(matrix_free);
       mass_matrix.compute_diagonal();
 
-      typedef LinearAlgebra::distributed::Vector<Number> LocalVectorType;
+      using LocalVectorType = LinearAlgebra::distributed::Vector<Number>;
       LocalVectorType vec, rhs, inhomogeneities;
       matrix_free->initialize_dof_vector(vec);
       matrix_free->initialize_dof_vector(rhs);
@@ -1596,7 +1594,7 @@ namespace VectorTools
       const DoFHandler<dim, spacedim> &dof =
         matrix_free->get_dof_handler(fe_component);
 
-      typedef typename VectorType::value_type Number;
+      using Number = typename VectorType::value_type;
       Assert(dof.get_fe(0).n_components() == 1,
              ExcDimensionMismatch(dof.get_fe(0).n_components(), 1));
       Assert(vec_result.size() == dof.n_dofs(),
@@ -1605,18 +1603,17 @@ namespace VectorTools
                dof.get_fe().degree == static_cast<unsigned int>(fe_degree),
              ExcDimensionMismatch(fe_degree, dof.get_fe().degree));
 
-      typedef MatrixFreeOperators::MassOperator<
+      using MatrixType = MatrixFreeOperators::MassOperator<
         dim,
         fe_degree,
         n_q_points_1d,
         1,
-        LinearAlgebra::distributed::Vector<Number>>
-                 MatrixType;
+        LinearAlgebra::distributed::Vector<Number>>;
       MatrixType mass_matrix;
       mass_matrix.initialize(matrix_free, {fe_component});
       mass_matrix.compute_diagonal();
 
-      typedef LinearAlgebra::distributed::Vector<Number> LocalVectorType;
+      using LocalVectorType = LinearAlgebra::distributed::Vector<Number>;
       LocalVectorType vec, rhs, inhomogeneities;
       matrix_free->initialize_dof_vector(vec, fe_component);
       matrix_free->initialize_dof_vector(rhs, fe_component);
@@ -1912,7 +1909,7 @@ namespace VectorTools
     VectorType &                                               rhs_vector,
     const AffineConstraints<typename VectorType::value_type> & constraints)
   {
-    typedef typename VectorType::value_type Number;
+    using Number = typename VectorType::value_type;
 
     const FiniteElement<dim, spacedim> &fe = dof_handler.get_fe();
     Assert(fe.n_components() == rhs_function.n_components,
@@ -2052,7 +2049,7 @@ namespace VectorTools
     VectorType &                                               rhs_vector,
     const AffineConstraints<typename VectorType::value_type> & constraints)
   {
-    typedef typename VectorType::value_type Number;
+    using Number = typename VectorType::value_type;
 
     const hp::FECollection<dim, spacedim> &fe = dof_handler.get_fe_collection();
     Assert(fe.n_components() == rhs_function.n_components,
@@ -6991,11 +6988,10 @@ namespace VectorTools
     // (i.e. constrain not just the *average normal direction* but *all normal
     // directions* we find). consequently, we also have to store which cell a
     // normal vector was computed on
-    typedef std::multimap<
+    using DoFToNormalsMap = std::multimap<
       internal::VectorDoFTuple<dim>,
       std::pair<Tensor<1, dim>,
-                typename DoFHandlerType<dim, spacedim>::active_cell_iterator>>
-      DoFToNormalsMap;
+                typename DoFHandlerType<dim, spacedim>::active_cell_iterator>>;
     std::map<internal::VectorDoFTuple<dim>, Vector<double>>
       dof_vector_to_b_values;
 
@@ -7177,10 +7173,9 @@ namespace VectorTools
         // contributed to the current set of vector dofs, add up the normal
         // vectors. the values of the map are pairs of normal vectors and
         // number of cells that have contributed
-        typedef std::map<
-          typename DoFHandlerType<dim, spacedim>::active_cell_iterator,
-          std::pair<Tensor<1, dim>, unsigned int>>
-          CellToNormalsMap;
+        using CellToNormalsMap =
+          std::map<typename DoFHandlerType<dim, spacedim>::active_cell_iterator,
+                   std::pair<Tensor<1, dim>, unsigned int>>;
 
         CellToNormalsMap cell_to_normals_map;
         for (typename DoFToNormalsMap::const_iterator q = same_dof_range[0];
@@ -7354,10 +7349,9 @@ namespace VectorTools
                 // std::list instead of a std::set (which would be more natural)
                 // because std::set requires that the stored elements are
                 // comparable with operator<
-                typedef std::map<
+                using CellContributions = std::map<
                   typename DoFHandlerType<dim, spacedim>::active_cell_iterator,
-                  std::list<Tensor<1, dim>>>
-                                  CellContributions;
+                  std::list<Tensor<1, dim>>>;
                 CellContributions cell_contributions;
 
                 for (typename DoFToNormalsMap::const_iterator q =
@@ -8172,7 +8166,7 @@ namespace VectorTools
       const Function<spacedim> *                          weight,
       const double                                        exponent_1)
     {
-      typedef typename InVector::value_type Number;
+      using Number = typename InVector::value_type;
       // we mark the "exponent" parameter to this function "const" since it is
       // strictly incoming, but we need to set it to something different later
       // on, if necessary, so have a read-write version of it:
@@ -8508,8 +8502,8 @@ namespace VectorTools
     Vector<typename VectorType::value_type> &                  difference,
     const Point<spacedim> &                                    point)
   {
-    typedef typename VectorType::value_type Number;
-    const FiniteElement<dim> &              fe = dof.get_fe();
+    using Number                 = typename VectorType::value_type;
+    const FiniteElement<dim> &fe = dof.get_fe();
 
     Assert(difference.size() == fe.n_components(),
            ExcDimensionMismatch(difference.size(), fe.n_components()));
@@ -8608,8 +8602,8 @@ namespace VectorTools
               const Point<spacedim> &                  point,
               Vector<typename VectorType::value_type> &value)
   {
-    typedef typename VectorType::value_type Number;
-    const FiniteElement<dim> &              fe = dof.get_fe();
+    using Number                 = typename VectorType::value_type;
+    const FiniteElement<dim> &fe = dof.get_fe();
 
     Assert(value.size() == fe.n_components(),
            ExcDimensionMismatch(value.size(), fe.n_components()));
@@ -8650,8 +8644,8 @@ namespace VectorTools
               const Point<spacedim> &                     point,
               Vector<typename VectorType::value_type> &   value)
   {
-    typedef typename VectorType::value_type Number;
-    const hp::FECollection<dim, spacedim> & fe = dof.get_fe_collection();
+    using Number                              = typename VectorType::value_type;
+    const hp::FECollection<dim, spacedim> &fe = dof.get_fe_collection();
 
     Assert(value.size() == fe.n_components(),
            ExcDimensionMismatch(value.size(), fe.n_components()));
@@ -8822,7 +8816,7 @@ namespace VectorTools
 
     // then use this to get the gradients of
     // the given fe_function at this point
-    typedef typename VectorType::value_type          Number;
+    using Number = typename VectorType::value_type;
     std::vector<std::vector<Tensor<1, dim, Number>>> u_gradient(
       1, std::vector<Tensor<1, dim, Number>>(fe.n_components()));
     fe_values.get_function_gradients(fe_function, u_gradient);
@@ -8840,8 +8834,8 @@ namespace VectorTools
     const Point<spacedim> &                     point,
     std::vector<Tensor<1, spacedim, typename VectorType::value_type>> &gradient)
   {
-    typedef typename VectorType::value_type Number;
-    const hp::FECollection<dim, spacedim> & fe = dof.get_fe_collection();
+    using Number                              = typename VectorType::value_type;
+    const hp::FECollection<dim, spacedim> &fe = dof.get_fe_collection();
 
     Assert(gradient.size() == fe.n_components(),
            ExcDimensionMismatch(gradient.size(), fe.n_components()));
@@ -9007,7 +9001,7 @@ namespace VectorTools
                      const VectorType &               v,
                      const unsigned int               component)
   {
-    typedef typename VectorType::value_type Number;
+    using Number = typename VectorType::value_type;
     Assert(v.size() == dof.n_dofs(),
            ExcDimensionMismatch(v.size(), dof.n_dofs()));
     Assert(component < dof.get_fe(0).n_components(),
index aa6ec7bcf155c8e14e9259f9ec1c2c6fe535500e..aadfb8e4c063018a30bed5e1500607424d4f4a98 100644 (file)
@@ -115,17 +115,17 @@ namespace Rol
   class VectorAdaptor : public ROL::Vector<typename VectorType::value_type>
   {
     /**
-     * A typedef for size type of <tt>VectorType</tt>.
+     * An alias for size type of <tt>VectorType</tt>.
      */
     using size_type = typename VectorType::size_type;
 
     /**
-     * A typedef for element type stored in the <tt>VectorType</tt>.
+     * An alias for element type stored in the <tt>VectorType</tt>.
      */
     using value_type = typename VectorType::value_type;
 
     /**
-     * A typedef for real-valued numbers.
+     * An alias for real-valued numbers.
      */
     using real_type = typename VectorType::real_type;
 
index aa9615bf38ad5e3b82b8fa2d3ce91068e8bd7996..5c0774b811ef2f9479490cb8b5f965fc7e5e7ce0 100644 (file)
@@ -40,7 +40,7 @@ namespace types
    *
    * The data type always indicates an unsigned integer type.
    */
-  typedef unsigned long long int particle_index;
+  using particle_index = unsigned long long int;
 
 #  ifdef DEAL_II_WITH_MPI
   /**
@@ -61,7 +61,7 @@ namespace types
    *
    * The data type always indicates an unsigned integer type.
    */
-  typedef unsigned int particle_index;
+  using particle_index = unsigned int;
 
 #  ifdef DEAL_II_WITH_MPI
   /**
@@ -82,9 +82,9 @@ namespace Particles
   namespace internal
   {
     /**
-     * Internal typedef of cell level/index pair.
+     * Internal alias of cell level/index pair.
      */
-    typedef std::pair<int, int> LevelInd;
+    using LevelInd = std::pair<int, int>;
   } // namespace internal
 
   /**
index 2f19ee32eb01a0cdb13513540956d297df8739e3..47df14e26d1198b3f821bb1b0c202d3140d35c7d 100644 (file)
@@ -57,12 +57,12 @@ namespace Particles
     /**
      * A type that can be used to iterate over all particles in the domain.
      */
-    typedef ParticleIterator<dim, spacedim> particle_iterator;
+    using particle_iterator = ParticleIterator<dim, spacedim>;
 
     /**
      * A type that represents a range of particles.
      */
-    typedef boost::iterator_range<particle_iterator> particle_iterator_range;
+    using particle_iterator_range = boost::iterator_range<particle_iterator>;
 
     /**
      * Default constructor.
index 587bd98107017da2a02fe39488e9a58b74d87254..5e687fb7a90bd5e42275bc69d3fc4c006eee67f2 100644 (file)
@@ -126,15 +126,15 @@ namespace Particles
     operator--(int);
 
     /**
-     * Mark the class as bidirectional iterator and declare some typedefs which
+     * Mark the class as bidirectional iterator and declare some alias which
      * are standard for iterators and are used by algorithms to enquire about
      * the specifics of the iterators they work on.
      */
-    typedef std::bidirectional_iterator_tag  iterator_category;
-    typedef ParticleAccessor<dim, spacedim>  value_type;
-    typedef std::ptrdiff_t                   difference_type;
-    typedef ParticleAccessor<dim, spacedim> *pointer;
-    typedef ParticleAccessor<dim, spacedim> &reference;
+    using iterator_category = std::bidirectional_iterator_tag;
+    using value_type        = ParticleAccessor<dim, spacedim>;
+    using difference_type   = std::ptrdiff_t;
+    using pointer           = ParticleAccessor<dim, spacedim> *;
+    using reference         = ParticleAccessor<dim, spacedim> &;
 
   private:
     /**
index deb409375eaef12b284fc3d331f2f2be1ce35c15..7e66e43b4478f0c4b62c21d4a00d098f43d9d3a3 100644 (file)
@@ -46,7 +46,7 @@ namespace Particles
      * uniquely identifies the slot of memory that is reserved for this
      * particle.
      */
-    typedef double *Handle;
+    using Handle = double *;
 
     /**
      * Define a default (invalid) value for handles.
index 181272b63a32122c4e469ccd7943d5e4b9d98368..983e3c567982dae06ba4bf6d0b76cd94321a017c 100644 (file)
@@ -279,7 +279,7 @@ namespace SUNDIALS
    * following code snippet:
    *
    * @code
-   * typedef Vector<double> VectorType;
+   * using VectorType = Vector<double>;
    *
    * SUNDIALS::ARKode<VectorType> ode;
    *
@@ -883,7 +883,7 @@ namespace SUNDIALS
     /**
      * MPI communicator. SUNDIALS solver runs happily in
      * parallel. Note that if the library is compiled without MPI
-     * support, MPI_Comm is typedefed as int.
+     * support, MPI_Comm is aliased as int.
      */
     MPI_Comm communicator;
 
index 2092286f35541420495ae5a2f9da199211995f6a..be8fcb2c61d0cdd867e5cc25a310e9401e896aff 100644 (file)
@@ -173,7 +173,7 @@ namespace SUNDIALS
    *
    * This is achieved by the following snippet of code:
    * @code
-   * typedef Vector<double> VectorType;
+   * using VectorType = Vector<double>;
    *
    * VectorType y(2);
    * VectorType y_dot(2);
@@ -827,7 +827,7 @@ namespace SUNDIALS
     /**
      * MPI communicator. SUNDIALS solver runs happily in
      * parallel. Note that if the library is compiled without MPI
-     * support, MPI_Comm is typedefed as int.
+     * support, MPI_Comm is aliased as int.
      */
     MPI_Comm communicator;
 

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.