Merge branch 'feature/codespell' into 'master'

Include codespell package to check spelling errors in CI

See merge request !68

.gitlab-ci.yml

@@ -14,3 +14,13 @@ dune:git  gcc-9  C++20:
 dune:git  gcc-8  C++17:
   image: registry.dune-project.org/docker/ci/dune:git-debian-10-gcc-8-17
   script: duneci-standard-test
+
+# Check for spelling mistakes in text
+code-spelling-check:
+  stage: .pre
+  # Avoid the global 'before_script'
+  before_script: ""
+  image: registry.dune-project.org/docker/ci/debian:11
+  script:
+  - codespell
+    --ignore-words-list foo,bar

CHANGELOG.md

@@ -2,6 +2,9 @@
 
 - The internal matrix of the`EnergyNorm` can now be accessed by `getMatrix()`.
 
+- `codespell` spell checker is now active for automated spell checking in the Gitlab CI. 
+  To exclude false positives add the words to the `--ignore-words-list` in `.gitlab-ci.yml`.
+
 # Release 2.8
 
 - `UMFPackSolver` can now handle matrices and vectors with scalar entries.

doc/LOWRANKBRANCH-BACKPORT-CHANGES

@@ -21,7 +21,7 @@ CHANGES REQUIRING CODE ADAPTATION
 ---------------------------------------------------------------------------------------
 
 
-CHANGES POSSIBLY AFFECTING PERFOMANCE (INCLUDING BUGFIXES)
+CHANGES POSSIBLY AFFECTING PERFORMANCE (INCLUDING BUGFIXES)
 ----------------------------------------------------------
 ----------------------------------------------------------
 

dune/solvers/common/genericvectortools.hh

@@ -48,7 +48,7 @@ struct GenericVector
         Dune::MatrixVector::Generic::readBinary(s, v);
     }
 
-    //! Resize vector recursivly to size of given vector/matrix
+    //! Resize vector recursively to size of given vector/matrix
     template <class VectorTypeA, class VectorTypeB>
     [[deprecated("Please use Dune::MatrixVector::resize instead.")]]
     static void resize(VectorTypeA& a, const VectorTypeB& b)
@@ -56,7 +56,7 @@ struct GenericVector
         Dune::MatrixVector::resize(a, b);
     }
 
-    //! Set vector to zero at indices that are true in bitvector recursivly
+    //! Set vector to zero at indices that are true in bitvector recursively
     template <class VectorType, class BitVectorType>
     [[deprecated("Please use Dune::MatrixVector::Generic::truncate instead.")]]
     static void truncate(VectorType& v, const BitVectorType& tr)
@@ -183,7 +183,7 @@ struct GenericVector
 struct GenericMatrix
 {
 
-    //! Set matrix to zero at indices that are true in bitvector recursivly
+    //! Set matrix to zero at indices that are true in bitvector recursively
     template <class MatrixType, class BitVectorTypeR, class BitVectorTypeC>
     static void truncate(MatrixType& mat, const BitVectorTypeR& trows, const BitVectorTypeC& tcols, bool setTruncatedDiagonalOne)
     {

dune/solvers/common/numproc.hh

@@ -16,7 +16,7 @@ public:
   /** \brief Different levels of verbosity */
   enum VerbosityMode {QUIET, REDUCED, FULL};
 
-  /** \brief Constructor, per defaut uses FULL. */
+  /** \brief Constructor, per default uses FULL. */
   NumProc(VerbosityMode verbosity = FULL)
     : verbosity_(verbosity)
   {}

dune/solvers/common/permutationmanager.hh

@@ -15,7 +15,7 @@
 //! Idea of implementation: define an ordering for the nodes (with respect to the axis of anisotropy)
 //! and then use a merge sort algorithm to renumerate the nodes along the lines which are parallel to this axis.
 //! to do so, we introduce a 'NodeList' class.
-//! everything is handeled by the PermutationManager
+//! everything is handled by the PermutationManager
 
 
 // type of nodes:
@@ -151,7 +151,7 @@ public:
 
 
 
-// the information about the axis of anisotropy is in NodeList, since this list contains a methode "less_equal", which describes the ordering of the nodes.
+// the information about the axis of anisotropy is in NodeList, since this list contains a method "less_equal", which describes the ordering of the nodes.
 // this ordering depends on the axis of anisotropy
 template< class GridViewImp >
 class PermutationManager{
@@ -430,9 +430,9 @@ public:
 
       for( int i = 0; i < node_list_.size(); ++i )
        {
-	 std::cout << "Original node[" << get_inverse_permuted_index( i ) << "] = (" << node_list_[i].get_global_coordinate() << ") recieved permuted index " << i << std::endl;
+	 std::cout << "Original node[" << get_inverse_permuted_index( i ) << "] = (" << node_list_[i].get_global_coordinate() << ") received permuted index " << i << std::endl;
          // alternative:
-	 //std::cout << "Original node[" << get_inverse_permuted_index( i ) << "] = (" << original_node_list_[get_inverse_permuted_index( i )].get_global_coordinate() << ") recieved permuted index " << i << std::endl;
+	 //std::cout << "Original node[" << get_inverse_permuted_index( i ) << "] = (" << original_node_list_[get_inverse_permuted_index( i )].get_global_coordinate() << ") received permuted index " << i << std::endl;
        }
 
 #if 0

dune/solvers/iterationsteps/linegsstep.cc

@@ -23,7 +23,7 @@ void LineGSStep<MatrixType, DiscFuncType, BitVectorType >::iterate()
 
         const int current_block_size = blockStructure_[b_num].size();
 
-        //! compute and save the residuals for the curent block:
+        //! compute and save the residuals for the current block:
         // determine the (permuted) residuals r[p(i)],..., r[p(i+current_block_size-1)]
         // this means that we determine the residuals for the current block
         DiscFuncType permuted_r_i(current_block_size);

dune/solvers/iterationsteps/minimalpolynomialextrapolationstep.hh

@@ -44,7 +44,7 @@ public:
     virtual void iterate();
 
     /** \brief To be called before starting to iterate
-       \note This calls the preprocess method for the dependant iteration step class, too!
+       \note This calls the preprocess method for the dependent iteration step class, too!
      */
     virtual void preprocess();
 

dune/solvers/iterationsteps/obstacletnnmgstep.hh

@@ -40,7 +40,7 @@
  * details please refer to
  *
  *   'Multigrid Methods for Obstacle Problems', C. Gräser and R. Kornhuber
- *   Journal of Computational Mathematics 27 (1), 2009, pp. 1-44 
+ *   Journal of Computational Mathematics 27 (1), 2009, pp. 1-44
  *
  * A much more general and flexible implementation that can also be used for
  * energy functionals with nonquadratic (anisotropic) smooth part
@@ -241,7 +241,7 @@ class ObstacleTNNMGStep
                         truncatedResidual_[i][ii] = 0;
             }
 
-            // apply linear multigrid to approximatively solve the truncated linear system
+            // apply linear multigrid to approximately solve the truncated linear system
             linearMGStep_.setProblem(truncatedMat, coarseCorrection_, truncatedResidual_);
             linearMGStep_.ignoreNodes_ = ignoreNodes_;
             linearMGStep_.preprocess();
@@ -345,13 +345,13 @@ class ObstacleTNNMGStep
          * is ignored if it is associated to an ignored fine dof
          * in the sense that the corresponding transfer operators entry is 1.
          *
-         * On each level a fixed number of v-cycles is performed.
+         * On each level a fixed number of V-cycles is performed.
          *
          * This method can be called before the preprocess() method.
          * It does not change the ObstacleTNNMGStep state despite
          * updating the solution vector.
          *
-         * \param coarseIterationSteps Number of v-cycle performed on the corse levels.
+         * \param coarseIterationSteps Number of V-cycles performed on the coarse levels.
          */
         void nestedIteration(int coarseIterationSteps=2)
         {

dune/solvers/iterationsteps/projectedlinegsstep.cc

@@ -178,7 +178,7 @@ void ProjectedLineGSStep<MatrixType, VectorType, BitVectorType>::iterate()
 
         const int current_block_size = this->blockStructure_[b_num].size();
 
-        //! compute and save the residuals for the curent block:
+        //! compute and save the residuals for the current block:
         // determine the (permuted) residuals r[p(i)],..., r[p(i+current_block_size-1)]
         // this means that we determine the residuals for the current block
         VectorType permuted_r_i(current_block_size);

dune/solvers/solvers/linearipopt.hh

@@ -584,7 +584,7 @@ void LinearIPOptSolver<VectorType,JacobianType>::solve()
       app->Options()->SetIntegerValue("print_level", 12);
   }
 
-  // Intialize the IpoptApplication and process the options
+  // Initialize the IpoptApplication and process the options
   Ipopt::ApplicationReturnStatus status;
   status = app->Initialize();
   if (status != Ipopt::Solve_Succeeded)
@@ -598,7 +598,7 @@ void LinearIPOptSolver<VectorType,JacobianType>::solve()
     DUNE_THROW(Dune::Exception, "IPOpt returned 'Invalid_Option' error!");
 
   if (status == Ipopt::Solved_To_Acceptable_Level)
-      std::cout<<"WARNING: Desired tolerance could not be reached, but still accetable tolerance is reached.\n";
+      std::cout<<"WARNING: Desired tolerance could not be reached, but still acceptable tolerance is reached.\n";
   else if (status != Ipopt::Solve_Succeeded)
       DUNE_THROW(Dune::Exception, "IPOpt: Error during optimization!");
 }

dune/solvers/solvers/quadraticipopt.hh

@@ -797,7 +797,7 @@ void QuadraticIPOptSolver<MatrixType,VectorType,JacobianType>::solve()
       app->Options()->SetIntegerValue("print_level", 12);
   }
 
-  // Intialize the IpoptApplication and process the options
+  // Initialize the IpoptApplication and process the options
   Ipopt::ApplicationReturnStatus status;
   status = app->Initialize();
   if (status != Ipopt::Solve_Succeeded)

dune/solvers/solvers/trustregionsolver.hh

@@ -128,10 +128,10 @@ protected:
     /** \brief The maximal trust-region radius in the maximum-norm */
     field_type maxRadius_;
 
-    /** \brief If the iteration is very successfull we enlarge the radius by this factor.*/
+    /** \brief If the iteration is very successful we enlarge the radius by this factor.*/
     field_type enlargeRadius_;
 
-    /** \brief If the iteration is unsuccessfull we shrink the radius by this factor.*/
+    /** \brief If the iteration is unsuccessful we shrink the radius by this factor.*/
     field_type shrinkRadius_;
 
     /** \brief If the ratio between predicted and achieved decrease is above this number, the iteration is very successful.*/

dune/solvers/test/common.hh

@@ -89,7 +89,7 @@ void assemblePQ1Stiffness(const GridView& gridView, Matrix& matrix)
 
         int localSize = fe.size();
 
-        // get quadrature rule of appropiate order (P1/Q1)
+        // get quadrature rule of appropriate order (P1/Q1)
         int order = (element.type().isSimplex())
                     ? 2*(1-1)
                     : 2*(dim-1);
@@ -220,7 +220,7 @@ void assemblePQ1RHS(const GridView& gridView, Vector& r, const Function& f)
 
         int localSize = fe.size();
 
-        // get quadrature rule of appropiate order (P1/Q1)
+        // get quadrature rule of appropriate order (P1/Q1)
         int order = (element.type().isSimplex())
                     ? 2*1
                     : 2*dim;

dune/solvers/test/obstacletnnmgtest.cc

@@ -76,7 +76,7 @@ void solveObstacleProblemByTNNMG(const GridType& grid, const MatrixType& mat, Ve
     tnnmgStep.preprocess();
     tnnmgStep.nestedIteration();
 
-    // cretae loop solver
+    // create loop solver
     Solver solver(tnnmgStep, maxIterations, tolerance, norm, Solver::FULL);
 
     // solve problem