]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Fix more typos. 6383/head
authorDavid Wells <wellsd2@rpi.edu>
Sun, 29 Apr 2018 01:26:34 +0000 (21:26 -0400)
committerDavid Wells <wellsd2@rpi.edu>
Sun, 29 Apr 2018 01:26:34 +0000 (21:26 -0400)
Work was done by codespell and the (newly fixed) double_word_typos.py script.

33 files changed:
contrib/utilities/double_word_typos.py
doc/doxygen/headers/manifold.h
doc/doxygen/headers/matrixfree.h
examples/step-1/step-1.cc
examples/step-17/doc/intro.dox
examples/step-25/doc/intro.dox
examples/step-25/step-25.cc
examples/step-32/step-32.cc
examples/step-33/doc/intro.dox
examples/step-34/doc/intro.dox
examples/step-35/doc/results.dox
examples/step-36/step-36.cc
examples/step-42/step-42.cc
examples/step-9/step-9.cc
include/deal.II/base/function_lib.h
include/deal.II/base/parameter_handler.h
include/deal.II/base/symmetric_tensor.h
include/deal.II/base/symmetric_tensor.templates.h
include/deal.II/dofs/dof_tools.h
include/deal.II/fe/fe_system.h
include/deal.II/grid/grid_generator.h
include/deal.II/grid/manifold_lib.h
include/deal.II/grid/tria_accessor.h
include/deal.II/lac/lapack_templates.h
include/deal.II/lac/scalapack.templates.h
include/deal.II/lac/trilinos_epetra_vector.h
include/deal.II/matrix_free/evaluation_selector.h
include/deal.II/matrix_free/fe_evaluation.h
include/deal.II/matrix_free/mapping_info.h
include/deal.II/matrix_free/operators.h
include/deal.II/numerics/solution_transfer.h
include/deal.II/numerics/vector_tools.templates.h
include/deal.II/physics/elasticity/standard_tensors.h

index 444bae2fc4eea3e224b7b87cb980fcffbe29dc86..ef60293b9bd425b53e1b8d4866c76ba5360db74f 100644 (file)
@@ -41,7 +41,7 @@ import sys
 SKIP = ["//", "*", "}", "|", "};", ">", "\"", "|", "/",
         "numbers::invalid_unsigned_int,", "std::string,", "int,"]
 
-with open(sys.argv[1], 'r') as handle:
+with open(sys.argv[1], 'r', encoding='utf-8') as handle:
     previous_line = ""
     for line_n, line in enumerate(handle):
         line = line.strip()
@@ -53,13 +53,15 @@ with open(sys.argv[1], 'r') as handle:
             continue
         if words[0] in ["*", "//"]:
             words = words[1:]
+        if len(words) == 0:
+            continue
 
         # See if the last word on the previous line is equal to the first word
         # on the current line.
         if len(previous_words) != 0:
             if words[0] not in SKIP and previous_words[-1] == words[0]:
-                print(sys.argv[1] + ":{}: {}".format(line_n + 1, previous_line))
-                print(sys.argv[1] + ":{}: {}".format(line_n + 2, line))
+                print(sys.argv[1] + ":{}: {}".format(line_n, previous_line))
+                print(sys.argv[1] + ":{}: {}".format(line_n + 1, line))
         previous_line = line
 
         for left_word, right_word in zip(words[:-1], words[1:]):
index 41c1564eed58ca0712cc7c2967dce98ded58dcfa..2d45f750136544c669dda70bbe82dcecbc4a11bf 100644 (file)
  *                              10);
  *  // again disable all manifolds for demonstration purposes
  *  triangulation.reset_all_manifolds();
- *  // reenable the
+ *  // reenable the manifold:
  *  triangulation.set_all_manifold_ids(0);
  *  triangulation.set_manifold (0, manifold);
  *  triangulation.refine_global (3);
index 2ef70972e52157aa8e40c01fc948082fb3d3dd59..054c4759f581e4ed78655a6bfc1e0b45d5931c32 100644 (file)
@@ -61,7 +61,7 @@
  * library uses SIMD vectorization and highly optimized kernels based on
  * templates of the polynomial degree to achieve this goal. To give a
  * perspective, a sparse matrix-vector product for quadratic elements FE_Q
- * used to be equally fast as the matrix-free implementation on procesors
+ * used to be equally fast as the matrix-free implementation on processors
  * designed around 2005-2007 (e.g. Pentium 4 or AMD Opteron Barcelona
  * with 2-4 cores per chip). By 2018, the matrix-free evaluation is around
  * eight times as fast (measured on Intel Skylake Server, 14 cores).
  * found. In this case, we also do not look for opportunities to find the same
  * pattern on more than one cell, even though such cases might exist such as
  * for extruded meshes. This search operation, which is based on inserting
- * data into an `std::map` using a custom floating point comparator
+ * data into a `std::map` using a custom floating point comparator
  * `FPArrayComparator`, is efficient enough when a single data field per cell
  * is used. However, it would be pretty expensive if done for all quadrature
  * points of all cells (with many different cases).
  * two components can be easily held apart. What makes the code a bit awkward
  * to read is the fact that we need to batch several objects together from the
  * original scalar evaluation done in an FEValues object, that we need to
- * identify data fields that are repetitive, and that we need to fine the
- * compression over several cells throught an `std::map` for the Cartesian and
+ * identify data fields that are repetitive, and that we need to define the
+ * compression over several cells with a `std::map` for the Cartesian and
  * affine cases.
  *
  * The data computation part of MappingInfo is parallelized by tasks besides
index fdad49228965dcbe41d3818fa38f9361b98e2e51..40579afe01f7b70b72fe1880bbfe9abaca2acc9d 100644 (file)
@@ -147,8 +147,8 @@ void second_grid ()
   for (unsigned int step=0; step<5; ++step)
     {
       // Next, we need to loop over the active cells of the triangulation. You
-      // can think of a triangulation as a collection of cells. If it was an
-      // an array, you would just get a pointer that you increment from one
+      // can think of a triangulation as a collection of cells. If it were an
+      // array, you would just get a pointer that you increment from one
       // element to the next using the operator `++`. The cells of a
       // triangulation aren't stored as a simple array, but the concept of an
       // <i>iterator</i> generalizes how pointers work to arbitrary collections
index f6f146aee58723fce4efd8acfd4929c3c6b4561b..4db26fa5e89aca807da23ecddd34c0a18b7c88ee 100644 (file)
@@ -159,7 +159,7 @@ processors.
 different processors run through different blocks of code in their
 copy of the executable. Programs internally also often communicate
 in other ways than through collectives. But in practice, %parallel finite
-finite element codes almost always follow the scheme where every copy
+element codes almost always follow the scheme where every copy
 of the program runs through the same blocks of code at the same time,
 interspersed by phases where all processors communicate with each other.)
 
@@ -193,4 +193,3 @@ The techniques this program then demonstrates are:
 
 Since all this can only be demonstrated using actual code, let us go straight to the
 code without much further ado.
-
index f1a5761816e6e47b872aa14e1c9b2c4d0904a034..7a725178ae0b82988a5c424876b97bdb3f0ab512 100644 (file)
@@ -64,7 +64,7 @@ formulation. To this end, by setting $v = u_t$, it is easy to see that the sine-
 \f}
 
 <h3>Discretization of the equations in time</h3>
-Now, we can discretize the split formulation in time using the the
+Now, we can discretize the split formulation in time using the
 $\theta$-method, which has a stencil of only two time steps. By
 choosing a $\theta\in [0,1]$, the latter discretization allows us to
 choose from a continuum of schemes. In particular, if we pick
index b63edf7b1a029253a8608f61a889e2f63d7792ef..1ad752881e21ccd2bd7aa943aeb87c84782fc9af 100644 (file)
@@ -616,7 +616,7 @@ namespace Step25
     }
 
     // For completeness, we output the zeroth time step to a file just like
-    // any other other time step.
+    // any other time step.
     output_results (0);
 
     // Now we perform the time stepping: at every time step we solve the
index efe404337c84e8e13156db5514b743dabe835696..b30614739ce8cbfe0791e390aa50b2a8330daf00 100644 (file)
@@ -1974,7 +1974,7 @@ namespace Step32
   //
   // In this function as well as many below, we measure how much time
   // we spend here and collect that in a section called "Setup dof
-  // systems" across function invokations. This is done using an
+  // systems" across function invocations. This is done using an
   // TimerOutput::Scope object that gets a timer going in the section
   // with above name of the `computing_timer` object upon construction
   // of the local variable; the timer is stopped again when the
index 440f4ed72bb3c7b04f1aa22ea43e04490b995c90..13001144caaceea800bc288b348703c01346c8fb 100644 (file)
@@ -365,7 +365,6 @@ correctly done, and consequently nothing in the <code>ConservationLaw</code>
 would have to be modified.
 
 Similarly, if we wanted to improve on the linear or nonlinear solvers, or on
-the time stepping scheme (as hinted at at the end of the <a
+the time stepping scheme (as hinted at the end of the <a
 href="#Results">results section</a>), then this would not require changes in
 the <code>EulerEquations</code> at all.
-
index c3c135c1d2842438bb09200f54eb7d7842b0a553..30d2491375c5b10fd64d2dd6e1f85ed52f72d2f2 100644 (file)
@@ -312,7 +312,7 @@ the velocity as $\mathbf{\tilde v}=\nabla \phi$.
 
 Notice that the evaluation of the above formula for $\mathbf{x} \in
 \Omega$ should yield zero as a result, since the integration of the
-the Dirac delta $\delta(\mathbf{x})$ in the domain
+Dirac delta $\delta(\mathbf{x})$ in the domain
 $\mathbb{R}^n\backslash\Omega$ is always zero by definition.
 
 As a final test, let us verify that this velocity indeed satisfies the
index 88a21e0e361547af9fe6faa810624259fe4ea6f2..9ad0f9436b8495e0b81a8d21d5f665c6300b05dc 100644 (file)
@@ -54,7 +54,7 @@ same directory as the source:
 Since the <code>verbose</code> parameter is set to <code>false</code>,
 we do not get any kind of output besides the number of the time step
 the program is currently working on.
-If we we were to set it to <code>true</code> we would get information on what the program is doing and
+If we were to set it to <code>true</code> we would get information on what the program is doing and
 how many steps each iterative process had to make to converge, etc.
 
 Let us plot the obtained results for $t=1,5,12,20,25$ (i.e. time steps
index 31496e3794dd39bb97453d78de6becdbcc6f552b..0f7b763b33de4028c6152f158e4d1c5672f573dd 100644 (file)
@@ -201,7 +201,7 @@ namespace Step36
     // is initialized using an IndexSet. IndexSet is used not only to resize the
     // PETScWrappers::MPI::Vector but it also associates an index in the
     // PETScWrappers::MPI::Vector with a degree of freedom (see step-40 for a
-    // more detailed explanation). The function complete_index_set() creates
+    // more detailed explanation). The function complete_index_set() creates
     // an IndexSet where every valid index is part of the set. Note that this
     // program can only be run sequentially and will throw an exception if used
     // in parallel.
index f888604a88db7fa3fa2f584b8f5d344ef20edb3d..c85bc0621a7946c94b428c18b6a8e3a8828ceac2 100644 (file)
@@ -1142,7 +1142,7 @@ namespace Step42
   // element with a set of interpolation points derived from the same quadrature
   // formula. The remainder of the function is relatively straightforward: we
   // put the resulting matrix into the given argument; because we know the
-  // matrix is diagonal, it is sufficient to have a loop over only $i$ not
+  // matrix is diagonal, it is sufficient to have a loop over only $i$ and
   // not over $j$. Strictly speaking, we could even avoid multiplying the
   // shape function's values at quadrature point <code>q_point</code> by itself
   // because we know the shape value to be a vector with exactly one one which
@@ -1629,10 +1629,9 @@ namespace Step42
   //   will have an inhomogeneity and will look like $x_0 = x_1/2 + \text{gap}/2$.
   //   So the corresponding entries in the
   //   ride-hang-side are non-zero with a
-  //   meaningless value. These values we have to
-  //   to set to zero.
+  //   meaningless value. These values we have to set to zero.
   // - Like in step-40, we need to shuffle between vectors that do and do
-  //   do not have ghost elements when solving or using the solution.
+  //   not have ghost elements when solving or using the solution.
   //
   // The rest of the function is similar to step-40 and
   // step-41 except that we use a BiCGStab solver
index 349f7b5a473c1dcff946b09adb465312d70cc658..56e999e78e5a6a635763bc9a3d07ca0fdda64e84 100644 (file)
@@ -1094,7 +1094,7 @@ namespace Step9
     // deal.II). Alternatively, the neighbor could be on the same level
     // and be further refined; then we have to find which of its children
     // are next to the present cell and select these (note that if a child
-    // of of neighbor of an active cell that is next to this active cell,
+    // of a neighbor of an active cell that is next to this active cell,
     // needs necessarily be active itself, due to the one-refinement rule
     // cited above).
     //
index 5ad7b72d87bff15ae6a8dc1ff93272c29c06345c..3cbb582fc5cc4501fa52a26cddc429ffb4832d49 100644 (file)
@@ -943,7 +943,6 @@ namespace Functions
   public:
     /**
      * Constructor. Arguments are the center of the ball and its radius.
-     * radius.
      *
      * If an argument <tt>select</tt> is given, the cut-off function will be
      * non-zero for this component only.
@@ -990,7 +989,6 @@ namespace Functions
   public:
     /**
      * Constructor. Arguments are the center of the ball and its radius.
-     * radius.
      *
      * If an argument <tt>select</tt> is given, the cut-off function will be
      * non-zero for this component only.
index e7e1451684c1772fc3eec17b99afa7cc50b7339d..a1e8b5681ae41452946c08b300bb8c2156042b4a 100644 (file)
@@ -717,7 +717,7 @@ class MultipleParameterLoop;
  * parameter; initially, the content of the file equals the default value of
  * the parameter.
  * - <code>default_value</code>: The content of this file is the default value
- * value of the parameter.
+ * of the parameter.
  * - <code>pattern</code>: A textual representation of the pattern that
  * describes the parameter's possible values.
  * - <code>pattern_index</code>: A number that indexes the Patterns::PatternBase
@@ -1404,7 +1404,7 @@ public:
                   "> of file <" << arg2 << ">: " << arg3);
 
   /**
-   * Exception for an an entry in a parameter file that does not match the
+   * Exception for an entry in a parameter file that does not match the
    * provided pattern. The arguments are, in order, the line number, file
    * name, entry value, entry name, and a description of the pattern.
    */
index d9611b895ba4989064c52f591ca7df4ff9a16d0e..092c31382fe925f059c533b18d4d1d31e3a858c6 100644 (file)
@@ -3028,7 +3028,7 @@ namespace internal
 
       /**
        * A struct that is used to sort arrays of pairs of eign=envalues and
-       * eigenvectors. Sorting is performed in in descending order of eigenvalue.
+       * eigenvectors. Sorting is performed in descending order of eigenvalue.
        */
       template <int dim, typename Number>
       struct SortEigenValuesVectors
index 5d38eadbb29face0f438b1ea4548384dab3798c6..5d07ca1212c4dd48a27118cfcf14e13d2a7bf6f6 100644 (file)
@@ -850,7 +850,7 @@ eigenvectors (const SymmetricTensor<2,dim,Number>         &T,
           // described by an Ogden-type model (i.e. using an eigen-decomposition of the right
           // Cauchy-Green tensor). Using this comparison between the well-understood result expected
           // from the Neo-Hookean model and its Ogden equivalent, these parameters are a first
-          // approximation to those required to collectively minimise error in the energy values,
+          // approximation to those required to collectively minimize error in the energy values,
           // first and second derivatives. What's apparent is that all AD numbers and
           // eigen-decomposition algorithms are not made equal!
           double sf = 1.0;
index b0c0b319204ffcfe47115640efc2be5ece73c022..aaa5a6be11625527948612e5c445f2d394e7eed4 100644 (file)
@@ -1100,7 +1100,7 @@ namespace DoFTools
    * and any combination of that...
    * @endcode
    *
-   * Optionally a matrix @p matrix along with an std::vector @p
+   * Optionally a matrix @p matrix along with a std::vector @p
    * first_vector_components can be specified that describes how DoFs on @p
    * face_1 should be modified prior to constraining to the DoFs of @p face_2.
    * Here, two declarations are possible: If the std::vector @p
index 836e7680163c76d18220db8f4d2fe86bde0cc0f9..db753852f4d9759e2f7bf564f846566f244d7f6a 100644 (file)
@@ -840,8 +840,8 @@ public:
    * Return whether this element implements its hanging node constraints in
    * the new way, which has to be used to make elements "hp compatible".
    *
-   * This function returns @p true iff all its base elements return @p true
-   * for this function.
+   * This function returns @p true if and only if all its base elements return
+   * @p true for this function.
    */
   virtual bool hp_constraints_are_implemented () const;
 
index 0a368a3229fba4ab3cb206fa4f76c0cf18154d66..1fc82fb2c0b7b065993c6fca658aa8ec75191410 100644 (file)
@@ -44,7 +44,7 @@ DEAL_II_NAMESPACE_OPEN
  * receive a different
  * @ref GlossManifoldIndicator "manifold indicator",
  * and the correct Manifold descriptor will be attached to
- * the Triangulation. Notice that if you later tranform the
+ * the Triangulation. Notice that if you later transform the
  * triangulation, you have to make sure you attach the correct new Manifold
  * to the triangulation.
  *
index e2679fa140a482e5e807c22ebabfd859cff5c217..6a0f3e18407d9630361c13d66e4852f986178940 100644 (file)
@@ -604,12 +604,12 @@ private:
   const bool owns_pointers;
 
   /**
-   * The expresssion used to construct the push_forward function.
+   * The expression used to construct the push_forward function.
    */
   const std::string push_forward_expression;
 
   /**
-   * The expresssion used to construct the pull_back function.
+   * The expression used to construct the pull_back function.
    */
   const std::string pull_back_expression;
 
index 7846428484815898d756ca63b6be60370e834ae2..89e5199380d9aae5d5ae02c5513f87cbdddc9998 100644 (file)
@@ -959,7 +959,7 @@ public:
    * correct function in the results section of step-49.
    *
    * @warning You should never set the boundary indicator of an interior face
-   * (a face not at the boundary of the domain), or set set the boundary
+   * (a face not at the boundary of the domain), or set the boundary
    * indicator of an exterior face to numbers::internal_face_boundary_id (this
    * value is reserved for another purpose). Algorithms may not work or
    * produce very confusing results if boundary cells have a boundary
index 8606ce83ebc5f0da62b6a97a7132afca5fd0ce38..216e7d63f41361577545e3eed0439ea5f4296d6a 100644 (file)
@@ -1408,7 +1408,7 @@ syevr(const char *jobz,
   /*
    * Netlib and Atlas Lapack perform floating point tests (e.g. divide-by-zero) within the call to dsyevr
    * causing floating point exceptions to be thrown (at least in debug mode). Therefore, we wrap the calls
-   * to dsyevr into the following code to supress the exception.
+   * to dsyevr into the following code to suppress the exception.
    */
 #ifdef DEAL_II_HAVE_FP_EXCEPTIONS
   fenv_t fp_exceptions;
@@ -1448,7 +1448,7 @@ syevr(const char *jobz,
   /*
    * Netlib and Atlas Lapack perform floating point tests (e.g. divide-by-zero) within the call to ssyevr
    * causing floating point exceptions to be thrown (at least in debug mode). Therefore, we wrap the calls
-   * to ssyevr into the following code to supress the exception.
+   * to ssyevr into the following code to suppress the exception.
    */
 #ifdef DEAL_II_HAVE_FP_EXCEPTIONS
   fenv_t fp_exceptions;
index 05dfbfb8eaeb851ab616d87b7512d0a78b389681..cf6866fe8dbe0fb91c8cb51cbbad05d19c2660c0 100644 (file)
@@ -1909,7 +1909,7 @@ inline void psyevr(const char *jobz,
   /*
    * Netlib ScaLAPACK performs floating point tests (e.g. divide-by-zero) within the call to pdsyevr
    * causing floating point exceptions to be thrown (at least in debug mode). Therefore, we wrap the calls
-   * to pdsyevr into the following code to supress the exception.
+   * to pdsyevr into the following code to suppress the exception.
    */
 #ifdef DEAL_II_HAVE_FP_EXCEPTIONS
   fenv_t fp_exceptions;
@@ -1951,7 +1951,7 @@ inline void psyevr(const char *jobz,
   /*
    * Netlib ScaLAPACK performs floating point tests (e.g. divide-by-zero) within the call to pssyevr
    * causing floating point exceptions to be thrown (at least in debug mode). Therefore, we wrap the calls
-   * to pssyevr into the following code to supress the exception.
+   * to pssyevr into the following code to suppress the exception.
    */
 #ifdef DEAL_II_HAVE_FP_EXCEPTIONS
   fenv_t fp_exceptions;
index db1fcab2ed808035f8860330dddeb443d585daa1..a03fc407cfe691acd40c9ebedaecccc0322115af 100644 (file)
@@ -134,7 +134,7 @@ namespace LinearAlgebra
       virtual Vector &operator+= (const VectorSpaceVector<double> &V) override;
 
       /**
-       * Substract the vector @p V from the present one.
+       * Subtract the vector @p V from the present one.
        */
       virtual Vector &operator-= (const VectorSpaceVector<double> &V) override;
 
index 1b601675786d2fc2483c9e409738908b0e430175..ae7a27fa1f1c59ba2c5af1b9dcefbb0783dfe002 100644 (file)
@@ -337,7 +337,7 @@ template <int dim, int n_q_points_1d, int n_components, typename Number>
 struct SelectEvaluator<dim, -1, n_q_points_1d, n_components, Number>
 {
   /**
-   * Based on the the run time parameters stored in @p shape_info this function
+   * Based on the run time parameters stored in @p shape_info this function
    * chooses an appropriate evaluation strategy for the integrate function, i.e.
    * this calls internal::FEEvaluationImpl::evaluate(),
    * internal::FEEvaluationImplCollocation::evaluate() or
@@ -355,7 +355,7 @@ struct SelectEvaluator<dim, -1, n_q_points_1d, n_components, Number>
                        const bool               evaluate_hessians);
 
   /**
-   * Based on the the run time parameters stored in @p shape_info this function
+   * Based on the run time parameters stored in @p shape_info this function
    * chooses an appropriate evaluation strategy for the integrate function, i.e.
    * this calls internal::FEEvaluationImpl::integrate(),
    * internal::FEEvaluationImplCollocation::integrate() or
index 92ed485e0921c47379a961f8f7aa4123eb950a36..79725892f23f3071a641181d419fe84228f7b414 100644 (file)
@@ -546,7 +546,7 @@ public:
   /**
    * Return a read-only pointer to the first field of the dof values. This is
    * the data field the read_dof_values() functions write into. First come the
-   * the dof values for the first component, then all values for the second
+   * dof values for the first component, then all values for the second
    * component, and so on. This is related to the internal data structures
    * used in this class. In general, it is safer to use the get_dof_value()
    * function instead.
index eba96ceab5587cca453027252699e968efcd83ed..b8db2d67c599e99ea431fc1c2588bf2a83c1eb3a 100644 (file)
@@ -445,7 +445,7 @@ namespace internal
      * A class that is used to compare floating point arrays (e.g. std::vectors,
      * Tensor<1,dim>, etc.). The idea of this class is to consider two arrays as
      * equal if they are the same within a given tolerance. We use this
-     * comparator class within an std::map<> of the given arrays. Note that this
+     * comparator class within a std::map<> of the given arrays. Note that this
      * comparison operator does not satisfy all the mathematical properties one
      * usually wants to have (consider e.g. the numbers a=0, b=0.1, c=0.2 with
      * tolerance 0.15; the operator gives a<c, but neither of a<b? or b<c? is
index f30adc12c300e7bd2071003f4ecf0b4dac2f3eb6..efd01dac8541b70ddb2d946eec56a164344e6c04 100644 (file)
@@ -119,7 +119,7 @@ namespace MatrixFreeOperators
    * <h4>Selective use of blocks in MatrixFree</h4>
    *
    * MatrixFree allows to use several DoFHandler/ConstraintMatrix combinations
-   * by passing an std::vector with pointers to the respective objects into
+   * by passing a std::vector with pointers to the respective objects into
    * the MatrixFree::reinit function. This class supports to select only some
    * of the blocks in the underlying MatrixFree object by optional integer
    * lists that specify the chosen blocks.
@@ -154,7 +154,7 @@ namespace MatrixFreeOperators
    * vector of two pointers pointing to the same DoFHandler object and a
    * vector of two pointers to the two ConstraintMatrix objects. If the first
    * constraint matrix is the one including the zero Dirichlet constraints,
-   * one would give an std::vector<unsigned int>(1, 0) to the initialize()
+   * one would give a std::vector<unsigned int>(1, 0) to the initialize()
    * function, i.e., a vector of length 1 that selects exactly the first
    * constraint matrix with index 0.
    *
index eaf7314a769ad22797cb5ef5eff9eab804deaa78..b70a510bab4972f044c19c76356bb2ebc9d6a9c6 100644 (file)
@@ -243,7 +243,7 @@ DEAL_II_NAMESPACE_OPEN
  *
  * @note This situation can only happen if you do coarsening. If all cells
  * remain as they are or are refined, then SolutionTransfer::interpolate()
- * computes a new vector of nodel values, but the function represented is of
+ * computes a new vector of nodal values, but the function represented is of
  * course exactly the same because the old finite element space is a subspace
  * of the new one. Thus, if the old function was conforming (i.e., satisfied
  * hanging node constraints), then so does the new one, and it is not
index 94fb37ae1b553140fa9930704b9a6ff41bf194ce..fb114df6640fb1320c6a658279bc48234b0bdbce 100644 (file)
@@ -3402,7 +3402,7 @@ namespace VectorTools
       // from a practical viewpoint such
       // problems should be much rarer. in
       // particular, meshes have to be very
-      // very fine for a vertex to land on
+      // fine for a vertex to land on
       // this line if the original body had a
       // vertex on the diagonal as well
       switch (dim)
index a0a9d90a7447425aadd1caf4dffff9f60e95d738..c110b1b18b1d3484e1d6f1735ab86d42b5fa8a50 100644 (file)
@@ -117,7 +117,7 @@ namespace Physics
       /**
        * The fourth-order spatial deviatoric tensor. Also known as the deviatoric
        * operator, this tensor projects a second-order symmetric tensor onto a
-       * deviatoric space (for which the hydrostatic component is removed).
+       * deviatoric space (for which the hydrostatic component is removed).
        *
        * This is defined as
        * @f[

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.