Prefer C++20 std::ssize() over static_cast (#153)

julianlitz · web-flow · commit 05c809e0a888 · 2026-01-15T19:42:29.000+01:00
diff --git a/include/PolarGrid/polargrid.inl b/include/PolarGrid/polargrid.inl
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <iterator>
+
 #include "polargrid.h"
 
 inline int PolarGrid::nr() const
@@ -18,13 +20,13 @@ inline int PolarGrid::numberOfNodes() const
 
 inline double PolarGrid::radius(const int r_index) const
 {
-    assert(r_index >= 0 && static_cast<size_t>(r_index) < radii_.size());
+    assert(r_index >= 0 && r_index < std::ssize(radii_));
     return radii_[r_index];
 }
 
 inline double PolarGrid::theta(const int theta_index) const
 {
-    assert(theta_index >= 0 && static_cast<size_t>(theta_index) < angles_.size());
+    assert(theta_index >= 0 && theta_index < std::ssize(angles_));
     return angles_[theta_index];
 }
 
@@ -57,7 +59,7 @@ inline int PolarGrid::numberRadialSmootherNodes() const
 
 inline double PolarGrid::radialSpacing(const int r_index) const
 {
-    assert(r_index >= 0 && static_cast<size_t>(r_index) < radial_spacings_.size());
+    assert(r_index >= 0 && r_index < std::ssize(radial_spacings_));
     return radial_spacings_[r_index];
 }
 
diff --git a/src/DirectSolver/DirectSolver-COO-MUMPS-Give/applySymmetryShift.cpp b/src/DirectSolver/DirectSolver-COO-MUMPS-Give/applySymmetryShift.cpp
@@ -2,6 +2,8 @@
 
 #include "../../../include/common/geometry_helper.h"
 
+#include <iterator>
+
 #ifdef GMGPOLAR_USE_MUMPS
 
 /* ----------------------- */
@@ -123,7 +125,7 @@ void DirectSolverGive::applySymmetryShiftOuterBoundary(Vector<double> x) const
 // clang-format off
 void DirectSolverGive::applySymmetryShift(Vector<double> x) const
 {
-    assert(x.size() == grid_.numberOfNodes());
+    assert(std::ssize(x) == grid_.numberOfNodes());
     assert(grid_.nr() >= 4);
 
     if (num_omp_threads_ == 1) {
diff --git a/src/DirectSolver/DirectSolver-COO-MUMPS-Take/applySymmetryShift.cpp b/src/DirectSolver/DirectSolver-COO-MUMPS-Take/applySymmetryShift.cpp
@@ -1,5 +1,7 @@
 #include "../../../include/DirectSolver/DirectSolver-COO-MUMPS-Take/directSolverTake.h"
 
+#include <iterator>
+
 #ifdef GMGPOLAR_USE_MUMPS
 
 /* ----------------------- */
@@ -80,7 +82,7 @@ void DirectSolverTake::applySymmetryShiftOuterBoundary(Vector<double> x) const
 
 void DirectSolverTake::applySymmetryShift(Vector<double> x) const
 {
-    assert(x.size() == grid_.numberOfNodes());
+    assert(std::ssize(x) == grid_.numberOfNodes());
     assert(grid_.nr() >= 4);
 
     if (num_omp_threads_ == 1) {
diff --git a/src/GMGPolar/build_rhs_f.cpp b/src/GMGPolar/build_rhs_f.cpp
@@ -4,7 +4,7 @@ void GMGPolar::build_rhs_f(const Level& level, Vector<double> rhs_f, const Bound
                            const SourceTerm& source_term)
 {
     const PolarGrid& grid = level.grid();
-    assert(rhs_f.size() == static_cast<uint>(grid.numberOfNodes()));
+    assert(std::ssize(rhs_f) == grid.numberOfNodes());
 
 #pragma omp parallel
     {
@@ -55,7 +55,7 @@ void GMGPolar::build_rhs_f(const Level& level, Vector<double> rhs_f, const Bound
 void GMGPolar::discretize_rhs_f(const Level& level, Vector<double> rhs_f)
 {
     const PolarGrid& grid = level.grid();
-    assert(rhs_f.size() == static_cast<uint>(grid.numberOfNodes()));
+    assert(std::ssize(rhs_f) == grid.numberOfNodes());
 
     if (level.levelCache().cacheDomainGeometry()) {
         /* DomainGeometry is cached */
diff --git a/src/GMGPolar/solver.cpp b/src/GMGPolar/solver.cpp
@@ -319,8 +319,8 @@ void GMGPolar::extrapolatedResidual(const int current_level, Vector<double> resi
     const PolarGrid& fineGrid   = levels_[current_level].grid();
     const PolarGrid& coarseGrid = levels_[current_level + 1].grid();
 
-    assert(residual.size() == static_cast<uint>(fineGrid.numberOfNodes()));
-    assert(residual_next_level.size() == static_cast<uint>(coarseGrid.numberOfNodes()));
+    assert(std::ssize(residual) == fineGrid.numberOfNodes());
+    assert(std::ssize(residual_next_level) == coarseGrid.numberOfNodes());
 
 #pragma omp parallel num_threads(max_omp_threads_)
     {
@@ -397,7 +397,7 @@ std::pair<double, double> GMGPolar::computeExactError(Level& level, ConstVector<
     const LevelCache& levelCache = level.levelCache();
 
     assert(solution.size() == error.size());
-    assert(solution.size() == static_cast<uint>(grid.numberOfNodes()));
+    assert(std::ssize(solution) == grid.numberOfNodes());
 
 #pragma omp parallel num_threads(max_omp_threads_)
     {
diff --git a/src/GMGPolar/writeToVTK.cpp b/src/GMGPolar/writeToVTK.cpp
@@ -63,7 +63,7 @@ void GMGPolar::writeToVTK(const std::filesystem::path& file_path, const Level& l
     const PolarGrid& grid         = level.grid();
     const LevelCache& level_cache = level.levelCache();
 
-    assert(static_cast<uint>(grid.numberOfNodes()) == grid_function.size());
+    assert(std::ssize(grid_function) == grid.numberOfNodes());
 
     const auto filename = file_path.stem().string() + ".vtu";
 
diff --git a/src/Interpolation/extrapolated_prolongation.cpp b/src/Interpolation/extrapolated_prolongation.cpp
@@ -84,8 +84,8 @@
 void Interpolation::applyExtrapolatedProlongation(const PolarGrid& coarse_grid, const PolarGrid& fine_grid,
                                                   Vector<double> fine_result, ConstVector<double> coarse_values) const
 {
-    assert(coarse_values.size() == static_cast<uint>(coarse_grid.numberOfNodes()));
-    assert(fine_result.size() == static_cast<uint>(fine_grid.numberOfNodes()));
+    assert(std::ssize(coarse_values) == coarse_grid.numberOfNodes());
+    assert(std::ssize(fine_result) == fine_grid.numberOfNodes());
 
     /* We split the loops into two regions to better respect the */
     /* access patterns of the smoother and improve cache locality. */
diff --git a/src/Interpolation/extrapolated_restriction.cpp b/src/Interpolation/extrapolated_restriction.cpp
@@ -49,8 +49,8 @@
 void Interpolation::applyExtrapolatedRestriction(const PolarGrid& fine_grid, const PolarGrid& coarse_grid,
                                                  Vector<double> coarse_result, ConstVector<double> fine_values) const
 {
-    assert(fine_values.size() == static_cast<uint>(fine_grid.numberOfNodes()));
-    assert(coarse_result.size() == static_cast<uint>(coarse_grid.numberOfNodes()));
+    assert(std::ssize(fine_values) == fine_grid.numberOfNodes());
+    assert(std::ssize(coarse_result) == coarse_grid.numberOfNodes());
 
     /* We split the loops into two regions to better respect the */
     /* access patterns of the smoother and improve cache locality. */
diff --git a/src/Interpolation/fmg_interpolation.cpp b/src/Interpolation/fmg_interpolation.cpp
@@ -231,8 +231,8 @@
 void Interpolation::applyFMGInterpolation(const PolarGrid& coarse_grid, const PolarGrid& fine_grid,
                                           Vector<double> fine_result, ConstVector<double> coarse_values) const
 {
-    assert(coarse_values.size() == static_cast<uint>(coarse_grid.numberOfNodes()));
-    assert(fine_result.size() == static_cast<uint>(fine_grid.numberOfNodes()));
+    assert(std::ssize(coarse_values) == coarse_grid.numberOfNodes());
+    assert(std::ssize(fine_result) == fine_grid.numberOfNodes());
 
 #pragma omp parallel num_threads(max_omp_threads_)
     {
diff --git a/src/Interpolation/injection.cpp b/src/Interpolation/injection.cpp
@@ -5,8 +5,8 @@
 void Interpolation::applyInjection(const PolarGrid& fine_grid, const PolarGrid& coarse_grid,
                                    Vector<double> coarse_result, ConstVector<double> fine_values) const
 {
-    assert(fine_values.size() == static_cast<uint>(fine_grid.numberOfNodes()));
-    assert(coarse_result.size() == static_cast<uint>(coarse_grid.numberOfNodes()));
+    assert(std::ssize(fine_values) == fine_grid.numberOfNodes());
+    assert(std::ssize(coarse_result) == coarse_grid.numberOfNodes());
 
 #pragma omp parallel num_threads(max_omp_threads_)
     {
diff --git a/src/Interpolation/prolongation.cpp b/src/Interpolation/prolongation.cpp
@@ -108,8 +108,8 @@
 void Interpolation::applyProlongation(const PolarGrid& coarse_grid, const PolarGrid& fine_grid,
                                       Vector<double> fine_result, ConstVector<double> coarse_values) const
 {
-    assert(coarse_values.size() == static_cast<uint>(coarse_grid.numberOfNodes()));
-    assert(fine_result.size() == static_cast<uint>(fine_grid.numberOfNodes()));
+    assert(std::ssize(coarse_values) == coarse_grid.numberOfNodes());
+    assert(std::ssize(fine_result) == fine_grid.numberOfNodes());
 
     /* We split the loops into two regions to better respect the */
     /* access patterns of the smoother and improve cache locality. */
diff --git a/src/Interpolation/restriction.cpp b/src/Interpolation/restriction.cpp
@@ -67,8 +67,8 @@
 void Interpolation::applyRestriction(const PolarGrid& fine_grid, const PolarGrid& coarse_grid,
                                      Vector<double> coarse_result, ConstVector<double> fine_values) const
 {
-    assert(fine_values.size() == static_cast<uint>(fine_grid.numberOfNodes()));
-    assert(coarse_result.size() == static_cast<uint>(coarse_grid.numberOfNodes()));
+    assert(std::ssize(fine_values) == fine_grid.numberOfNodes());
+    assert(std::ssize(coarse_result) == coarse_grid.numberOfNodes());
 
     /* We split the loops into two regions to better respect the */
     /* access patterns of the smoother and improve cache locality. */
diff --git a/src/Stencil/stencil.cpp b/src/Stencil/stencil.cpp
@@ -5,7 +5,7 @@ Stencil::Stencil(std::initializer_list<int> init)
 {
     std::copy(init.begin(), init.end(), values_.begin());
     stencil_size_ = 0;
-    for (int i = 0; i < static_cast<int>(init.size()); i++) {
+    for (int i = 0; i < std::ssize(init); i++) {
         if (values_[i] != -1)
             stencil_size_++;
     }
diff --git a/src/convergence_order.cpp b/src/convergence_order.cpp
@@ -158,7 +158,7 @@ int main(int argc, char* argv[])
     // Print the table rows with data
     for (int i = 0; i < MAX_DIVIDE_BY_2; i++) {
         // Start the row
-        std::cout << std::setw(6) << table_nr[i] << " x " << table_ntheta[i] << std::setw(7.5) << table_iterations[i]
+        std::cout << std::setw(6) << table_nr[i] << " x " << table_ntheta[i] << std::setw(7) << table_iterations[i]
                   << std::setw(9) << table_reduction_factor[i];
 
         // Print ||err||_2/sqrt(m) in scientific notation
diff --git a/tests/test_tools.h b/tests/test_tools.h
@@ -10,7 +10,7 @@ inline Vector<double> generate_random_sample_data(const PolarGrid& grid, unsigne
     Vector<double> x("x", grid.numberOfNodes());
     std::mt19937 gen(seed);
     std::uniform_real_distribution<double> dist(min_val, max_val);
-    for (uint i = 0; i < x.size(); ++i) {
+    for (std::size_t i = 0; i < x.size(); ++i) {
         x(i) = dist(gen);
     }
     return x;

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,7 @@`
`1`	`1`	`#pragma once`
`2`	`2`
	`3`	`+#include <iterator>`
	`4`	`+`
`3`	`5`	`#include "polargrid.h"`
`4`	`6`
`5`	`7`	`inline int PolarGrid::nr() const`
`@@ -18,13 +20,13 @@ inline int PolarGrid::numberOfNodes() const`
`18`	`20`
`19`	`21`	`inline double PolarGrid::radius(const int r_index) const`
`20`	`22`	`{`
`21`		`- assert(r_index >= 0 && static_cast<size_t>(r_index) < radii_.size());`
	`23`	`+ assert(r_index >= 0 && r_index < std::ssize(radii_));`
`22`	`24`	`return radii_[r_index];`
`23`	`25`	`}`
`24`	`26`
`25`	`27`	`inline double PolarGrid::theta(const int theta_index) const`
`26`	`28`	`{`
`27`		`- assert(theta_index >= 0 && static_cast<size_t>(theta_index) < angles_.size());`
	`29`	`+ assert(theta_index >= 0 && theta_index < std::ssize(angles_));`
`28`	`30`	`return angles_[theta_index];`
`29`	`31`	`}`
`30`	`32`
`@@ -57,7 +59,7 @@ inline int PolarGrid::numberRadialSmootherNodes() const`
`57`	`59`
`58`	`60`	`inline double PolarGrid::radialSpacing(const int r_index) const`
`59`	`61`	`{`
`60`		`- assert(r_index >= 0 && static_cast<size_t>(r_index) < radial_spacings_.size());`
	`62`	`+ assert(r_index >= 0 && r_index < std::ssize(radial_spacings_));`
`61`	`63`	`return radial_spacings_[r_index];`
`62`	`64`	`}`
`63`	`65`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@ void GMGPolar::build_rhs_f(const Level& level, Vector<double> rhs_f, const Bound`
`4`	`4`	`const SourceTerm& source_term)`
`5`	`5`	`{`
`6`	`6`	`const PolarGrid& grid = level.grid();`
`7`		`- assert(rhs_f.size() == static_cast<uint>(grid.numberOfNodes()));`
	`7`	`+ assert(std::ssize(rhs_f) == grid.numberOfNodes());`
`8`	`8`
`9`	`9`	`#pragma omp parallel`
`10`	`10`	`{`
`@@ -55,7 +55,7 @@ void GMGPolar::build_rhs_f(const Level& level, Vector<double> rhs_f, const Bound`
`55`	`55`	`void GMGPolar::discretize_rhs_f(const Level& level, Vector<double> rhs_f)`
`56`	`56`	`{`
`57`	`57`	`const PolarGrid& grid = level.grid();`
`58`		`- assert(rhs_f.size() == static_cast<uint>(grid.numberOfNodes()));`
	`58`	`+ assert(std::ssize(rhs_f) == grid.numberOfNodes());`
`59`	`59`
`60`	`60`	`if (level.levelCache().cacheDomainGeometry()) {`
`61`	`61`	`/* DomainGeometry is cached */`
Original file line number	Diff line number	Diff line change
`@@ -231,8 +231,8 @@`
`231`	`231`	`void Interpolation::applyFMGInterpolation(const PolarGrid& coarse_grid, const PolarGrid& fine_grid,`
`232`	`232`	`Vector<double> fine_result, ConstVector<double> coarse_values) const`
`233`	`233`	`{`
`234`		`- assert(coarse_values.size() == static_cast<uint>(coarse_grid.numberOfNodes()));`
`235`		`- assert(fine_result.size() == static_cast<uint>(fine_grid.numberOfNodes()));`
	`234`	`+ assert(std::ssize(coarse_values) == coarse_grid.numberOfNodes());`
	`235`	`+ assert(std::ssize(fine_result) == fine_grid.numberOfNodes());`
`236`	`236`
`237`	`237`	`#pragma omp parallel num_threads(max_omp_threads_)`
`238`	`238`	`{`
Original file line number	Diff line number	Diff line change
`@@ -5,8 +5,8 @@`
`5`	`5`	`void Interpolation::applyInjection(const PolarGrid& fine_grid, const PolarGrid& coarse_grid,`
`6`	`6`	`Vector<double> coarse_result, ConstVector<double> fine_values) const`
`7`	`7`	`{`
`8`		`- assert(fine_values.size() == static_cast<uint>(fine_grid.numberOfNodes()));`
`9`		`- assert(coarse_result.size() == static_cast<uint>(coarse_grid.numberOfNodes()));`
	`8`	`+ assert(std::ssize(fine_values) == fine_grid.numberOfNodes());`
	`9`	`+ assert(std::ssize(coarse_result) == coarse_grid.numberOfNodes());`
`10`	`10`
`11`	`11`	`#pragma omp parallel num_threads(max_omp_threads_)`
`12`	`12`	`{`