]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Do not break hyphenated words in the documentation. 16395/head
authorWolfgang Bangerth <bangerth@colostate.edu>
Sun, 31 Dec 2023 23:01:39 +0000 (16:01 -0700)
committerWolfgang Bangerth <bangerth@colostate.edu>
Sun, 31 Dec 2023 23:03:32 +0000 (16:03 -0700)
73 files changed:
include/deal.II/base/array_view.h
include/deal.II/base/conditional_ostream.h
include/deal.II/base/data_out_base.h
include/deal.II/base/function.h
include/deal.II/base/function_lib.h
include/deal.II/base/geometry_info.h
include/deal.II/base/graph_coloring.h
include/deal.II/base/iterator_range.h
include/deal.II/base/logstream.h
include/deal.II/base/numbers.h
include/deal.II/base/parameter_handler.h
include/deal.II/base/polynomial.h
include/deal.II/base/polynomials_abf.h
include/deal.II/base/qprojector.h
include/deal.II/base/table.h
include/deal.II/base/table_handler.h
include/deal.II/base/tensor_product_polynomials.h
include/deal.II/base/thread_local_storage.h
include/deal.II/base/vectorization.h
include/deal.II/distributed/tria.h
include/deal.II/dofs/dof_accessor.h
include/deal.II/dofs/dof_handler.h
include/deal.II/dofs/dof_renumbering.h
include/deal.II/dofs/dof_tools.h
include/deal.II/fe/fe.h
include/deal.II/fe/fe_data.h
include/deal.II/fe/fe_dgp.h
include/deal.II/fe/fe_dgp_monomial.h
include/deal.II/fe/fe_system.h
include/deal.II/fe/fe_tools.h
include/deal.II/fe/fe_values_base.h
include/deal.II/fe/fe_values_extractors.h
include/deal.II/fe/mapping.h
include/deal.II/grid/grid_tools.h
include/deal.II/grid/persistent_tria.h
include/deal.II/grid/tria.h
include/deal.II/grid/tria_accessor.h
include/deal.II/lac/affine_constraints.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/la_parallel_vector.h
include/deal.II/lac/petsc_block_sparse_matrix.h
include/deal.II/lac/petsc_block_vector.h
include/deal.II/lac/relaxation_block.h
include/deal.II/lac/schur_complement.h
include/deal.II/lac/solver_gmres.h
include/deal.II/lac/sparse_decomposition.h
include/deal.II/lac/sparse_ilu.h
include/deal.II/lac/sparse_matrix.h
include/deal.II/lac/sparse_mic.h
include/deal.II/lac/sparse_vanka.h
include/deal.II/lac/sparsity_pattern.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/matrix_free/dof_info.h
include/deal.II/matrix_free/fe_evaluation_data.h
include/deal.II/matrix_free/shape_info.h
include/deal.II/matrix_free/task_info.h
include/deal.II/matrix_free/tensor_product_kernels.h
include/deal.II/meshworker/scratch_data.h
include/deal.II/multigrid/multigrid.h
include/deal.II/numerics/data_out.h
include/deal.II/numerics/data_out_rotation.h
include/deal.II/numerics/data_out_stack.h
include/deal.II/numerics/error_estimator.h
include/deal.II/numerics/error_estimator.templates.h
include/deal.II/numerics/matrix_tools.h
include/deal.II/numerics/vector_tools_boundary.h

index c773259e013da6e14257f77802fa530e2cd1f140..067ffd543fc1db231b20ac8eff7a5f107bff8e2e 100644 (file)
@@ -1268,8 +1268,8 @@ make_array_view(const std::vector<ElementType> &vector)
 
 /**
  * Create a view to a part of a std::vector object. This is equivalent to
- * initializing the ArrayView object with a pointer to the @p starting_index-
- * th element and the @p size_of_view as the length of the view.
+ * initializing the ArrayView object with a pointer to the
+ * @p starting_index-th element and the @p size_of_view as the length of the view.
  *
  * This function is used for non-@p const references to objects of vector
  * type. Such objects contain elements that can be written to. Consequently,
@@ -1302,8 +1302,8 @@ make_array_view(std::vector<ElementType> &vector,
 
 /**
  * Create a view to a part of a std::vector object. This is equivalent to
- * initializing the ArrayView object with a pointer to the @p starting_index-
- * th element and the @p size_of_view as the length of the view.
+ * initializing the ArrayView object with a pointer to the @p starting_index-th
+ * element and the @p size_of_view as the length of the view.
  *
  * This function is used for @p const references to objects of vector type
  * because they contain immutable elements. Consequently, the return type of
index d3827e17ea6e59f1167792689e035e1657b9b9ae..13944e5cb0cffef38296c1ebee1020af3818a0d4 100644 (file)
@@ -36,8 +36,8 @@ DEAL_II_NAMESPACE_OPEN
  * parallel programs, this means that each of the MPI processes write to the
  * screen, which yields many repetitions of the same text. To avoid it, one
  * would have to have a designated process, say the one with MPI process
- * number zero, do the output, and guard each write statement with an if-
- * condition. This becomes cumbersome and clutters up the code. Rather than
+ * number zero, do the output, and guard each write statement with an
+ * if-condition. This becomes cumbersome and clutters up the code. Rather than
  * doing so, the present class can be used: objects of its type act just like
  * a standard output stream, but they only print something based on a
  * condition that can be set to, for example, <tt>mpi_process==0</tt>, so that
@@ -67,8 +67,8 @@ DEAL_II_NAMESPACE_OPEN
  * @code
  * system_matrix.print_formatted(pout);
  * @endcode
- * is <em>not</em> possible. Instead use the is_active() function for a work-
- * around:
+ * is <em>not</em> possible. Instead use the is_active() function for a
+ * work-around:
  *
  * @code
  * if (pout.is_active())
index f678c78c4c3ac8c40bc329c3015ac730f0286869..e3a7fdf2ba6324069d14902cbecb3d9f7313be08 100644 (file)
@@ -928,9 +928,9 @@ namespace DataOutBase
     /**
      * Flag whether to fill the regions between the lines bounding the cells
      * or not. If not, no hidden line removal is performed, which in this
-     * crude implementation is done through writing the cells in a back-to-
-     * front order, thereby hiding the cells in the background by cells in the
-     * foreground.
+     * crude implementation is done through writing the cells in a
+     * back-to-front order, thereby hiding the cells in the background by
+     * cells in the foreground.
      *
      * If this flag is <tt>false</tt> and #draw_mesh is <tt>false</tt> as
      * well, nothing will be printed.
@@ -1099,8 +1099,8 @@ namespace DataOutBase
     const char *zone_name;
 
     /**
-     * Solution time for each zone in a strand. This value must be non-
-     * negative, otherwise it will not be written to file. Do not assign any
+     * Solution time for each zone in a strand. This value must be
+     * non-negative, otherwise it will not be written to file. Do not assign any
      * value for this in case of a static zone.
      */
     double solution_time;
@@ -1760,9 +1760,9 @@ namespace DataOutBase
     std::ostream   &out);
 
   /**
-   * This is the same function as above except for domains that are not two-
-   * dimensional. This function is not implemented (and will throw an error if
-   * called) but is declared to allow for dimension-independent programs.
+   * This is the same function as above except for domains that are not
+   * two-dimensional. This function is not implemented (and will throw an error
+   * if called) but is declared to allow for dimension-independent programs.
    */
   template <int dim, int spacedim>
   void
index 969ab07701f3ee4ade4a8246871c3e9224692e40..d5e9d1934d5fc9b48a0e12e259e61fe7ae2ca41c 100644 (file)
@@ -94,8 +94,8 @@ class TensorFunction;
  * or several points (i.e. vector_value(), vector_value_list()), will
  * <em>not</em> call the function returning one component at one point
  * repeatedly, once for each point and component. The reason is efficiency:
- * this would amount to too many virtual function calls. If you have vector-
- * valued functions, you should therefore also provide overloads of the
+ * this would amount to too many virtual function calls. If you have
+ * vector-valued functions, you should therefore also provide overloads of the
  * virtual functions for all components at a time.
  *
  * Also note, that unless only called a very small number of times, you should
@@ -186,8 +186,8 @@ public:
    * Virtual destructor; absolutely necessary in this case.
    *
    * This destructor is declared pure virtual, such that objects of this class
-   * cannot be created. Since all the other virtual functions have a pseudo-
-   * implementation to avoid overhead in derived classes, they can not be
+   * cannot be created. Since all the other virtual functions have a
+   * pseudo-implementation to avoid overhead in derived classes, they can not be
    * abstract. As a consequence, we could generate an object of this class
    * because none of this class's functions are abstract.
    *
index 43118d114506613f2e77e55abd33489596845a04..6eee6bd4f656287c5b196bac0317de5006c04038 100644 (file)
@@ -1371,8 +1371,8 @@ namespace Functions
   /**
    * A scalar function that computes its values by (bi-, tri-)linear
    * interpolation from a set of point data that are arranged on a possibly
-   * non-uniform tensor product mesh. In other words, considering the three-
-   * dimensional case, let there be points $x_0,\ldots, x_{K-1}$,
+   * non-uniform tensor product mesh. In other words, considering the
+   * three-dimensional case, let there be points $x_0,\ldots, x_{K-1}$,
    * $y_0,\ldots,y_{L-1}$, $z_1,\ldots,z_{M-1}$, and data $d_{klm}$ defined at
    * point $(x_k,y_l,z_m)^T$, then evaluating the function at a point $\mathbf
    * x=(x,y,z)$ will find the box so that $x_k\le x\le x_{k+1}, y_l\le y\le
@@ -1460,8 +1460,8 @@ namespace Functions
      * @param coordinate_values An array of dim arrays. Each of the inner
      * arrays contains the coordinate values $x_0,\ldots, x_{K-1}$ and
      * similarly for the other coordinate directions. These arrays need not
-     * have the same size. Obviously, we need dim such arrays for a dim-
-     * dimensional function object. The coordinate values within this array
+     * have the same size. Obviously, we need dim such arrays for a
+     * dim-dimensional function object. The coordinate values within this array
      * are assumed to be strictly ascending to allow for efficient lookup.
      *
      * @param data_values A dim-dimensional table of data at each of the mesh
@@ -1556,10 +1556,10 @@ namespace Functions
   /**
    * A scalar function that computes its values by (bi-, tri-)linear
    * interpolation from a set of point data that are arranged on a uniformly
-   * spaced tensor product mesh. In other words, considering the three-
-   * dimensional case, let there be points $x_0,\ldots, x_{K-1}$ that result
-   * from a uniform subdivision of the interval $[x_0,x_{K-1}]$ into $K-1$
-   * sub-intervals of size $\Delta x = (x_{K-1}-x_0)/(K-1)$, and similarly
+   * spaced tensor product mesh. In other words, considering the
+   * three-dimensional case, let there be points $x_0,\ldots, x_{K-1}$ that
+   * result from a uniform subdivision of the interval $[x_0,x_{K-1}]$ into
+   * $K-1$ sub-intervals of size $\Delta x = (x_{K-1}-x_0)/(K-1)$, and similarly
    * $y_0,\ldots,y_{L-1}$, $z_1,\ldots,z_{M-1}$. Also consider data $d_{klm}$
    * defined at point $(x_k,y_l,z_m)^T$, then evaluating the function at a
    * point $\mathbf x=(x,y,z)$ will find the box so that $x_k\le x\le x_{k+1},
index 715adfaa002fc79da87b71b5b6f64adac29eef11..d40be658fd96e86ca704492232544817ec88e2c9 100644 (file)
@@ -2546,8 +2546,8 @@ struct GeometryInfo
    * v_1\wedge \mathbf v_2 \wedge \mathbf v_3 = (\mathbf v_1\times \mathbf
    * v_2)\cdot \mathbf v_3$, where $\mathbf v_1, \mathbf v_2, \mathbf v_3$ are
    * the images of the unit vectors at a vertex of the unit dim-dimensional
-   * cell under transformation to the dim-dimensional cell in spacedim-
-   * dimensional space. In both cases, i.e. for dim==2 or 3, the result
+   * cell under transformation to the dim-dimensional cell in
+   * spacedim-dimensional space. In both cases, i.e. for dim==2 or 3, the result
    * happens to equal the determinant of the Jacobian of the mapping from
    * reference cell to cell in real space. Note that it is the actual
    * determinant, not its absolute value as often used in transforming
index 8d00562abdf0ee7d008adbdb5b0b2d8ef9ceb1f9..fb57f76f7c073d3058b4ed564a4a0f6999f65de9 100644 (file)
@@ -90,8 +90,8 @@ namespace GraphColoring
      * shells around the very first cell. Note that elements in each zone may
      * conflict with other elements in the same zone.
      *
-     * The question whether two iterators conflict is determined by a user-
-     * provided function. The meaning of this function is discussed in the
+     * The question whether two iterators conflict is determined by a
+     * user-provided function. The meaning of this function is discussed in the
      * documentation of the GraphColoring::make_graph_coloring() function.
      *
      * @param[in] begin The first element of a range of iterators for which a
index be3f80a46adc09ec2699c579eecaf9d73f6046f3..1a6ed54119aa4aa2d3c8f69128abe5e4d0a72e7a 100644 (file)
@@ -64,8 +64,8 @@ class IteratorOverIterators;
  * <h3>Class design: Motivation</h3>
  *
  * Informally, the way the C++11 standard describes <a
- * href="http://en.wikipedia.org/wiki/C%2B%2B11#Range-based_for_loop">range-
- * based for loops</a> works as follows: A <i>range-based for loop</i> of the
+ * href="http://en.wikipedia.org/wiki/C%2B%2B11#Range-based_for_loop">range-based
+ * for loops</a> works as follows: A <i>range-based for loop</i> of the
  * form
  * @code
  *   Container c;
@@ -99,8 +99,8 @@ class IteratorOverIterators;
  * a call such as Triangulation::active_cell_iterators() returns an object
  * that represents a <i>collection of iterators</i> of the kind <code>{begin,
  * begin+1, ..., end-1}</code>. This is conveniently expressed as the half
- * open interval <code>[begin,end)</code>. The loop variable in the range-
- * based for loop would then take on each of these iterators in turn.
+ * open interval <code>[begin,end)</code>. The loop variable in the
+ * range-based for loop would then take on each of these iterators in turn.
  *
  *
  * <h3>Class design: Implementation</h3>
index fcb0927da9519b8aff3e80fb05b0222d4a7a6b51..3b1a0ec8334543cbbff98b418a97edcc357dcf1a 100644 (file)
@@ -306,10 +306,10 @@ public:
 private:
   /**
    * Internal wrapper around thread-local prefixes. This private function will
-   * return the correct internal prefix stack. More important, a new thread-
-   * local stack will be copied from the current stack of the "blessed" thread
-   * that created this LogStream instance (usually, in the case of deallog,
-   * the "main" thread).
+   * return the correct internal prefix stack. More important, a new
+   * thread-local stack will be copied from the current stack of the "blessed"
+   * thread that created this LogStream instance (usually, in the case of
+   * deallog, the "main" thread).
    */
   std::stack<std::string> &
   get_prefixes() const;
index 15da882e88ea0bac37406ffcde8b29f3dd422495..e0dcfd618450c81a2d424f77d73fe4f4f860496f 100644 (file)
@@ -436,8 +436,8 @@ namespace numbers
     /**
      * 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.
+     * specializations of std::complex<T>, the underlying type must be
+     * real-values, so the real_type is equal to the underlying type.
      */
     using real_type = number;
 
index 9fff4947d282534a127071e41f88de52a4af47eb..156ef322c1d295a2ea4c9ae823421387a9a66b70 100644 (file)
@@ -1517,8 +1517,8 @@ public:
 
   /**
    * Print parameters to a logstream. This function allows to print all
-   * parameters into a log-file. Sections will be indented in the usual log-
-   * file style.
+   * parameters into a log-file. Sections will be indented in the usual
+   * log-file style.
    *
    * All current parameters and subsections are sorted
    * alphabetically by default.
index 7adedd9d4dc0748439e2dcf6146c1b80b7461613..5de164b910338451202df612fbd08381a1abdad2 100644 (file)
@@ -557,8 +557,8 @@ namespace Polynomials
     compute_coefficients(const unsigned int p);
 
     /**
-     * Get coefficients for constructor.  This way, it can use the non-
-     * standard constructor of Polynomial.
+     * Get coefficients for constructor.  This way, it can use the
+     * non-standard constructor of Polynomial.
      */
     static const std::vector<double> &
     get_coefficients(const unsigned int p);
index 757848bb4046bf353a66973de7c8ed349ac07fd2..9940db81c5cc7f3e8d8707ab521038ff1b60186d 100644 (file)
@@ -35,9 +35,9 @@ DEAL_II_NAMESPACE_OPEN
 
 /**
  * This class implements the <i>H<sup>div</sup></i>-conforming, vector-valued
- * Arnold-Boffi-Falk polynomials as described in the article by Arnold-Boffi-
- * Falk: Quadrilateral H(div) finite elements, SIAM J. Numer. Anal. Vol.42,
- * No.6, pp.2429-2451
+ * Arnold-Boffi-Falk polynomials as described in the article by Arnold, Boffi,
+ * and Falk: Quadrilateral H(div) finite elements, SIAM J. Numer. Anal., Vol.
+ * 42, No. 6, pp.2429-2451
  *
  *
  * The ABF polynomials are constructed such that the divergence is in the
@@ -64,8 +64,8 @@ public:
   PolynomialsABF(const unsigned int k);
 
   /**
-   * Compute the value and the first and second derivatives of each Raviart-
-   * Thomas polynomial at @p unit_point.
+   * Compute the value and the first and second derivatives of each
+   * Raviart-Thomas polynomial at @p unit_point.
    *
    * The size of the vectors must either be zero or equal <tt>n()</tt>.  In
    * the first case, the function will not compute these values.
index 40849a6b53069ff6da86ef1e224f19beac641075..56780cd589044b69d1ca6569127ae28e559bf2c6 100644 (file)
@@ -299,9 +299,9 @@ public:
      * course is only allowed if <tt>dim>=2</tt>, and the face orientation,
      * flip and rotation are ignored if the space dimension equals 2.
      *
-     * The last argument denotes the number of quadrature points the lower-
-     * dimensional face quadrature formula (the one that has been projected
-     * onto the faces) has.
+     * The last argument denotes the number of quadrature points the
+     * lower-dimensional face quadrature formula (the one that has been
+     * projected onto the faces) has.
      */
     static DataSetDescriptor
     face(const ReferenceCell &reference_cell,
index 6fa33782f1ed76eefc818689c998b86be64c724e..e561cacf9d51eb51e03745d2f736006b5edcc804 100644 (file)
@@ -104,8 +104,8 @@ namespace internal
 
     /**
      * @internal Have a class which declares some nested alias, depending
-     * on its template parameters. Specialization for accessors to non-
-     * constant objects.
+     * on its template parameters. Specialization for accessors to
+     * non-constant objects.
      */
     template <int N, typename T>
     struct Types<N, T, false>
@@ -1563,8 +1563,8 @@ public:
   using TableBase<3, T>::reinit;
 
   /**
-   * Access operator. Generate an object that accesses the requested two-
-   * dimensional subobject of this three-dimensional table. Range checks are
+   * Access operator. Generate an object that accesses the requested
+   * two-dimensional subobject of this three-dimensional table. Range checks are
    * performed.
    *
    * This version of the function only allows read access.
@@ -1573,9 +1573,9 @@ public:
   operator[](const size_type i) const;
 
   /**
-   * Access operator. Generate an object that accesses the requested two-
-   * dimensional subobject of this three-dimensional table. Range checks are
-   * performed.
+   * Access operator. Generate an object that accesses the requested
+   * two-dimensional subobject of this three-dimensional table. Range
+   * checks are performed.
    *
    * This version of the function allows read-write access.
    */
@@ -1641,9 +1641,9 @@ public:
         const size_type size4);
 
   /**
-   * Access operator. Generate an object that accesses the requested three-
-   * dimensional subobject of this four-dimensional table. Range checks are
-   * performed.
+   * Access operator. Generate an object that accesses the requested
+   * three-dimensional subobject of this four-dimensional table. Range checks
+   * are performed.
    *
    * This version of the function only allows read access.
    */
@@ -1651,9 +1651,9 @@ public:
   operator[](const size_type i) const;
 
   /**
-   * Access operator. Generate an object that accesses the requested three-
-   * dimensional subobject of this four-dimensional table. Range checks are
-   * performed.
+   * Access operator. Generate an object that accesses the requested
+   * three-dimensional subobject of this four-dimensional table. Range checks
+   * are performed.
    *
    * This version of the function allows read-write access.
    */
@@ -1727,8 +1727,8 @@ public:
         const size_type size5);
 
   /**
-   * Access operator. Generate an object that accesses the requested four-
-   * dimensional subobject of this five-dimensional table. Range checks are
+   * Access operator. Generate an object that accesses the requested
+   * four-dimensional subobject of this five-dimensional table. Range checks are
    * performed.
    *
    * This version of the function only allows read access.
@@ -1737,8 +1737,8 @@ public:
   operator[](const size_type i) const;
 
   /**
-   * Access operator. Generate an object that accesses the requested four-
-   * dimensional subobject of this five-dimensional table. Range checks are
+   * Access operator. Generate an object that accesses the requested
+   * four-dimensional subobject of this five-dimensional table. Range checks are
    * performed.
    *
    * This version of the function allows read-write access.
@@ -1814,8 +1814,8 @@ public:
         const size_type size6);
 
   /**
-   * Access operator. Generate an object that accesses the requested five-
-   * dimensional subobject of this six-dimensional table. Range checks are
+   * Access operator. Generate an object that accesses the requested
+   * five-dimensional subobject of this six-dimensional table. Range checks are
    * performed.
    *
    * This version of the function only allows read access.
@@ -1824,8 +1824,8 @@ public:
   operator[](const size_type i) const;
 
   /**
-   * Access operator. Generate an object that accesses the requested five-
-   * dimensional subobject of this six-dimensional table. Range checks are
+   * Access operator. Generate an object that accesses the requested
+   * five-dimensional subobject of this six-dimensional table. Range checks are
    * performed.
    *
    * This version of the function allows read-write access.
@@ -1903,8 +1903,8 @@ public:
         const size_type size7);
 
   /**
-   * Access operator. Generate an object that accesses the requested six-
-   * dimensional subobject of this seven-dimensional table. Range checks are
+   * Access operator. Generate an object that accesses the requested
+   * six-dimensional subobject of this seven-dimensional table. Range checks are
    * performed.
    *
    * This version of the function only allows read access.
@@ -1913,8 +1913,8 @@ public:
   operator[](const size_type i) const;
 
   /**
-   * Access operator. Generate an object that accesses the requested six-
-   * dimensional subobject of this seven-dimensional table. Range checks are
+   * Access operator. Generate an object that accesses the requested
+   * six-dimensional subobject of this seven-dimensional table. Range checks are
    * performed.
    *
    * This version of the function allows read-write access.
index 526935f04fe5a957816bf792dea54fa2f2774887..1e019f7e38a022e78886619ba495dffb3e88ce37 100644 (file)
@@ -310,9 +310,9 @@ public:
    *   @endcode
    * - <code>table_with_separate_column_description</code>: This is a better
    * format when there are many columns and the table as a whole can not be
-   * displayed on the screen. Here, the column keys are first listed one-by-
-   * one on lines of their own, and are numbered for better readability. In
-   * addition, each of these description lines are prefixed by '#' to mark
+   * displayed on the screen. Here, the column keys are first listed
+   * one-by-one on lines of their own, and are numbered for better readability.
+   * In addition, each of these description lines are prefixed by '#' to mark
    * these lines as comments for programs that want to read the following
    * table as data and should ignore these descriptive lines. GNUPLOT is one
    * such program that will automatically ignore lines so prefixed. Output
index 4b3808431e93d4f0372824342724bd9d11692a64..179a1aa9d1791c4fa80da81cc5bff957d71613dc 100644 (file)
@@ -270,8 +270,8 @@ protected:
 
   /**
    * Each tensor product polynomial <i>i</i> is a product of one-dimensional
-   * polynomials in each space direction. Compute the indices of these one-
-   * dimensional polynomials for each space direction, given the index
+   * polynomials in each space direction. Compute the indices of these
+   * one-dimensional polynomials for each space direction, given the index
    * <i>i</i>.
    */
   void
@@ -473,8 +473,8 @@ private:
 
   /**
    * Each tensor product polynomial $p_i$ is a product of one-dimensional
-   * polynomials in each space direction. Compute the indices of these one-
-   * dimensional polynomials for each space direction, given the index
+   * polynomials in each space direction. Compute the indices of these
+   * one-dimensional polynomials for each space direction, given the index
    * <tt>i</tt>.
    */
   void
index 1c3ab436a9274df4c0953c1581b5b93a70fbe689..adb180e43fe9e052c3867a8d968de6522f8cc04d 100644 (file)
@@ -231,8 +231,8 @@ namespace Threads
      * same time, the purpose of this function is to release memory other
      * threads may have allocated for their own thread local objects after
      * which every use of this object will require some kind of
-     * initialization. This is necessary both in the multithreaded or non-
-     * multithreaded case.
+     * initialization. This is necessary both in the multithreaded or
+     * non-multithreaded case.
      */
     void
     clear();
index 5445b8acc99156d12580997f8bcc23b5a358826e..fc9019b3357e49b5d6ce08521a6352c9cb6e1654 100644 (file)
@@ -881,10 +881,10 @@ vectorized_load_and_transpose(const unsigned int                 n_entries,
 /**
  * This method stores the vectorized arrays in transposed form into the given
  * output array @p out with the given offsets @p offsets. This operation
- * corresponds to a transformation of a struct-of-array (input) into an array-
- * of-struct (output). This method operates on plain array, so no checks for
- * valid data access are made. It is the user's responsibility to ensure that
- * the given arrays are valid according to the access layout below.
+ * corresponds to a transformation of a struct-of-array (input) into an
+ * array-of-struct (output). This method operates on plain array, so no checks
+ * for valid data access are made. It is the user's responsibility to ensure
+ * that the given arrays are valid according to the access layout below.
  *
  * This method assumes that the specified offsets do not overlap. Otherwise,
  * the behavior is undefined in the vectorized case. It is the user's
index 74c9c3a115aac97b7af33a5b54ffc93639d2a4b9..a478dfb4f2083c9afab5408a9cc4ecba609b5ebb 100644 (file)
@@ -194,8 +194,8 @@ namespace parallel
      * that this function is in fact a member function of the class that
      * generates the mesh, for example because it needs to access run-time
      * parameters. This can be achieved as follows: assuming the
-     * <code>set_boundary_ids()</code> function has been declared as a (non-
-     * static, but possibly private) member function of the
+     * <code>set_boundary_ids()</code> function has been declared as a
+     * (non-static, but possibly private) member function of the
      * <code>MyClass</code> class, then the following will work:
      * @code
      * #include <functional>
index 133a89d6ba32d1178f702bcaf6f89e41b63c31cb..6be9f2c2f24c2df50958b31c5a5c6e2e7ef62b79 100644 (file)
@@ -570,9 +570,9 @@ public:
   n_active_fe_indices() const;
 
   /**
-   * Return the @p n-th active FE index on this object. For cells and all non-
-   * hp-objects, there is only a single active FE index, so the argument must
-   * be equal to zero. For lower-dimensional hp-objects, there are
+   * Return the @p n-th active FE index on this object. For cells and all
+   * non-hp-objects, there is only a single active FE index, so the argument
+   * must be equal to zero. For lower-dimensional hp-objects, there are
    * n_active_fe_indices() active finite elements, and this function can be
    * queried for their indices.
    */
@@ -590,8 +590,8 @@ public:
 
   /**
    * Return true if the finite element with given index is active on the
-   * present object. When the current DoFHandler does not have hp-
-   * capabilities, this is of course the case only if @p fe_index equals
+   * present object. When the current DoFHandler does not have
+   * hp-capabilities, this is of course the case only if @p fe_index equals
    * zero. For cells, it is the case if @p fe_index equals active_fe_index()
    * of this cell. For faces and other lower- dimensional objects, there may
    * be more than one @p fe_index that are active on any given object (see
@@ -800,8 +800,8 @@ public:
   DoFAccessor();
 
   /**
-   * Constructor to be used if the object here refers to a vertex of a one-
-   * dimensional triangulation, i.e. a face of the triangulation.
+   * Constructor to be used if the object here refers to a vertex of a
+   * one-dimensional triangulation, i.e. a face of the triangulation.
    *
    * Since there is no mapping from vertices to cells, an accessor object for
    * a point has no way to figure out whether it is at the boundary of the
@@ -1718,8 +1718,8 @@ public:
    * If the cell is part of a DoFHandler with hp-capabilities, cells only have
    * an associated finite element space if they are active. However, this
    * function is supposed to also work on inactive cells with children.
-   * Consequently, it carries a third argument that can be used in the hp-
-   * context that denotes the finite element space we are supposed to
+   * Consequently, it carries a third argument that can be used in the
+   * hp-context that denotes the finite element space we are supposed to
    * interpret the input vector of this function in. If the cell is active,
    * this function then interpolates the input vector interpreted as an
    * element of the space described by the <code>fe_index</code>th element of
@@ -1986,8 +1986,8 @@ public:
   /**
    * Set the index of the FiniteElement used for this cell. This determines
    * which element in an hp::FECollection to use. This function is only useful
-   * if the DoF handler object associated with the current cell has hp-
-   * capabilities enabled.
+   * if the DoF handler object associated with the current cell has
+   * hp-capabilities enabled.
    *
    * @note Since degrees of freedom only exist on active cells for DoFHandler
    * objects with hp-capabilities (i.e., there is currently no implementation
@@ -2043,8 +2043,8 @@ public:
    * will be returned.
    *
    * For DoFHandlers without hp-capabilities enabled, this is of course always
-   * the same element, independent of the cell we are presently on, but for hp-
-   * DoFHandler objects this may change from cell to cell.
+   * the same element, independent of the cell we are presently on, but for
+   * hp-DoFHandler objects this may change from cell to cell.
    *
    * @note Since degrees of freedom only exist on active cells for DoFHandler
    * objects with hp-capabilities (i.e., there is currently no implementation
index 42207e37ef6d65fa03c5524840970dca20b297c6..a2c37c8b1ba118fe267fd8cc018106825a5247b6 100644 (file)
@@ -1498,8 +1498,8 @@ private:
   BlockInfo block_info_object;
 
   /**
-   * Boolean indicating whether or not the current DoFHandler has hp-
-   * capabilities.
+   * Boolean indicating whether or not the current DoFHandler has
+   * hp-capabilities.
    */
   bool hp_capability_enabled;
 
index 60e36e04942e366737a8cf6e1fafcd68c467bd37..499b397ccf01cf36d57426ba141f2d6d4e0c2beb 100644 (file)
@@ -162,12 +162,13 @@ class MatrixFree;
  * all the pressures so that the resulting matrix naturally decomposes into a
  * $2\times 2$ system.
  *
- * This kind of numbering may be obtained by calling the component_wise()
- * function of this class. Since it does not touch the order of indices within
- * each component, it may be worthwhile to first renumber using the Cuthill-
- * McKee or a similar algorithm and afterwards renumbering component-wise.
- * This will bring out the matrix structure and additionally have a good
- * numbering within each block.
+ * This kind of numbering may be obtained by calling the
+ * component_wise() function of this class. Since it does not touch
+ * the order of indices within each component, it may be worthwhile to
+ * first renumber using the Cuthill-McKee or a similar algorithm and
+ * afterwards renumbering component-wise.  This will bring out the
+ * matrix structure and additionally have a good numbering within each
+ * block.
  *
  * The component_wise() function allows not only to honor enumeration based on
  * vector components, but also allows to group together vector components into
index 7cb861e0a94a604fdcd4119590b554df849330f8..0a875ef135e3b9254f97dca47662bfef05d51cc0 100644 (file)
@@ -1974,8 +1974,8 @@ namespace DoFTools
    * details of the generated patches. The default settings are those for
    * Arnold-Falk-Winther type smoothers for divergence and curl conforming
    * finite elements with essential boundary conditions. Other applications
-   * are possible, in particular changing <tt>boundary_patches</tt> for non-
-   * essential boundary conditions.
+   * are possible, in particular changing <tt>boundary_patches</tt> for
+   * non-essential boundary conditions.
    *
    * This function returns the <tt>vertex_mapping</tt>,
    * that contains the mapping from the vertex indices to the block indices
@@ -2065,8 +2065,8 @@ namespace DoFTools
    * details of the generated patches. The default settings are those for
    * Arnold-Falk-Winther type smoothers for divergence and curl conforming
    * finite elements with essential boundary conditions. Other applications
-   * are possible, in particular changing <tt>boundary_dofs</tt> for non-
-   * essential boundary conditions.
+   * are possible, in particular changing <tt>boundary_dofs</tt> for
+   * non-essential boundary conditions.
    *
    * @arg <tt>block_list</tt>: the SparsityPattern into which the patches will
    * be stored.
@@ -2146,8 +2146,8 @@ namespace DoFTools
    * components of a nonprimitive vector valued element is collected only in
    * the first component. All other components will have a count of zero.
    *
-   * The additional optional argument @p target_component allows for a re-
-   * sorting and grouping of components. To this end, it contains for each
+   * The additional optional argument @p target_component allows for a
+   * re-sorting and grouping of components. To this end, it contains for each
    * component the component number it shall be counted as. Having the same
    * number entered several times sums up several components as the same. One
    * of the applications of this argument is when you want to form block
@@ -2585,8 +2585,8 @@ namespace DoFTools
    * module for handling the case where there are conflicting constraints on
    * individual degrees of freedom.
    * @param component_mask An optional component mask that restricts the
-   * functionality of this function to a subset of an FESystem. For non-
-   * @ref GlossPrimitive "primitive"
+   * functionality of this function to a subset of an FESystem. For
+   * non-@ref GlossPrimitive "primitive"
    * shape functions, any degree of freedom is affected that belongs to a
    * shape function where at least one of its nonzero components is affected
    * by the component mask (see
index a44e0ca838e459552e297e6bb86a5b36aed23496..1d84e927100044890a8584f40088b89b371be19d 100644 (file)
@@ -961,10 +961,11 @@ public:
   shape_3rd_derivative(const unsigned int i, const Point<dim> &p) const;
 
   /**
-   * Just like for shape_3rd_derivative(), but this function will be called
-   * when the shape function has more than one non-zero vector component. In
-   * that case, this function should return the gradient of the @p component-
-   * th vector component of the @p ith shape function at point @p p.
+   * Just like for shape_3rd_derivative(), but this function will be
+   * called when the shape function has more than one non-zero vector
+   * component. In that case, this function should return the gradient
+   * of the @p component-th vector component of the @p ith shape
+   * function at point @p p.
    */
   virtual Tensor<3, dim>
   shape_3rd_derivative_component(const unsigned int i,
@@ -998,8 +999,9 @@ public:
   /**
    * Just like for shape_4th_derivative(), but this function will be called
    * when the shape function has more than one non-zero vector component. In
-   * that case, this function should return the gradient of the @p component-
-   * th vector component of the @p ith shape function at point @p p.
+   * that case, this function should return the gradient of the
+   * @p component-th vector component of the @p ith shape function at point
+   * @p p.
    */
   virtual Tensor<4, dim>
   shape_4th_derivative_component(const unsigned int i,
@@ -1580,11 +1582,11 @@ public:
   is_primitive() const;
 
   /**
-   * Return whether the @p ith shape function is primitive in the sense that
-   * the shape function is non-zero in only one vector component. Non-
-   * primitive shape functions would then, for example, be those of divergence
-   * free ansatz spaces, in which the individual vector components are
-   * coupled.
+   * Return whether the @p ith shape function is primitive in the
+   * sense that the shape function is non-zero in only one vector
+   * component. Non-primitive shape functions would then, for example,
+   * be those of divergence free ansatz spaces, in which the
+   * individual vector components are coupled.
    *
    * The result of the function is @p true if and only if the result of
    * <tt>n_nonzero_components(i)</tt> is equal to one.
@@ -2133,18 +2135,20 @@ public:
    * For a given degree of freedom, return whether it is logically associated
    * with a vertex, line, quad or hex.
    *
-   * For instance, for continuous finite elements this coincides with the
-   * lowest dimensional object the support point of the degree of freedom lies
-   * on. To give an example, for $Q_1$ elements in 3d, every degree of freedom
-   * is defined by a shape function that we get by interpolating using support
-   * points that lie on the vertices of the cell. The support of these points
-   * of course extends to all edges connected to this vertex, as well as the
-   * adjacent faces and the cell interior, but we say that logically the
-   * degree of freedom is associated with the vertex as this is the lowest-
-   * dimensional object it is associated with. Likewise, for $Q_2$ elements in
-   * 3d, the degrees of freedom with support points at edge midpoints would
-   * yield a value of GeometryPrimitive::line from this function, whereas
-   * those on the centers of faces in 3d would return GeometryPrimitive::quad.
+   * For instance, for continuous finite elements this coincides with
+   * the lowest dimensional object the support point of the degree of
+   * freedom lies on. To give an example, for $Q_1$ elements in 3d,
+   * every degree of freedom is defined by a shape function that we
+   * get by interpolating using support points that lie on the
+   * vertices of the cell. The support of these points of course
+   * extends to all edges connected to this vertex, as well as the
+   * adjacent faces and the cell interior, but we say that logically
+   * the degree of freedom is associated with the vertex as this is
+   * the lowest-dimensional object it is associated with. Likewise,
+   * for $Q_2$ elements in 3d, the degrees of freedom with support
+   * points at edge midpoints would yield a value of
+   * GeometryPrimitive::line from this function, whereas those on the
+   * centers of faces in 3d would return GeometryPrimitive::quad.
    *
    * To make this more formal, the kind of object returned by this function
    * represents the object so that the support of the shape function
@@ -2587,10 +2591,11 @@ protected:
   const bool cached_primitivity;
 
   /**
-   * Return the size of interface constraint matrices. Since this is needed in
-   * every derived finite element class when initializing their size, it is
-   * placed into this function, to avoid having to recompute the dimension-
-   * dependent size of these matrices each time.
+   * Return the size of interface constraint matrices. Since this is
+   * needed in every derived finite element class when initializing
+   * their size, it is placed into this function, to avoid having to
+   * recompute the dimension-dependent size of these matrices each
+   * time.
    *
    * Note that some elements do not implement the interface constraints for
    * certain polynomial degrees. In this case, this function still returns the
@@ -2655,8 +2660,8 @@ protected:
    * last argument. This output argument is guaranteed to always be the same one
    * when used with the InternalDataBase object returned by this function. In
    * other words, the subdivision of scratch data and final data in the returned
-   * object and the @p output_data object is as follows: If data can be pre-
-   * computed on the reference cell in the exact form in which it will later
+   * object and the @p output_data object is as follows: If data can be
+   * pre-computed on the reference cell in the exact form in which it will later
    * be needed on a concrete cell, then this function should already emplace
    * it in the @p output_data object. An example are the values of shape
    * functions at quadrature points for the usual Lagrange elements which on a
@@ -2684,9 +2689,10 @@ protected:
    * compute. This set of flags may also include information that the finite
    * element can not compute, e.g., flags that pertain to data produced by the
    * mapping. An implementation of this function needs to set up all data
-   * fields in the returned object that are necessary to produce the finite-
-   * element related data specified by these flags, and may already pre-
-   * compute part of this information as discussed above. Elements may want to
+   * fields in the returned object that are necessary to produce the
+   * finite-element related data specified by these flags, and may already
+   * pre-compute part of this information as discussed above. Elements may
+   * want to
    * store these update flags (or a subset of these flags) in
    * InternalDataBase::update_each so they know at the time when
    * FiniteElement::fill_fe_values() is called what they are supposed to
@@ -2703,10 +2709,10 @@ protected:
    * above. FEValues guarantees that this output object and the object
    * returned by the current function will always be used together.
    * @return A pointer to an object of a type derived from InternalDataBase
-   * and that derived classes can use to store scratch data that can be pre-
-   * computed, or for scratch arrays that then only need to be allocated once.
-   * The calling site assumes ownership of this object and will delete it when
-   * it is no longer necessary.
+   * and that derived classes can use to store scratch data that can be
+   * pre-computed, or for scratch arrays that then only need to be allocated
+   * once. The calling site assumes ownership of this object and will delete it
+   * when it is no longer necessary.
    */
   virtual std::unique_ptr<InternalDataBase>
   get_data(const UpdateFlags             update_flags,
@@ -2732,9 +2738,10 @@ protected:
    * compute. This set of flags may also include information that the finite
    * element can not compute, e.g., flags that pertain to data produced by the
    * mapping. An implementation of this function needs to set up all data
-   * fields in the returned object that are necessary to produce the finite-
-   * element related data specified by these flags, and may already pre-
-   * compute part of this information as discussed above. Elements may want to
+   * fields in the returned object that are necessary to produce the
+   * finite-element related data specified by these flags, and may already
+   * pre-compute part of this information as discussed above. Elements may
+   * want to
    * store these update flags (or a subset of these flags) in
    * InternalDataBase::update_each so they know at the time when
    * FiniteElement::fill_fe_face_values() is called what they are supposed to
@@ -2751,10 +2758,10 @@ protected:
    * discussed above. FEValues guarantees that this output object and the
    * object returned by the current function will always be used together.
    * @return A pointer to an object of a type derived from InternalDataBase
-   * and that derived classes can use to store scratch data that can be pre-
-   * computed, or for scratch arrays that then only need to be allocated once.
-   * The calling site assumes ownership of this object and will delete it when
-   * it is no longer necessary.
+   * and that derived classes can use to store scratch data that can be
+   * pre-computed, or for scratch arrays that then only need to be allocated
+   * once. The calling site assumes ownership of this object and will
+   * delete it when it is no longer necessary.
    */
   virtual std::unique_ptr<InternalDataBase>
   get_face_data(const UpdateFlags               update_flags,
@@ -2791,9 +2798,10 @@ protected:
    * compute. This set of flags may also include information that the finite
    * element can not compute, e.g., flags that pertain to data produced by the
    * mapping. An implementation of this function needs to set up all data
-   * fields in the returned object that are necessary to produce the finite-
-   * element related data specified by these flags, and may already pre-
-   * compute part of this information as discussed above. Elements may want to
+   * fields in the returned object that are necessary to produce the
+   * finite-element related data specified by these flags, and may already
+   * pre-compute part of this information as discussed above. Elements may
+   * want to
    * store these update flags (or a subset of these flags) in
    * InternalDataBase::update_each so they know at the time when
    * FiniteElement::fill_fe_subface_values() is called what they are supposed
@@ -2810,8 +2818,9 @@ protected:
    * discussed above. FEValues guarantees that this output object and the
    * object returned by the current function will always be used together.
    * @return A pointer to an object of a type derived from InternalDataBase
-   * and that derived classes can use to store scratch data that can be pre-
-   * computed, or for scratch arrays that then only need to be allocated once.
+   * and that derived classes can use to store scratch data that can be
+   * pre-computed, or for scratch arrays that then only need to be allocated
+   * once.
    * The calling site assumes ownership of this object and will delete it when
    * it is no longer necessary.
    */
index d6eeab01ad4c003bf40087c9ba59997b7620ff52..0fddc49f1abd30ce8811e0bf69caffd7839e3e77 100644 (file)
@@ -63,11 +63,11 @@ namespace FiniteElementDomination
    *
    * Note that there are situations where neither side dominates. The
    * @ref hp_paper "hp-paper"
-   * lists two case, with the simpler one being that a $Q_2\times Q_1$ vector-
-   * valued element (i.e. a <code>FESystem(FE_Q(2),1,FE_Q(1),1)</code>) meets
-   * a $Q_1\times Q_2$ element: here, for each of the two vector-components,
-   * we can define a domination relationship, but it is different for the two
-   * components.
+   * lists two case, with the simpler one being that a $Q_2\times Q_1$
+   * vector-valued element (i.e. a <code>FESystem(FE_Q(2),1,FE_Q(1),1)</code>)
+   * meets a $Q_1\times Q_2$ element: here, for each of the two
+   * vector-components, we can define a domination relationship, but it is
+   * different for the two components.
    *
    * It is clear that the concept of domination doesn't matter for
    * discontinuous elements. However, discontinuous elements may be part of
index a0a1c4a5a27894d3e3dc3c9663527f8bba24dbc5..cd123943bc76741fea5e515d6740900d1ecc20ac 100644 (file)
@@ -32,8 +32,8 @@ DEAL_II_NAMESPACE_OPEN
 /**
  * Discontinuous finite elements based on Legendre polynomials.
  *
- * This finite element implements complete polynomial spaces, that is, dim-
- * dimensional polynomials of degree p. For example, in 2d the element
+ * This finite element implements complete polynomial spaces, that is,
+ * dim-dimensional polynomials of degree p. For example, in 2d the element
  * FE_DGP(1) would represent the span of the functions $\{1,\hat x,\hat y\}$,
  * which is in contrast to the element FE_DGQ(1) that is formed by the span of
  * $\{1,\hat x,\hat y,\hat x\hat y\}$. Since the DGP space has only three
index 4654dc3163dd93b228dad496c8327d27ad2d8d84..2016e3a1ed33e9eb69a16c55fbaf23252e76bfa3 100644 (file)
@@ -32,8 +32,8 @@ DEAL_II_NAMESPACE_OPEN
 /**
  * Discontinuous finite elements based on monomials.
  *
- * This finite element implements complete polynomial spaces, that is, dim-
- * dimensional polynomials of degree p. For example, in 2d the element
+ * This finite element implements complete polynomial spaces, that is,
+ * dim-dimensional polynomials of degree p. For example, in 2d the element
  * FE_DGP(1) would represent the span of the functions $\{1,\hat x,\hat y\}$,
  * which is in contrast to the element FE_DGQ(1) that is formed by the span of
  * $\{1,\hat x,\hat y,\hat x\hat y\}$. Since the DGP space has only three
index 7f055dc7312f4f833610c12388faa9efe4ff4cd0..5d19bd9eba1032b235e1963c648ef9f61760c403 100644 (file)
@@ -670,14 +670,15 @@ public:
                        const unsigned int component) const override;
 
   /**
-   * Return the tensor of second derivatives of the @p ith shape function at
-   * point @p p on the unit cell. The derivatives are derivatives on the unit
-   * cell with respect to unit cell coordinates. Since this finite element is
-   * always vector-valued, we return the value of the only non-zero component
-   * of the vector value of this shape function. If the shape function has
-   * more than one non-zero component (which we refer to with the term non-
-   * primitive), then throw an exception of type @p
-   * ExcShapeFunctionNotPrimitive.
+   * Return the tensor of second derivatives of the @p ith shape
+   * function at point @p p on the unit cell. The derivatives are
+   * derivatives on the unit cell with respect to unit cell
+   * coordinates. Since this finite element is always vector-valued,
+   * we return the value of the only non-zero component of the vector
+   * value of this shape function. If the shape function has more than
+   * one non-zero component (which we refer to with the term
+   * non-primitive), then throw an exception of type
+   * @p ExcShapeFunctionNotPrimitive.
    *
    * An @p ExcUnitShapeValuesDoNotExist is thrown if the shape values of the
    * @p FiniteElement (corresponding to the @p ith shape function) depend on
@@ -705,8 +706,8 @@ public:
    * cell with respect to unit cell coordinates. Since this finite element is
    * always vector-valued, we return the value of the only non-zero component
    * of the vector value of this shape function. If the shape function has
-   * more than one non-zero component (which we refer to with the term non-
-   * primitive), then throw an exception of type @p
+   * more than one non-zero component (which we refer to with the term
+   * non-primitive), then throw an exception of type @p
    * ExcShapeFunctionNotPrimitive.
    *
    * An @p ExcUnitShapeValuesDoNotExist is thrown if the shape values of the
@@ -736,9 +737,9 @@ public:
    * cell with respect to unit cell coordinates. Since this finite element is
    * always vector-valued, we return the value of the only non-zero component
    * of the vector value of this shape function. If the shape function has
-   * more than one non-zero component (which we refer to with the term non-
-   * primitive), then throw an exception of type @p
-   * ExcShapeFunctionNotPrimitive.
+   * more than one non-zero component (which we refer to with the term
+   * non-primitive), then throw an exception of type
+   * @p ExcShapeFunctionNotPrimitive.
    *
    * An @p ExcUnitShapeValuesDoNotExist is thrown if the shape values of the
    * @p FiniteElement (corresponding to the @p ith shape function) depend on
index b198f2ebdb4f1d71be6924b55d1786140d2a7560..7859c575af8e8267d6b32dd6f0c2b84ba4bf323d 100644 (file)
@@ -435,9 +435,9 @@ namespace FETools
    * data <tt>u<sub>q</sub>, 0 <= q < Q:=quadrature.size()</tt> defined at the
    * quadrature points of a cell, with the points defined by the given
    * <tt>rhs_quadrature</tt> object. We may then want to ask for that finite
-   * element function (on a single cell) <tt>v<sub>h</sub></tt> in the finite-
-   * dimensional space defined by the given FE object that is the projection
-   * of <tt>u</tt> in the following sense:
+   * element function (on a single cell) <tt>v<sub>h</sub></tt> in the
+   * finite-dimensional space defined by the given FE object that is the
+   * projection of <tt>u</tt> in the following sense:
    *
    * Usually, the projection <tt>v<sub>h</sub></tt> is that function that
    * satisfies <tt>(v<sub>h</sub>,w)=(u,w)</tt> for all discrete test
@@ -492,9 +492,9 @@ namespace FETools
    * The first one is that it really only makes sense to project onto a finite
    * element that has at most as many degrees of freedom per cell as there are
    * quadrature points; the projection of N quadrature point data into a space
-   * with M>N unknowns is well-defined, but often yields funny and non-
-   * intuitive results. Secondly, one would think that if the quadrature point
-   * data is defined in the support points of the finite element, i.e. the
+   * with M>N unknowns is well-defined, but often yields funny and
+   * non-intuitive results. Secondly, one would think that if the quadrature
+   * point data is defined in the support points of the finite element, i.e. the
    * quadrature points of <tt>rhs_quadrature</tt> equal
    * <tt>fe.get_unit_support_points()</tt>, then the projection should be the
    * identity, i.e. each degree of freedom of the finite element equals the
@@ -1251,8 +1251,8 @@ namespace FETools
    * The format of the @p name parameter should include the name of a finite
    * element. However, it is safe to use either the class name alone or to use
    * the result of FiniteElement::get_name (which includes the space dimension
-   * as well as the polynomial degree), since everything after the first non-
-   * name character will be ignored.
+   * as well as the polynomial degree), since everything after the first
+   * non-name character will be ignored.
    *
    * The FEFactory object should be an object newly created with <tt>new</tt>.
    * FETools will take ownership of this object and delete it once it is not
index 25664587df42f0c448e7327546bad33e3aeecf1e..d5dfb8a5a50ac0d5197ac44d57a9518a004d3404 100644 (file)
@@ -128,8 +128,8 @@ DEAL_II_NAMESPACE_OPEN
  * set of functions as above, except that for vector valued finite elements
  * they return only one vector component. This is useful for elements of which
  * shape functions have more than one non-zero component, since then the above
- * functions cannot be used, and you have to walk over all (or only the non-
- * zero) components of the shape function using this set of functions.
+ * functions cannot be used, and you have to walk over all (or only the
+ * non-zero) components of the shape function using this set of functions.
  *
  * <li> get_function_values(), get_function_gradients(), etc.: Compute a
  * finite element function or its derivative in quadrature points.
@@ -257,8 +257,8 @@ public:
    * subface selected the last time the <tt>reinit</tt> function of the
    * derived class was called.
    *
-   * If the shape function is vector-valued, then this returns the only non-
-   * zero component. If the shape function has more than one non-zero
+   * If the shape function is vector-valued, then this returns the only
+   * non-zero component. If the shape function has more than one non-zero
    * component (i.e. it is not primitive), then throw an exception of type
    * ExcShapeFunctionNotPrimitive. In that case, use the
    * shape_value_component() function.
@@ -309,8 +309,8 @@ public:
    * reference to the gradient's value is returned, there should be no major
    * performance drawback.
    *
-   * If the shape function is vector-valued, then this returns the only non-
-   * zero component. If the shape function has more than one non-zero
+   * If the shape function is vector-valued, then this returns the only
+   * non-zero component. If the shape function has more than one non-zero
    * component (i.e. it is not primitive), then it will throw an exception of
    * type ExcShapeFunctionNotPrimitive. In that case, use the
    * shape_grad_component() function.
@@ -357,8 +357,8 @@ public:
    * one component. Since only a reference to the hessian values is returned,
    * there should be no major performance drawback.
    *
-   * If the shape function is vector-valued, then this returns the only non-
-   * zero component. If the shape function has more than one non-zero
+   * If the shape function is vector-valued, then this returns the only
+   * non-zero component. If the shape function has more than one non-zero
    * component (i.e. it is not primitive), then throw an exception of type
    * ExcShapeFunctionNotPrimitive. In that case, use the
    * shape_hessian_component() function.
@@ -400,8 +400,8 @@ public:
    * to extract one component. Since only a reference to the 3rd derivative
    * values is returned, there should be no major performance drawback.
    *
-   * If the shape function is vector-valued, then this returns the only non-
-   * zero component. If the shape function has more than one non-zero
+   * If the shape function is vector-valued, then this returns the only
+   * non-zero component. If the shape function has more than one non-zero
    * component (i.e. it is not primitive), then throw an exception of type
    * ExcShapeFunctionNotPrimitive. In that case, use the
    * shape_3rdderivative_component() function.
@@ -985,8 +985,9 @@ public:
 
   /**
    * This function does the same as the other
-   * get_function_third_derivatives(), but applied to multi-component (vector-
-   * valued) elements. The meaning of the arguments is as explained there.
+   * get_function_third_derivatives(), but applied to multi-component
+   * (vector-valued) elements. The meaning of the arguments is as explained
+   * there.
    *
    * @post <code>third_derivatives[q]</code> is a vector of third derivatives
    * of the field described by fe_function at the $q$th quadrature point. The
index 16951add997c86e16a87f793077881acbb0f6204..2224a30da361940b264a6ebb69f644076c0f12de 100644 (file)
@@ -122,8 +122,8 @@ namespace FEValuesExtractors
 
 
   /**
-   * Extractor for a vector of <code>spacedim</code> components of a vector-
-   * valued element. The value of <code>spacedim</code> is defined by the
+   * Extractor for a vector of <code>spacedim</code> components of a
+   * vector-valued element. The value of <code>spacedim</code> is defined by the
    * FEValues object the extractor is applied to. The result of applying an
    * object of this type to an FEValues, FEFaceValues or FESubfaceValues
    * object is of type FEValuesViews::Vector.
@@ -180,8 +180,8 @@ namespace FEValuesExtractors
   /**
    * Extractor for a symmetric tensor of a rank specified by the template
    * argument. For a second order symmetric tensor, this represents a
-   * collection of <code>(dim*dim + dim)/2</code> components of a vector-
-   * valued element. The value of <code>dim</code> is defined by the FEValues
+   * collection of <code>(dim*dim + dim)/2</code> components of a vector-valued
+   * element. The value of <code>dim</code> is defined by the FEValues
    * object the extractor is applied to. The result of applying an object of
    * this type to an FEValues, FEFaceValues or FESubfaceValues object is of
    * type FEValuesViews::SymmetricTensor.
index 194389a094fea4d436e9e25a783a986b2435c455..70592d6d559d5548196ee265ebfd8aa7afcc7944 100644 (file)
@@ -612,8 +612,8 @@ public:
    * - To provide scratch space for computations that are done in
    * Mapping::fill_fe_values() and similar functions. Some of the derived
    * classes would like to use scratch arrays and it would be a waste of time
-   * to allocate these arrays every time this function is called, just to de-
-   * allocate it again at the end of the function. Rather, one could allocate
+   * to allocate these arrays every time this function is called, just to
+   * de-allocate it again at the end of the function. Rather, one could allocate
    * this memory once as a member variable of the current class, and simply
    * use it in Mapping::fill_fe_values().
    * - After calling Mapping::fill_fe_values(), FEValues::reinit()
@@ -721,8 +721,8 @@ protected:
    * interface of mappings with the FEValues class).
    *
    * Derived classes will return pointers to objects of a type derived from
-   * Mapping::InternalDataBase (see there for more information) and may pre-
-   * compute some information already (in accordance with what will be asked
+   * Mapping::InternalDataBase (see there for more information) and may
+   * pre-compute some information already (in accordance with what will be asked
    * of the mapping in the future, as specified by the update flags) and for
    * the given quadrature object. Subsequent calls to transform() or
    * fill_fe_values() and friends will then receive back the object created
index 80e6c4104e9d02fce9c176c4ac42f129b68bfe44..66aad79dcb2689fdf6ccd4da602548e60dd19601 100644 (file)
@@ -327,8 +327,8 @@ namespace GridTools
    * all boundary vertices (although you then lose control over the exact
    * shape of the mapped domain).
    *
-   * @param[in,out] tria The Triangulation object. This object is changed in-
-   * place, i.e., the previous locations of vertices are overwritten.
+   * @param[in,out] tria The Triangulation object. This object is changed
+   * in-place, i.e., the previous locations of vertices are overwritten.
    *
    * @param[in] coefficient An optional coefficient for the Laplace problem.
    * Larger values make cells less prone to deformation (effectively
index 7e298a2ac993bce6f9eb14eb3b3289fc156f590d..a584f157023cf6c3f6d08cf93e021dec6f22acbc 100644 (file)
@@ -29,8 +29,8 @@ DEAL_II_NAMESPACE_OPEN
 
 /**
  * This class handles the history of a triangulation and can rebuild it after
- * it was deleted some time before. Its main purpose is support for time-
- * dependent problems where one frequently deletes a triangulation due to
+ * it was deleted some time before. Its main purpose is support for
+ * time-dependent problems where one frequently deletes a triangulation due to
  * memory pressure and later wants to rebuild it; this class has all the
  * information to rebuild it exactly as it was before including the mapping of
  * cell numbers to the geometrical cells.
index 48066c61b7e1f5ada8d010fdeafc4d4818b39357..6069d84c54f9f744a504a27be72182d54daa4835 100644 (file)
@@ -1173,8 +1173,8 @@ namespace internal
  *   previous_cell = Triangulation<dim>::active_cell_iterator();
  * }
  * @endcode
- * Here, whenever the triangulation is refined, it triggers the post-
- * refinement signal which calls the function object attached to it. This
+ * Here, whenever the triangulation is refined, it triggers the
+ * post-refinement signal which calls the function object attached to it. This
  * function object is the member function
  * <code>FEValues<dim>::invalidate_previous_cell</code> where we have bound
  * the single argument (the <code>this</code> pointer of a member function
@@ -1352,8 +1352,8 @@ public:
   enum MeshSmoothing
   {
     /**
-     * No mesh smoothing at all, except that meshes have to remain one-
-     * irregular.
+     * No mesh smoothing at all, except that meshes have to remain
+     * one-irregular.
      */
     none = 0x0,
     /**
@@ -3026,8 +3026,8 @@ public:
 
   /**
    * Return an iterator range that contains all cells (active or not) that
-   * make up this triangulation. Such a range is useful to initialize range-
-   * based for loops as supported by C++11. See the example in the
+   * make up this triangulation. Such a range is useful to initialize
+   * range-based for loops as supported by C++11. See the example in the
    * documentation of active_cell_iterators().
    *
    * @return The half open range <code>[this->begin(), this->end())</code>
index e5bc974b3b807f706c2783911e392ce0a9338c52..4a0c59401bdee2b4f1361bbd0381a48951cd4be5 100644 (file)
@@ -1914,8 +1914,8 @@ class TriaAccessor<0, dim, spacedim>
 public:
   /**
    * Dimension of the space the object represented by this accessor lives in.
-   * For example, if this accessor represents a quad that is part of a two-
-   * dimensional surface in four-dimensional space, then this value is four.
+   * For example, if this accessor represents a quad that is part of a
+   * two-dimensional surface in four-dimensional space, then this value is four.
    */
   static constexpr unsigned int space_dimension = spacedim;
 
@@ -2326,8 +2326,8 @@ class TriaAccessor<0, 1, spacedim>
 public:
   /**
    * Dimension of the space the object represented by this accessor lives in.
-   * For example, if this accessor represents a quad that is part of a two-
-   * dimensional surface in four-dimensional space, then this value is four.
+   * For example, if this accessor represents a quad that is part of a
+   * two-dimensional surface in four-dimensional space, then this value is four.
    */
   static constexpr unsigned int space_dimension = spacedim;
 
@@ -2965,8 +2965,8 @@ public:
   set_manifold_id(const types::manifold_id);
 
   /**
-   * Set the boundary indicator of this object and all of its lower-
-   * dimensional sub-objects.  Since this object only represents a single
+   * Set the boundary indicator of this object and all of its
+   * lower-dimensional sub-objects.  Since this object only represents a single
    * vertex, there are no lower-dimensional object and this function is
    * equivalent to calling set_boundary_id() with the same argument.
    *
@@ -2979,8 +2979,8 @@ public:
   set_all_boundary_ids(const types::boundary_id) const;
 
   /**
-   * Set the manifold indicator of this object and all of its lower-
-   * dimensional sub-objects.  Since this object only represents a single
+   * Set the manifold indicator of this object and all of its
+   * lower-dimensional sub-objects.  Since this object only represents a single
    * vertex, there are no lower-dimensional object and this function is
    * equivalent to calling set_manifold_id() with the same argument.
    *
@@ -3723,8 +3723,8 @@ public:
   set_material_id(const types::material_id new_material_id) const;
 
   /**
-   * Set the material id of this cell and all its children (and grand-
-   * children, and so on) to the given value.
+   * Set the material id of this cell and all its children (and
+   * grand-children, and so on) to the given value.
    *
    * See the
    * @ref GlossMaterialId "glossary"
index 55715f1f19e62e6f17015ec6bb209a88e5ff1815..8dde2feb57cefa5acf8145e1e9bddf0237bc1800 100644 (file)
@@ -849,9 +849,9 @@ public:
    * This function essentially exists to allow adding several constraints of
    * the form <i>x<sub>i</sub></i>=0 all at once, where the set of indices
    * <i>i</i> for which these constraints should be added are given by the
-   * argument of this function. On the other hand, just as if the single-
-   * argument add_line() function were called repeatedly, the constraints can
-   * later be modified to include linear dependencies using the add_entry()
+   * argument of this function. On the other hand, just as if the
+   * single-argument add_line() function were called repeatedly, the constraints
+   * can later be modified to include linear dependencies using the add_entry()
    * function as well as inhomogeneities using set_inhomogeneity().
    */
   void
@@ -864,9 +864,9 @@ public:
    * This function essentially exists to allow adding several constraints of
    * the form <i>x<sub>i</sub></i>=0 all at once, where the set of indices
    * <i>i</i> for which these constraints should be added are given by the
-   * argument of this function. On the other hand, just as if the single-
-   * argument add_line() function were called repeatedly, the constraints can
-   * later be modified to include linear dependencies using the add_entry()
+   * argument of this function. On the other hand, just as if the
+   * single-argument add_line() function were called repeatedly, the constraints
+   * can later be modified to include linear dependencies using the add_entry()
    * function as well as inhomogeneities using set_inhomogeneity().
    */
   void
@@ -879,9 +879,9 @@ public:
    * This function essentially exists to allow adding several constraints of
    * the form <i>x<sub>i</sub></i>=0 all at once, where the set of indices
    * <i>i</i> for which these constraints should be added are given by the
-   * argument of this function. On the other hand, just as if the single-
-   * argument add_line() function were called repeatedly, the constraints can
-   * later be modified to include linear dependencies using the add_entry()
+   * argument of this function. On the other hand, just as if the
+   * single-argument add_line() function were called repeatedly, the constraints
+   * can later be modified to include linear dependencies using the add_entry()
    * function as well as inhomogeneities using set_inhomogeneity().
    */
   void
@@ -1158,8 +1158,8 @@ public:
   max_constraint_indirections() const;
 
   /**
-   * Return <tt>true</tt> in case the dof is constrained and there is a non-
-   * trivial inhomogeneous values set to the dof.
+   * Return <tt>true</tt> in case the dof is constrained and there is a
+   * non-trivial inhomogeneous values set to the dof.
    */
   bool
   is_inhomogeneously_constrained(const size_type index) const;
index 7b60d94aa37a9b393695ce89ae2f5096972fbaab..9d6a6834d3ab3d4ec82ef726bad4b83ebb139702 100644 (file)
@@ -858,8 +858,8 @@ protected:
    * matrix to indices into the subobjects. You *must* call this function each
    * time after you have changed the size of the sub-objects.
    *
-   * Derived classes should call this function whenever the size of the sub-
-   * objects has changed and the @p X_block_indices arrays need to be updated.
+   * Derived classes should call this function whenever the size of the
+   * sub-objects has changed and the @p X_block_indices arrays need to be updated.
    *
    * Note that this function is not public since not all derived classes need
    * to export its interface. For example, for the usual deal.II SparseMatrix
index cd06f2e71f911031716a7adfb685b42c440483ba..3e958b25ce84f7fb53380d9fb976ddffe9251a91 100644 (file)
@@ -144,8 +144,8 @@ public:
    * latter tells the matrix how many nonzero elements there need to be
    * reserved.
    *
-   * Basically, this function only calls SparseMatrix::reinit() of the sub-
-   * matrices with the block sparsity patterns of the parameter.
+   * Basically, this function only calls SparseMatrix::reinit() of the
+   * sub-matrices with the block sparsity patterns of the parameter.
    *
    * You have to make sure that the lifetime of the sparsity structure is at
    * least as long as that of this matrix or as long as reinit(const
index ce07c9f288836c17510cb2eba57a6e535fcc4d86..90ff1058b66e437d2ab71240e9b0c843b5cc37b2 100644 (file)
@@ -157,8 +157,8 @@ public:
   /**
    * Return whether the object is empty. It is empty if no memory is
    * allocated, which is the same as that both dimensions are zero. This
-   * function is just the concatenation of the respective call to all sub-
-   * matrices.
+   * function is just the concatenation of the respective call to all
+   * sub-matrices.
    */
   bool
   empty() const;
@@ -174,9 +174,9 @@ public:
 
   /**
    * Return number of columns of this matrix, which equals the dimension of
-   * the domain space. It is the sum of the number of columns over the sub-
-   * matrix blocks of this matrix. Recall that the matrix is of size m() times
-   * n().
+   * the domain space. It is the sum of the number of columns over the
+   * sub-matrix blocks of this matrix. Recall that the matrix is of size m()
+   * times n().
    */
   size_type
   n() const;
index 2bbde6956209dcfaa5ed8e4b795965066bba56e1..f0cb6f49b86f33fd729fb331acc866117add29c2 100644 (file)
@@ -200,8 +200,8 @@ public:
   /**
    * Return whether the object is empty. It is empty if no memory is
    * allocated, which is the same as that both dimensions are zero. This
-   * function is just the concatenation of the respective call to all sub-
-   * matrices.
+   * function is just the concatenation of the respective call to all
+   * sub-matrices.
    */
   bool
   empty() const;
@@ -263,8 +263,8 @@ public:
 
   /**
    * Return number of columns of this matrix, which equals the dimension of
-   * the range space. It is the sum of columns of the (block-)columns of sub-
-   * matrices.
+   * the range space. It is the sum of columns of the (block-)columns of
+   * sub-matrices.
    */
   using SparsityPatternBase::n_cols;
 
@@ -476,8 +476,8 @@ public:
 
 
   /**
-   * Return whether the structure is compressed or not, i.e. whether all sub-
-   * matrices are compressed.
+   * Return whether the structure is compressed or not, i.e. whether all
+   * sub-matrices are compressed.
    */
   bool
   is_compressed() const;
index aa0934352edebe38933ed1ce0afa11e04fa344a6..215de86a869f1c07889c01727e55275f439a4747 100644 (file)
@@ -562,10 +562,10 @@ namespace LinearAlgebra
       update_ghost_values() const;
 
       /**
-       * Initiates communication for the @p compress() function with non-
-       * blocking communication. This function does not wait for the transfer
-       * to finish, in order to allow for other computations during the time
-       * it takes until all data arrives.
+       * Initiates communication for the @p compress() function with
+       * non-blocking communication. This function does not wait for the
+       * transfer to finish, in order to allow for other computations during the
+       * time it takes until all data arrives.
        *
        * Before the data is actually exchanged, the function must be followed
        * by a call to @p compress_finish().
index 778b3a14b5672e3aacf255c34f36b4b60a181c04..261a974d7384b438a71b980365e93897fbf2a7da 100644 (file)
@@ -254,8 +254,7 @@ namespace PETScWrappers
        * This function collects the sizes of the sub-objects and stores them
        * in internal arrays, in order to be able to relay global indices into
        * the matrix to indices into the subobjects. You *must* call this
-       * function each time after you have changed the size of the sub-
-       * objects.
+       * function each time after you have changed the size of the sub-objects.
        */
       void
       collect_sizes();
index 905c913ceb28f59747643a2a93c0980401dc06c0..e573c56ce45462689908f3309f4202e3f3feee35 100644 (file)
@@ -262,8 +262,7 @@ namespace PETScWrappers
        * This function collects the sizes of the sub-objects and stores them
        * in internal arrays, in order to be able to relay global indices into
        * the vector to indices into the subobjects. You *must* call this
-       * function each time after you have changed the size of the sub-
-       * objects.
+       * function each time after you have changed the size of the sub-objects.
        */
       void
       collect_sizes();
index 3d886980aa8d29ea196967317f3620c43a2d5e5d..7e5e175645819ec2bc32bdb8a09433aeb5a79ef5 100644 (file)
@@ -42,8 +42,8 @@ DEAL_II_NAMESPACE_OPEN
  * PreconditionBlock, since the index sets may be arbitrary and overlapping,
  * while there only contiguous, disjoint sets of equal size are allowed. As a
  * drawback, this class cannot be used as a preconditioner, since its
- * implementation relies on a straight forward implementation of the Gauss-
- * Seidel process.
+ * implementation relies on a straight forward implementation of the
+ * Gauss-Seidel process.
  *
  * Parallel computations require you to specify an initialized
  * ghost vector in AdditionalData::temp_ghost_vector.
index 7470c06b6cfeae33b3fea2a8ff045c17fc33c20e..75854d9f978447aa3b8f4d91e75bcff652c44ef8 100644 (file)
@@ -230,9 +230,9 @@ DEAL_II_NAMESPACE_OPEN
  * rendering its behavior constant.
  *
  * Further examples of this functionality can be found in the test-suite, such
- * as <code>tests/lac/schur_complement_01.cc</code> . The solution of a multi-
- * component problem (namely step-22) using the schur_complement can be found
- * in <code>tests/lac/schur_complement_03.cc</code> .
+ * as <code>tests/lac/schur_complement_01.cc</code>. The solution of a
+ * multi-component problem (namely step-22) using the schur_complement can be
+ * found in <code>tests/lac/schur_complement_03.cc</code>.
  *
  * @see
  * @ref GlossBlockLA "Block (linear algebra)"
index 939be5052261078530408fe888c21fc32acebe02..72234c8c0559c34d05a1f2778e30e966b8086191 100644 (file)
@@ -164,9 +164,9 @@ namespace internal
  *
  * Note that the minimizing property of GMRes only pertains to the Krylov
  * space spanned by the Arnoldi basis. Therefore, restarted GMRes is
- * <b>not</b> minimizing anymore. The choice of the basis length is a trade-
- * off between memory consumption and convergence speed, since a longer basis
- * means minimization over a larger space.
+ * <b>not</b> minimizing anymore. The choice of the basis length is a
+ * trade-off between memory consumption and convergence speed, since a longer
+ * basis means minimization over a larger space.
  *
  * For the requirements on matrices and vectors in order to work with this
  * class, see the documentation of the Solver base class.
index 373180734be99ff43f1197a8f7b070d275f2dcea..84fb8fed70d0906b6a42c7d6b06c48aadf09e1bf 100644 (file)
@@ -52,9 +52,9 @@ DEAL_II_NAMESPACE_OPEN
  * sparsity pattern of the decomposition is a superset of the sparsity pattern
  * in the original matrix.
  *
- * Such fill-in can be accomplished by various ways, one of which is the copy-
- * constructor of the SparsityPattern class that allows the addition of side-
- * diagonals to a given sparsity structure.
+ * Such fill-in can be accomplished by various ways, one of which is the
+ * copy-constructor of the SparsityPattern class that allows the addition of
+ * side-diagonals to a given sparsity structure.
  *
  *
  * <h3>Unified use of preconditioners</h3>
index 6e75ed57cad3dce4208f9a5b59a599b74a497413..3cdca4765328f00363135e98581fd4a7c7cbfdda 100644 (file)
@@ -113,8 +113,8 @@ public:
 
 
   /**
-   * Apply the transpose of the incomplete decomposition, i.e. do one forward-
-   * backward step $dst=(LU)^{-T}src$.
+   * Apply the transpose of the incomplete decomposition, i.e. do one
+   * forward-backward step $dst=(LU)^{-T}src$.
    *
    * The initialize() function needs to be called before.
    */
index d1400eab4303f1b250c97df956845b9a162df190..5b2091f8ea16eb9885b0abc2e83e1bbcdb470a4d 100644 (file)
@@ -1322,8 +1322,8 @@ public:
    * Return the $l_1$-norm of the matrix, that is $|M|_1=\max_{\mathrm{all\
    * columns\ }j}\sum_{\mathrm{all\ rows\ } i} |M_{ij}|$, (max. sum of
    * columns).  This is the natural matrix norm that is compatible to the
-   * $l_1$-norm for vectors, i.e.  $|Mv|_1\leq |M|_1 |v|_1$. (cf. Haemmerlin-
-   * Hoffmann: Numerische Mathematik)
+   * $l_1$-norm for vectors, i.e.  $|Mv|_1\leq |M|_1 |v|_1$. (cf.
+   * Haemmerlin-Hoffmann: Numerische Mathematik)
    */
   real_type
   l1_norm() const;
index 42ac4910d81b390f8e48dba204d19a1408a66398..e6707ba9bda5a6afc4de24d58535615c5bcac56b 100644 (file)
@@ -108,8 +108,8 @@ public:
   vmult(Vector<somenumber> &dst, const Vector<somenumber> &src) const;
 
   /**
-   * Apply the transpose of the incomplete decomposition, i.e. do one forward-
-   * backward step $dst=(LU)^{-1}src$.
+   * Apply the transpose of the incomplete decomposition, i.e. do one
+   * forward-backward step $dst=(LU)^{-1}src$.
    *
    * Call @p initialize before calling this function.
    *
index 278561a23999d25e71dcf5e9fbbaf46a0c888cdb..4f11daaab2acbb7779878cce6e139e171d9b2fd9 100644 (file)
@@ -377,9 +377,9 @@ private:
  * Splitting the matrix into blocks is always done in a way such that the
  * blocks are not necessarily of equal size, but such that the number of
  * selected degrees of freedom for which a local system is to be solved is
- * equal between blocks. The reason for this strategy to subdivision is load-
- * balancing for multithreading. There are several possibilities to actually
- * split the matrix into blocks, which are selected by the flag @p
+ * equal between blocks. The reason for this strategy to subdivision is
+ * load-balancing for multithreading. There are several possibilities to
+ * actually split the matrix into blocks, which are selected by the flag @p
  * blocking_strategy that is passed to the constructor. By a block, we will in
  * the sequel denote a list of indices of degrees of freedom; the algorithm
  * will work on each block separately, i.e. the solutions of the local systems
index 8cd6c54a3b9aca6cff36ce7f0ea8083fa75b04fd..6e827a57b6d4e0f537be03955ee719e0b5aea835 100644 (file)
@@ -514,8 +514,8 @@ public:
    *
    * This constructs objects intended for the application of the ILU(n)-method
    * or other incomplete decompositions.  Therefore, additional to the
-   * original entry structure, space for <tt>extra_off_diagonals</tt> side-
-   * diagonals is provided on both sides of the main diagonal.
+   * original entry structure, space for <tt>extra_off_diagonals</tt>
+   * side-diagonals is provided on both sides of the main diagonal.
    *
    * <tt>max_per_row</tt> is the maximum number of nonzero elements per row
    * which this structure is to hold. It is assumed that this number is
@@ -524,8 +524,8 @@ public:
    * will usually want to give the same number as you gave for
    * <tt>original</tt> plus the number of side diagonals times two. You may
    * however give a larger value if you wish to add further nonzero entries
-   * for the decomposition based on other criteria than their being on side-
-   * diagonals.
+   * for the decomposition based on other criteria than their being on
+   * side-diagonals.
    *
    * This function requires that <tt>original</tt> refers to a quadratic
    * matrix structure.  It must be compressed. The matrix structure is not
index 3464f83dc9fa222525663204d2b3a859ceeba0ed..92edf5a622f11ceb717eabab70e89b7ea1ac1a37 100644 (file)
@@ -271,9 +271,9 @@ namespace TrilinosWrappers
        * then queried from the input vector. Note that you should not write to
        * the resulting vector any more, since the some data can be stored
        * several times on different processors, leading to unpredictable
-       * results. In particular, such a vector cannot be used for matrix-
-       * vector products as for example done during the solution of linear
-       * systems.
+       * results. In particular, such a vector cannot be used for
+       * matrix-vector products as for example done during the solution of
+       * linear systems.
        */
       void
       import_nonlocal_data_for_fe(const TrilinosWrappers::BlockSparseMatrix &m,
index 37f98f33ff2212eaf840c3aa37f06936ea92a4b2..9be5f75673cda772746d7fa1165e9357b41cf9f9 100644 (file)
@@ -277,9 +277,9 @@ namespace TrilinosWrappers
       /**
        * This specifies the minimum value the diagonal elements should have.
        * This might be necessary when the Jacobi preconditioner is used on
-       * matrices with zero diagonal elements. In that case, a straight-
-       * forward application would not be possible since we would divide by
-       * zero.
+       * matrices with zero diagonal elements. In that case, a
+       * straight-forward application would not be possible since we would
+       * divide by zero.
        */
       double min_diagonal;
 
@@ -339,8 +339,8 @@ namespace TrilinosWrappers
      * setting the parameter <tt>min_diagonal</tt> to a small nonzero value
      * the SOR will work on a matrix that is not too far away from the one we
      * want to treat. Finally, <tt>overlap</tt> governs the overlap of the
-     * partitions when the preconditioner runs in parallel, forming a so-
-     * called additive Schwarz preconditioner.
+     * partitions when the preconditioner runs in parallel, forming a
+     * so-called additive Schwarz preconditioner.
      */
     struct AdditionalData
     {
@@ -364,9 +364,9 @@ namespace TrilinosWrappers
       /**
        * This specifies the minimum value the diagonal elements should have.
        * This might be necessary when the SSOR preconditioner is used on
-       * matrices with zero diagonal elements. In that case, a straight-
-       * forward application would not be possible since we divide by the
-       * diagonal element.
+       * matrices with zero diagonal elements. In that case, a
+       * straight-forward application would not be possible since we divide by
+       * the diagonal element.
        */
       double min_diagonal;
 
@@ -433,8 +433,8 @@ namespace TrilinosWrappers
      * setting the parameter <tt>min_diagonal</tt> to a small nonzero value
      * the SOR will work on a matrix that is not too far away from the one we
      * want to treat. Finally, <tt>overlap</tt> governs the overlap of the
-     * partitions when the preconditioner runs in parallel, forming a so-
-     * called additive Schwarz preconditioner.
+     * partitions when the preconditioner runs in parallel, forming a
+     * so-called additive Schwarz preconditioner.
      */
     struct AdditionalData
     {
@@ -458,9 +458,9 @@ namespace TrilinosWrappers
       /**
        * This specifies the minimum value the diagonal elements should have.
        * This might be necessary when the SOR preconditioner is used on
-       * matrices with zero diagonal elements. In that case, a straight-
-       * forward application would not be possible since we divide by the
-       * diagonal element.
+       * matrices with zero diagonal elements. In that case, a
+       * straight-forward application would not be possible since we divide by
+       * the diagonal element.
        */
       double min_diagonal;
 
@@ -559,9 +559,9 @@ namespace TrilinosWrappers
       /**
        * This specifies the minimum value the diagonal elements should have.
        * This might be necessary when the block Jacobi preconditioner is used
-       * on matrices with zero diagonal elements. In that case, a straight-
-       * forward application would not be possible since we divide by the
-       * diagonal element.
+       * on matrices with zero diagonal elements. In that case, a
+       * straight-forward application would not be possible since we divide by
+       * the diagonal element.
        */
       double min_diagonal;
 
@@ -585,8 +585,8 @@ namespace TrilinosWrappers
 
   /**
    * A wrapper class for a block SSOR preconditioner for Trilinos matrices. As
-   * opposed to PreconditionSSOR where each row is treated separately (point-
-   * wise), this scheme collects block of a given size and inverts a full
+   * opposed to PreconditionSSOR where each row is treated separately
+   * (point-wise), this scheme collects block of a given size and inverts a full
    * matrix for all these rows simultaneously. Trilinos allows to select
    * several strategies for selecting which rows form a block, including
    * "linear" (i.e., divide the local range of the matrix in slices of the
@@ -663,9 +663,9 @@ namespace TrilinosWrappers
       /**
        * This specifies the minimum value the diagonal elements should have.
        * This might be necessary when the SSOR preconditioner is used on
-       * matrices with zero diagonal elements. In that case, a straight-
-       * forward application would not be possible since we divide by the
-       * diagonal element.
+       * matrices with zero diagonal elements. In that case, a
+       * straight-forward application would not be possible since we divide by
+       * the diagonal element.
        */
       double min_diagonal;
 
@@ -774,9 +774,9 @@ namespace TrilinosWrappers
       /**
        * This specifies the minimum value the diagonal elements should have.
        * This might be necessary when the SOR preconditioner is used on
-       * matrices with zero diagonal elements. In that case, a straight-
-       * forward application would not be possible since we divide by the
-       * diagonal element.
+       * matrices with zero diagonal elements. In that case, a
+       * straight-forward application would not be possible since we divide by
+       * the diagonal element.
        */
       double min_diagonal;
 
@@ -1037,8 +1037,8 @@ namespace TrilinosWrappers
    * lets the user specify which elements should be dropped (i.e., should not
    * be part of the incomplete decomposition). Trilinos calculates first the
    * complete factorization for one row, and then skips those elements that
-   * are lower than the threshold. This is the main difference to the non-
-   * thresholded ILU preconditioner, where the parameter <tt>ilut_fill</tt>
+   * are lower than the threshold. This is the main difference to the
+   * non-thresholded ILU preconditioner, where the parameter <tt>ilut_fill</tt>
    * governs the incomplete factorization structure. This parameter is
    * available here as well, but provides only some extra information here.
    *
@@ -1066,8 +1066,8 @@ namespace TrilinosWrappers
   public:
     /**
      * Standardized data struct to pipe additional parameters to the
-     * preconditioner. The Trilinos ILU-T decomposition allows for some fill-
-     * in, so it actually is a threshold incomplete LU factorization. The
+     * preconditioner. The Trilinos ILU-T decomposition allows for some
+     * fill-in, so it actually is a threshold incomplete LU factorization. The
      * amount of fill-in, and hence, the amount of memory used by this
      * preconditioner, is controlled by the parameters <tt>ilut_drop</tt> and
      * <tt>ilut_fill</tt>, which specifies a threshold about which values
@@ -1310,9 +1310,9 @@ namespace TrilinosWrappers
    * processors.
    *
    * For proper functionality of this class we recommend using Trilinos v9.0
-   * and higher. Older versions may have problems with generating the coarse-
-   * matrix structure when using matrices with many nonzero entries per row
-   * (i.e., matrices stemming from higher order finite element
+   * and higher. Older versions may have problems with generating the
+   * coarse-matrix structure when using matrices with many nonzero entries per
+   * row (i.e., matrices stemming from higher order finite element
    * discretizations).
    *
    * @ingroup TrilinosWrappers
@@ -1439,8 +1439,8 @@ namespace TrilinosWrappers
       /**
        * Determines whether the AMG preconditioner should be optimized for
        * elliptic problems (ML option smoothed aggregation SA, using a
-       * Chebyshev smoother) or for non-elliptic problems (ML option non-
-       * symmetric smoothed aggregation NSSA, smoother is SSOR with
+       * Chebyshev smoother) or for non-elliptic problems (ML option
+       * non-symmetric smoothed aggregation NSSA, smoother is SSOR with
        * underrelaxation).
        */
       bool elliptic;
@@ -1733,8 +1733,8 @@ namespace TrilinosWrappers
       /**
        * Determines whether the AMG preconditioner should be optimized for
        * elliptic problems (MueLu option smoothed aggregation SA, using a
-       * Chebyshev smoother) or for non-elliptic problems (MueLu option non-
-       * symmetric smoothed aggregation NSSA, smoother is SSOR with
+       * Chebyshev smoother) or for non-elliptic problems (MueLu option
+       * non-symmetric smoothed aggregation NSSA, smoother is SSOR with
        * underrelaxation).
        */
       bool elliptic;
index b74256504f818136b83622c12ddd93a4ab1bc92a..777ead8f2f44de4f612aa799e1deb86bee32883a 100644 (file)
@@ -747,9 +747,9 @@ namespace TrilinosWrappers
      * actual matrix structure has more nonzero entries than specified in the
      * constructor. However it is still advantageous to provide good estimates
      * here since this will considerably increase the performance of the
-     * matrix setup. However, there is no effect in the performance of matrix-
-     * vector products, since Trilinos reorganizes the matrix memory prior to
-     * use (in the compress() step).
+     * matrix setup. However, there is no effect in the performance of
+     * matrix-vector products, since Trilinos reorganizes the matrix memory
+     * prior to use (in the compress() step).
      */
     SparseMatrix(const IndexSet    &parallel_partitioning,
                  const MPI_Comm     communicator          = MPI_COMM_WORLD,
@@ -1029,9 +1029,9 @@ namespace TrilinosWrappers
      * </ul>
      *
      * In both cases, this function compresses the data structures and allows
-     * the resulting matrix to be used in all other operations like matrix-
-     * vector products. This is a collective operation, i.e., it needs to be
-     * run on all processors when used in %parallel.
+     * the resulting matrix to be used in all other operations like
+     * matrix-vector products. This is a collective operation, i.e., it needs to
+     * be run on all processors when used in %parallel.
      *
      * See
      * @ref GlossCompress "Compressing distributed objects"
@@ -1712,9 +1712,9 @@ namespace TrilinosWrappers
      * that all elements of one row are accessed before the elements of the
      * next row. If your algorithm relies on visiting elements within one row,
      * you will need to consult with the Trilinos documentation on the order
-     * in which it stores data. It is, however, generally not a good and long-
-     * term stable idea to rely on the order in which receive elements if you
-     * iterate over them.
+     * in which it stores data. It is, however, generally not a good and
+     * long-term stable idea to rely on the order in which receive elements if
+     * you iterate over them.
      *
      * When you iterate over the elements of a parallel matrix, you will only
      * be able to access the locally owned rows. (You can access the other
@@ -1758,9 +1758,9 @@ namespace TrilinosWrappers
      * that all elements of one row are accessed before the elements of the
      * next row. If your algorithm relies on visiting elements within one row,
      * you will need to consult with the Trilinos documentation on the order
-     * in which it stores data. It is, however, generally not a good and long-
-     * term stable idea to rely on the order in which receive elements if you
-     * iterate over them.
+     * in which it stores data. It is, however, generally not a good and
+     * long-term stable idea to rely on the order in which receive elements if
+     * you iterate over them.
      *
      * @note When you access the elements of a parallel matrix, you can only
      * access the elements of rows that are actually stored locally. (You can
@@ -1946,8 +1946,8 @@ namespace TrilinosWrappers
     std::unique_ptr<Epetra_FECrsMatrix> matrix;
 
     /**
-     * A sparse matrix object in Trilinos to be used for collecting the non-
-     * local elements if the matrix was constructed from a Trilinos sparsity
+     * A sparse matrix object in Trilinos to be used for collecting the
+     * non-local elements if the matrix was constructed from a Trilinos sparsity
      * pattern with the respective option.
      */
     std::unique_ptr<Epetra_CrsMatrix> nonlocal_matrix;
index 82c4b88544cdca249c5dd601ae64b1e7ed97ba7f..b29175d374dbadf352bfd2a58fb81a28c66a06a8 100644 (file)
@@ -487,8 +487,8 @@ namespace TrilinosWrappers
                     const std::vector<size_type> &n_entries_per_row);
 
     /**
-     * This constructor constructs general sparsity patterns, possible non-
-     * square ones. Constructing a sparsity pattern this way allows the user
+     * This constructor constructs general sparsity patterns, possible
+     * non-square ones. Constructing a sparsity pattern this way allows the user
      * to explicitly specify the rows into which we are going to add elements.
      * This set is required to be a superset of the first index set @p
      * row_parallel_partitioning that includes also rows that are owned by
@@ -576,8 +576,8 @@ namespace TrilinosWrappers
            const size_type n_entries_per_row = 0);
 
     /**
-     * This reinit function is used to specify general matrices, possibly non-
-     * square ones. In addition to the arguments of the other reinit method
+     * This reinit function is used to specify general matrices, possibly
+     * non-square ones. In addition to the arguments of the other reinit method
      * above, it allows the user to explicitly specify the rows into which we
      * are going to add elements. This set is a superset of the first index
      * set @p row_parallel_partitioning that includes also rows that are owned
@@ -805,8 +805,8 @@ namespace TrilinosWrappers
     /**
      * Return a const reference to the underlying Trilinos Epetra_Map that
      * sets the partitioning of the range space of this sparsity pattern,
-     * i.e., the partitioning of the vectors that are result from matrix-
-     * vector products.
+     * i.e., the partitioning of the vectors that are result from
+     * matrix-vector products.
      */
     const Epetra_Map &
     range_partitioner() const;
index ce036af8650e5f1c8dca42a665a415c8065a0ed1..20347cc1b405886794b1ddd89fda1554af0541a6 100644 (file)
@@ -710,9 +710,9 @@ namespace TrilinosWrappers
        * then queried from the input vector. Note that you should not write to
        * the resulting vector any more, since the some data can be stored
        * several times on different processors, leading to unpredictable
-       * results. In particular, such a vector cannot be used for matrix-
-       * vector products as for example done during the solution of linear
-       * systems.
+       * results. In particular, such a vector cannot be used for
+       * matrix-vector products as for example done during the solution of
+       * linear systems.
        */
       void
       import_nonlocal_data_for_fe(
@@ -1169,10 +1169,10 @@ namespace TrilinosWrappers
        * then it is possible to add data from a vector that uses a different
        * map, i.e., a vector whose elements are split across processors
        * differently. This may include vectors with ghost elements, for example.
-       * In general, however, adding vectors with a different element-to-
-       * processor map requires communicating data among processors and,
-       * consequently, is a slower operation than when using vectors using the
-       * same map.
+       * In general, however, adding vectors with a different
+       * element-to-processor map requires communicating data among processors
+       * and, consequently, is a slower operation than when using vectors using
+       * the same map.
        */
       void
       add(const Vector &V, const bool allow_different_maps = false);
index dc078dc1ce9dffa9d87090916fb2e03ed618dca3..42695cc5a11740b3d4c446237745f067aa9b7467 100644 (file)
@@ -159,8 +159,8 @@ namespace internal
       clear();
 
       /**
-       * Return the FE index for a given finite element degree. If not in hp-
-       * mode, this function always returns index 0. If an index is not found
+       * Return the FE index for a given finite element degree. If not in
+       * hp-mode, this function always returns index 0. If an index is not found
        * in hp-mode, it returns numbers::invalid_unsigned_int.
        */
       unsigned int
@@ -710,8 +710,8 @@ namespace internal
       std::vector<unsigned int> cell_active_fe_index;
 
       /**
-       * Stores the maximum degree of different finite elements for the hp-
-       * case.
+       * Stores the maximum degree of different finite elements for the
+       * hp-case.
        */
       unsigned int max_fe_index;
 
index 061eb3c0bcf2b68abed09e3770712631e66a761d..c23f9a88e9265fc13ca8448281271c51b5c04abf 100644 (file)
@@ -323,8 +323,8 @@ public:
    * Return a read-only pointer to the first field of function hessians on
    * quadrature points. First comes the xx-component of the hessian for the
    * first component on all quadrature points, then the yy-component,
-   * zz-component in (3d), then the xy-component, and so on. Next comes the xx-
-   * component of the second component, and so on. This is related to the
+   * zz-component in (3d), then the xy-component, and so on. Next comes the
+   * xx-component of the second component, and so on. This is related to the
    * internal data structures used in this class. The raw data after a call to
    * @p evaluate only contains unit cell operations, so possible
    * transformations, quadrature weights etc. must be applied manually. In
index e8f96b1897cc5c847ec1247427c950992313f046..ab504b1a0d4eb608c896b13f2e4d5c1981debd80 100644 (file)
@@ -240,8 +240,8 @@ namespace internal
       AlignedVector<Number> shape_values_eo;
 
       /**
-       * Stores the shape gradients in a different format, namely the so-
-       * called even-odd scheme where the symmetries in shape_gradients are
+       * Stores the shape gradients in a different format, namely the
+       * so-called even-odd scheme where the symmetries in shape_gradients are
        * used for faster evaluation.
        */
       AlignedVector<Number> shape_gradients_eo;
@@ -417,8 +417,8 @@ namespace internal
        * Initializes the data fields. Takes a one-dimensional quadrature
        * formula and a finite element as arguments and evaluates the shape
        * functions, gradients and Hessians on the one-dimensional unit cell.
-       * This function assumes that the finite element is derived from a one-
-       * dimensional element by a tensor product and that the zeroth shape
+       * This function assumes that the finite element is derived from a
+       * one-dimensional element by a tensor product and that the zeroth shape
        * function in zero evaluates to one.
        */
       template <int dim, int spacedim, int dim_q>
index cfa37f6181242f8146f3f795276f0180196dbce6..63da93a13d913b52dd8ed77b098161edec5e02f0 100644 (file)
@@ -269,11 +269,11 @@ namespace internal
        *
        * The strategy is based on a two-level approach. The outer level is
        * subdivided into partitions similar to the type of neighbors in
-       * Cuthill-McKee, and the inner level is again subdivided into Cuthill-
-       * McKee-like partitions (partitions whose level differs by more than 2
-       * can be worked on independently). One task is represented by a chunk
-       * of cells. The cell chunks are formed after subdivision into the two
-       * levels of partitions.
+       * Cuthill-McKee, and the inner level is again subdivided into
+       * Cuthill-McKee-like partitions (partitions whose level differs by more
+       * than 2 can be worked on independently). One task is represented by a
+       * chunk of cells. The cell chunks are formed after subdivision into the
+       * two levels of partitions.
        *
        * @param cell_active_fe_index The active FE index corresponding to the
        * individual indices in the list of all cell indices, in order to be
index 9e8f7a36642fec139e92ab97143f1b77ae094b68..8832ec3809d273f247b6a46df0e594738e21e2cb 100644 (file)
@@ -1845,10 +1845,9 @@ namespace internal
    *                            is performed. This is a typical scenario in
    *                            FEFaceEvaluation::evaluate() calls. If false,
    *                            data from n_rows^(dim-1) points is expanded
-   *                            into the n_rows^dim points of the higher-
-   *                            dimensional data array. Derivatives in the
-   *                            case contract_onto_face==false are summed
-   *                            together.
+   *                            into the n_rows^dim points of the
+   *                            higher-dimensional data array. Derivatives in
+   * the case contract_onto_face==false are summed together.
    * @tparam add If true, the result is added to the output vector, else
    *             the computed values overwrite the content in the output.
    * @tparam max_derivative Sets the number of derivatives that should be
index 0baab792079bf27a02ba682375282f751bad9fe6..f3b0098b29154f94711b3573525d028026a4d2c2 100644 (file)
@@ -1462,8 +1462,8 @@ namespace MeshWorker
     hp::QCollection<dim - 1> face_quadrature_collection;
 
     /**
-     * Boolean indicating whether or not the current ScratchData has hp-
-     * capabilities.
+     * Boolean indicating whether or not the current ScratchData has
+     * hp-capabilities.
      */
     bool hp_capability_enabled;
 
index 1777d46efb48321d232ea0f9e4e06259a6de535e..01805e012ee096dd6649b19ae740bc605b6ca8a2 100644 (file)
@@ -502,8 +502,8 @@ class PreconditionMG : public Subscriptor
 {
 public:
   /**
-   * Constructor. Arguments are the multigrid object, pre-smoother, post-
-   * smoother and coarse grid solver.
+   * Constructor. Arguments are the multigrid object, pre-smoother,
+   * post-smoother and coarse grid solver.
    */
   PreconditionMG(const DoFHandler<dim> &dof_handler,
                  Multigrid<VectorType> &mg,
index c9b54e453352197009bbf079b497b35d0c58d77a..d7763643a9baad1a56692110010738835d7f1cb1 100644 (file)
@@ -247,9 +247,9 @@ public:
    * tri)quadratic elements, then what is written into the output file is just
    * a (bi-, tri)linear interpolation onto the current mesh, i.e., only the
    * values at the vertices. If this is not good enough, you can, for example,
-   * specify @p n_subdivisions equal to 2 to plot the solution on a once-
-   * refined mesh, or if set to 3, on a mesh where each cell is represented by
-   * 3-by-3 patches. On each of these smaller patches, given the limitations
+   * specify @p n_subdivisions equal to 2 to plot the solution on a
+   * once-refined mesh, or if set to 3, on a mesh where each cell is represented
+   * by 3-by-3 patches. On each of these smaller patches, given the limitations
    * of output formats, the data is still linearly interpolated, but a linear
    * interpolation of quadratic data on a finer mesh is still a better
    * representation of the actual quadratic surface than on the original mesh.
index 7cc1f9eef12b84a0dc0c2a0165baa78b7a06b41b..d258312483378e661d969c6199c69451d2f4e547 100644 (file)
@@ -89,8 +89,8 @@ namespace internal
  * The one coordinate in the triangulation used by the DoFHandler object
  * passed to this class is taken as the radial variable, and the output will
  * then be either a circle or a ring domain. It is in the user's
- * responsibility to assure that the radial coordinate only attains non-
- * negative values.
+ * responsibility to assure that the radial coordinate only attains
+ * non-negative values.
  *
  *
  * <h3>Details for 2d computations</h3>
index d8a2612d3c3c006f405ead186b660c9d72bf0729..d93cdccf6c43b9cabbb8b411f043214d779b8ebf 100644 (file)
@@ -51,8 +51,8 @@ class DoFHandler;
  * We will explain the concept for a time dependent problem, but instead of
  * the time any parameter can be substituted. In our example, a solution of an
  * equation is computed for each discrete time level. This is then added to an
- * object of the present class and after all time levels are added, a space-
- * time plot will be written in any of the output formats supported by the
+ * object of the present class and after all time levels are added, a
+ * space-time plot will be written in any of the output formats supported by the
  * base class. Upon output, the (spatial) solution on each time level is
  * extended into the time direction by writing it twice, once for the time
  * level itself and once for a time equal to the time level minus a given time
index 142501836c9c98cae249a0778fcd1665405bc650..0de2802b8e62219aff738651870ecc5d76299e8a 100644 (file)
@@ -191,8 +191,8 @@ namespace hp
  * contribution of the face $F\in\partial K$ looks like \f[ n_F\int_F
  * \left|g-a\frac{\partial u_h}{\partial n}\right|^2 ds \f] where $g$ is the
  * Neumann boundary function, $n_F=\frac {h_K}{24}$ and $n_F=\frac {h_F}{p}$ for
- * the Kelly and hp-estimator, respectively. If the finite element is vector-
- * valued, then obviously the function denoting the Neumann boundary
+ * the Kelly and hp-estimator, respectively. If the finite element is
+ * vector-valued, then obviously the function denoting the Neumann boundary
  * conditions needs to be vector-valued as well.
  *
  * <li> No other boundary conditions are considered.
index 0f0fdaeebbdbc6c3c66d454333809690740c1317..42b105f1717ca0fe43f92600239551a86e8e6052 100644 (file)
@@ -194,8 +194,8 @@ namespace internal
 
     /**
      * Resize the arrays so that they fit the number of quadrature points
-     * associated with the given finite element index into the hp-
-     * collections.
+     * associated with the given finite element index into the
+     * hp-collections.
      */
     void
     resize(const unsigned int active_fe_index);
index a67d82c6fd44759a4c9ce3339a943535f6eefa11..5e90cbfc7b1151836a1682b2a8593bd035ef94ad 100644 (file)
@@ -255,8 +255,8 @@ namespace TrilinosWrappers
  * find difficulties: when we eliminate a degree of freedom, we delete the row
  * and column of this unknown, and set the diagonal entry to some positive
  * value. To make the problem more or less well-conditioned, we set this
- * diagonal entry to the absolute value of its prior value if that was non-
- * zero, or to the average magnitude of all other nonzero diagonal elements.
+ * diagonal entry to the absolute value of its prior value if that was
+ * non-zero, or to the average magnitude of all other nonzero diagonal elements.
  * Then we set the right hand side value such that the resulting solution
  * entry has the right value as given by the boundary values. Since we add
  * these contributions up over all local contributions, the diagonal entry and
index 981fa0d278a9b9ca76c31c17c6f4659a748adb92..ad2a4bd729f686ac2a509880119cade5d3191091 100644 (file)
@@ -577,8 +577,8 @@ namespace VectorTools
   /**
    * This function is an updated version of the
    * project_boundary_values_curl_conforming function. The intention is to fix
-   * a problem when using the previous function in conjunction with non-
-   * rectangular geometries (i.e. elements with non-rectangular faces). The
+   * a problem when using the previous function in conjunction with
+   * non-rectangular geometries (i.e. elements with non-rectangular faces). The
    * L2-projection method used has been taken from the paper "Electromagnetic
    * scattering simulation using an H (curl) conforming hp-finite element
    * method in three dimensions" by PD Ledger, K Morgan and O Hassan ( Int. J.
@@ -592,9 +592,9 @@ namespace VectorTools
    * <h4>Computing constraints</h4>
    *
    * To compute the constraints we use a projection method based upon the
-   * paper mentioned above. In 2d this is done in a single stage for the edge-
-   * based shape functions, regardless of the order of the finite element. In
-   * 3d this is done in two stages, edges first and then faces.
+   * paper mentioned above. In 2d this is done in a single stage for the
+   * edge-based shape functions, regardless of the order of the finite element.
+   * In 3d this is done in two stages, edges first and then faces.
    *
    * For each cell, each edge, $e$, is projected by solving the linear system
    * $Ax=b$ where $x$ is the vector of constraints on degrees of freedom on the

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.