Prefer std::size_t over plain size_t

phdum-a · phdum-a · commit 240d841aad3b · 2025-12-02T11:45:00.000-08:00
diff --git a/palace/linalg/nleps.cpp b/palace/linalg/nleps.cpp
@@ -283,7 +283,7 @@ void QuasiNewtonSolver::SetInitialGuess()
 
   // If the number of initial guesses is greater than the number of requested modes
   // de-prioritize the initial guesses that have larger errors.
-  std::vector<size_t> indices(nev_linear);
+  std::vector<std::size_t> indices(nev_linear);
   std::iota(indices.begin(), indices.end(), 0);
   if (nev_linear > nev)
   {
@@ -330,8 +330,8 @@ namespace
 ComplexVector MatVecMult(const std::vector<ComplexVector> &X, const Eigen::VectorXcd &y)
 {
   MFEM_ASSERT(X.size() == y.size(), "Mismatch in dimension of input vectors!");
-  const size_t k = X.size();
-  const size_t n = X[0].Size();
+  const std::size_t k = X.size();
+  const std::size_t n = X[0].Size();
   const bool use_dev = X[0].UseDevice();
   ComplexVector z;
   z.SetSize(n);
diff --git a/palace/models/postoperatorcsv.cpp b/palace/models/postoperatorcsv.cpp
@@ -292,7 +292,7 @@ int PrecIndexCol(const ProblemType solver_t)
 // Index checking when adding to a new excitation block: When adding data to data_col with
 // index idx, checks that idx matches what is already written in the corresponding row of
 // idx_col. Adds a new idx row to idx_col if needed.
-void CheckAppendIndex(Column &idx_col, double idx_value, size_t m_idx_row)
+void CheckAppendIndex(Column &idx_col, double idx_value, std::size_t m_idx_row)
 {
   if (m_idx_row == idx_col.n_rows())
   {
@@ -656,7 +656,7 @@ auto PostOperatorCSV<solver_t>::PrintFarFieldE(const SurfacePostOperator &surf_p
   }
   using fmt::format;
   int v_dim = surf_post_op.GetVDim();
-  for (size_t i = 0; i < measurement_cache.farfield.thetaphis.size(); i++)
+  for (std::size_t i = 0; i < measurement_cache.farfield.thetaphis.size(); i++)
   {
     farfield_E->table["idx"] << row_idx_v;
     if constexpr (U == ProblemType::EIGENMODE)
@@ -740,7 +740,7 @@ void PostOperatorCSV<solver_t>::PrintProbeE(const InterpolationOperator &interp_
 
   CheckAppendIndex(probe_E->table["idx"], row_idx_v, row_i);
 
-  size_t i = 0;
+  std::size_t i = 0;
   for (const auto &idx : interp_op.GetProbes())
   {
     for (int i_dim = 0; i_dim < v_dim; i_dim++)
@@ -818,7 +818,7 @@ void PostOperatorCSV<solver_t>::PrintProbeB(const InterpolationOperator &interp_
 
   CheckAppendIndex(probe_B->table["idx"], row_idx_v, row_i);
 
-  size_t i = 0;
+  std::size_t i = 0;
   for (const auto &idx : interp_op.GetProbes())
   {
     for (int i_dim = 0; i_dim < v_dim; i_dim++)
diff --git a/palace/models/strattonchu.cpp b/palace/models/strattonchu.cpp
@@ -120,7 +120,7 @@ void AddStrattonChuIntegrandAtElement(const GridFunction &E, const GridFunction
     // This is a hot loop. Manually unrolling and avoiding Vectors significantly
     // increases performance.
     PalacePragmaOmp(parallel for schedule(static))
-    for (size_t i = 0; i < r_naughts.size(); i++)
+    for (std::size_t i = 0; i < r_naughts.size(); i++)
     {
       const auto &r = r_naughts[i];
 
diff --git a/palace/models/surfacepostoperator.cpp b/palace/models/surfacepostoperator.cpp
@@ -400,19 +400,19 @@ std::vector<std::array<std::complex<double>, 3>> SurfacePostOperator::GetFarFiel
 
   double *data_r_ptr = integrals_r.data()->data();
   double *data_i_ptr = integrals_i.data()->data();
-  size_t total_elements = integrals_r.size() * 3;
+  std::size_t total_elements = integrals_r.size() * 3;
   Mpi::GlobalSum(total_elements, data_i_ptr, E.GetComm());
   Mpi::GlobalSum(total_elements, data_r_ptr, E.GetComm());
 
   // Finally, we apply cross product to reduced integrals and package the result
   // in a neatly accessible vector of arrays of complex numbers.
   std::vector<std::array<std::complex<double>, 3>> result(theta_phi_pairs.size());
   StaticVector<3> tmp_r, tmp_i;
-  for (size_t k = 0; k < theta_phi_pairs.size(); k++)
+  for (std::size_t k = 0; k < theta_phi_pairs.size(); k++)
   {
     linalg::Cross3(r_naughts[k], integrals_r[k], tmp_r);
     linalg::Cross3(r_naughts[k], integrals_i[k], tmp_i);
-    for (size_t d = 0; d < 3; d++)
+    for (std::size_t d = 0; d < 3; d++)
     {
       result[k][d] = std::complex<double>{tmp_r[d], tmp_i[d]};
     }
diff --git a/palace/models/surfacepostoperator.hpp b/palace/models/surfacepostoperator.hpp
@@ -73,7 +73,7 @@ class SurfacePostOperator
     FarFieldData(const config::FarFieldPostData &data, const mfem::ParMesh &mesh,
                  const mfem::Array<int> &bdr_attr_marker);
 
-    size_t size() const { return thetaphis.size(); }
+    std::size_t size() const { return thetaphis.size(); }
   };
 
   // Reference to material property operator (not owned).
diff --git a/palace/utils/tablecsv.cpp b/palace/utils/tablecsv.cpp
@@ -17,16 +17,16 @@
 namespace palace
 {
 
-[[nodiscard]] size_t Column::col_width(const ColumnOptions &defaults) const
+[[nodiscard]] std::size_t Column::col_width(const ColumnOptions &defaults) const
 {
   // Quickfix to specify full column width in integer case to match current formatting.
   if (print_as_int)
   {
     return std::max(min_left_padding.value_or(defaults.min_left_padding),
                     header_text.size());
   }
-  size_t pad = min_left_padding.value_or(defaults.min_left_padding);
-  size_t prec = float_precision.value_or(defaults.float_precision);
+  std::size_t pad = min_left_padding.value_or(defaults.min_left_padding);
+  std::size_t prec = float_precision.value_or(defaults.float_precision);
 
   // Normal float in our exponent format needs float_precision + 7 ("+" , leading digit,
   // ".", "e", "+", +2 exponent. Sometimes exponent maybe +3 if very small or large; see
@@ -36,14 +36,14 @@ namespace palace
 }
 
 [[nodiscard]] auto Column::format_header(const ColumnOptions &defaults,
-                                         const std::optional<size_t> &width) const
+                                         const std::optional<std::size_t> &width) const
 {
   auto w = width.value_or(col_width(defaults));
   return fmt::format("{0:>{1}s}", header_text, w);
 }
 
-[[nodiscard]] auto Column::format_row(size_t i, const ColumnOptions &defaults,
-                                      const std::optional<size_t> &width) const
+[[nodiscard]] auto Column::format_row(std::size_t i, const ColumnOptions &defaults,
+                                      const std::optional<std::size_t> &width) const
 {
   auto width_ = width.value_or(col_width(defaults));
   // If data available format double.
@@ -68,15 +68,16 @@ namespace palace
 }
 
 Column::Column(std::string name_, std::string header_text_, long column_group_idx_,
-               std::optional<size_t> min_left_padding_,
-               std::optional<size_t> float_precision_, std::optional<std::string> fmt_sign_)
+               std::optional<std::size_t> min_left_padding_,
+               std::optional<std::size_t> float_precision_,
+               std::optional<std::string> fmt_sign_)
   : name(std::move(name_)), header_text(std::move(header_text_)),
     column_group_idx(column_group_idx_), min_left_padding(min_left_padding_),
     float_precision(float_precision_), fmt_sign(std::move(fmt_sign_))
 {
 }
 
-[[nodiscard]] size_t Table::n_rows() const
+[[nodiscard]] std::size_t Table::n_rows() const
 {
   if (n_cols() == 0)
   {
@@ -87,7 +88,7 @@ Column::Column(std::string name_, std::string header_text_, long column_group_id
   return max_col->n_rows();
 }
 
-void Table::reserve(size_t n_rows, size_t n_cols)
+void Table::reserve(std::size_t n_rows, std::size_t n_cols)
 {
   reserve_n_rows = n_rows;
   cols.reserve(n_cols);
@@ -127,7 +128,7 @@ Column &Table::operator[](std::string_view name)
 template <typename T>
 void Table::append_header(T &buf) const
 {
-  for (size_t i = 0; i < n_cols(); i++)
+  for (std::size_t i = 0; i < n_cols(); i++)
   {
     if (i > 0)
     {
@@ -139,9 +140,9 @@ void Table::append_header(T &buf) const
 }
 
 template <typename T>
-void Table::append_row(T &buf, size_t row_j) const
+void Table::append_row(T &buf, std::size_t row_j) const
 {
-  for (size_t i = 0; i < n_cols(); i++)
+  for (std::size_t i = 0; i < n_cols(); i++)
   {
     if (i > 0)
     {
@@ -159,7 +160,7 @@ void Table::append_row(T &buf, size_t row_j) const
   return {buf.data(), buf.size()};
 }
 
-[[nodiscard]] std::string Table::format_row(size_t j) const
+[[nodiscard]] std::string Table::format_row(std::size_t j) const
 {
   fmt::memory_buffer buf{};
   append_row(buf, j);
@@ -170,7 +171,7 @@ void Table::append_row(T &buf, size_t row_j) const
 {
   fmt::memory_buffer buf{};
   append_header(buf);
-  for (size_t j = 0; j < n_rows(); j++)
+  for (std::size_t j = 0; j < n_rows(); j++)
   {
     append_row(buf, j);
   }
@@ -273,7 +274,7 @@ Table::Table(std::string_view table_str,
 
 // explicit instantiation to avoid fmt inclusion.
 template void Table::append_header(fmt::memory_buffer &) const;
-template void Table::append_row(fmt::memory_buffer &, size_t) const;
+template void Table::append_row(fmt::memory_buffer &, std::size_t) const;
 
 TableWithCSVFile::TableWithCSVFile(std::string csv_file_fullpath, bool load_existing_file)
   : csv_file_fullpath_{std::move(csv_file_fullpath)}
diff --git a/test/unit/test-config.cpp b/test/unit/test-config.cpp
@@ -138,13 +138,13 @@ TEST_CASE("Config Driven Solver", "[config][Serial]")
   constexpr double delta_eps = 1.0e-9;  // Precision in frequency comparisons (Hz)
   {
     auto sample_f = std::vector{0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1};
-    auto save_indices = std::vector<size_t>{0, 2, 4, 6, 8, 10};
+    auto save_indices = std::vector<std::size_t>{0, 2, 4, 6, 8, 10};
     {
       // Top level configuration
       config::DrivenSolverData driven_solver;
       REQUIRE_NOTHROW(driven_solver.SetUp(*config.find("driven_base_uniform_sample")));
 
-      for (size_t i = 0; i < sample_f.size(); ++i)
+      for (std::size_t i = 0; i < sample_f.size(); ++i)
       {
         CHECK_THAT(driven_solver.sample_f[i], WithinAbs(sample_f[i], delta_eps));
       }
@@ -156,7 +156,7 @@ TEST_CASE("Config Driven Solver", "[config][Serial]")
       config::DrivenSolverData driven_solver;
       REQUIRE_NOTHROW(driven_solver.SetUp(*config.find("driven_uniform_freq_step")));
 
-      for (size_t i = 0; i < sample_f.size(); ++i)
+      for (std::size_t i = 0; i < sample_f.size(); ++i)
       {
         CHECK_THAT(driven_solver.sample_f[i], WithinAbs(sample_f[i], delta_eps));
       }
@@ -170,9 +170,9 @@ TEST_CASE("Config Driven Solver", "[config][Serial]")
     REQUIRE_NOTHROW(driven_solver.SetUp(*config.find("driven_uniform_nsample")));
 
     auto sample_f = std::vector{0.0, 0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0};
-    auto save_indices = std::vector<size_t>{0, 2, 4, 6, 8};
+    auto save_indices = std::vector<std::size_t>{0, 2, 4, 6, 8};
 
-    for (size_t i = 0; i < sample_f.size(); ++i)
+    for (std::size_t i = 0; i < sample_f.size(); ++i)
     {
       CHECK_THAT(driven_solver.sample_f[i], WithinAbs(sample_f[i], delta_eps));
     }
@@ -185,10 +185,10 @@ TEST_CASE("Config Driven Solver", "[config][Serial]")
     REQUIRE_NOTHROW(driven_solver.SetUp(*config.find("driven_paired_uniform_sample")));
 
     auto sample_f = std::vector{0.0, 0.25, 0.5, 0.75, 1.0, 2.5, 5.0, 7.5, 10.0};
-    auto save_indices =
-        std::vector<size_t>{0, 2, 4, 5, 6, 7, 8};  // 0.0, 0.5, 1.0, 2.5, 5.0, 7.5, 10.0
+    auto save_indices = std::vector<std::size_t>{
+        0, 2, 4, 5, 6, 7, 8};  // 0.0, 0.5, 1.0, 2.5, 5.0, 7.5, 10.0
 
-    for (size_t i = 0; i < sample_f.size(); ++i)
+    for (std::size_t i = 0; i < sample_f.size(); ++i)
     {
       CHECK_THAT(driven_solver.sample_f[i], WithinAbs(sample_f[i], delta_eps));
     }
@@ -202,10 +202,10 @@ TEST_CASE("Config Driven Solver", "[config][Serial]")
 
     auto sample_f = std::vector{0.0, 0.125, 0.15,  0.25, 0.35,  0.375,
                                 0.5, 0.55,  0.625, 0.75, 0.875, 1.0};
-    auto save_indices = std::vector<size_t>{0, 2, 3, 4, 6, 7, 9, 11};
-    auto prom_indices = std::vector<size_t>{0, sample_f.size() - 1, 2, 4, 7};
+    auto save_indices = std::vector<std::size_t>{0, 2, 3, 4, 6, 7, 9, 11};
+    auto prom_indices = std::vector<std::size_t>{0, sample_f.size() - 1, 2, 4, 7};
 
-    for (size_t i = 0; i < sample_f.size(); ++i)
+    for (std::size_t i = 0; i < sample_f.size(); ++i)
     {
       CHECK_THAT(driven_solver.sample_f[i], WithinAbs(sample_f[i], delta_eps));
     }
@@ -219,10 +219,10 @@ TEST_CASE("Config Driven Solver", "[config][Serial]")
 
     auto sample_f = std::vector{0.1,  0.15, 0.1778279410038923, 0.31622776601683794,
                                 0.35, 0.55, 0.5623413251903491, 1.0};
-    auto save_indices = std::vector<size_t>{0, 1, 3, 4, 5, 7};
-    auto prom_indices = std::vector<size_t>{0, sample_f.size() - 1, 1, 4, 5};
+    auto save_indices = std::vector<std::size_t>{0, 1, 3, 4, 5, 7};
+    auto prom_indices = std::vector<std::size_t>{0, sample_f.size() - 1, 1, 4, 5};
 
-    for (size_t i = 0; i < sample_f.size(); ++i)
+    for (std::size_t i = 0; i < sample_f.size(); ++i)
     {
       CHECK_THAT(driven_solver.sample_f[i], WithinAbs(sample_f[i], delta_eps));
     }
diff --git a/test/unit/test-lumpedportintegration.cpp b/test/unit/test-lumpedportintegration.cpp
@@ -576,7 +576,7 @@ TEST_CASE("LumpedPort_BasicTests_3ElementPort_Cube321", "[lumped_port][Serial]")
 
   std::vector<std::array<double, 2>> expected_length_width = {{1., 1.}, {2., 1.}, {3., 1.}};
   // Properties of single rectangular element in port.
-  for (size_t i = 0; i < port_1.elems.size(); i++)
+  for (std::size_t i = 0; i < port_1.elems.size(); i++)
   {
     const auto [dl, dw] = expected_length_width.at(i);
     const auto *el_ptr = port_1.elems.at(i).get();
@@ -609,7 +609,7 @@ TEST_CASE("LumpedPort_BasicTests_3ElementPort_Cube321", "[lumped_port][Serial]")
 
   std::vector<int> perp_vec_dir_index = {0, 0, 1};
 
-  for (size_t i = 0; i < port_1.elems.size(); i++)
+  for (std::size_t i = 0; i < port_1.elems.size(); i++)
   {
     const auto *el_ptr = port_1.elems.at(i).get();
     REQUIRE(el_ptr != nullptr);
diff --git a/test/unit/test-postoperatorcsv.cpp b/test/unit/test-postoperatorcsv.cpp
@@ -91,7 +91,7 @@ class PostOperatorCSVFixture
         CHECK(post_op_csv.row_i == 0);
         CHECK(post_op_csv.ex_idx_i == 0);
         CHECK(post_op_csv.nr_expected_measurement_rows == 6);
-        CHECK(post_op_csv.ex_idx_v_all == std::vector<size_t>{1});
+        CHECK(post_op_csv.ex_idx_v_all == std::vector<std::size_t>{1});
         CHECK(post_op_csv.HasSingleExIdx());
         CHECK(!post_op_csv.reload_table);  // Default restart
         REQUIRE_NOTHROW(post_op_csv.InitializePortVI(space_op));
@@ -111,7 +111,7 @@ class PostOperatorCSVFixture
         CHECK(post_op_csv.row_i == 3);
         CHECK(post_op_csv.ex_idx_i == 0);
         CHECK(post_op_csv.nr_expected_measurement_rows == 6);
-        CHECK(post_op_csv.ex_idx_v_all == std::vector<size_t>{1});
+        CHECK(post_op_csv.ex_idx_v_all == std::vector<std::size_t>{1});
 
         CHECK_THROWS_WITH(post_op_csv.InitializePortVI(space_op),
                           Catch::Matchers::ContainsSubstring(
@@ -137,7 +137,7 @@ class PostOperatorCSVFixture
         CHECK(post_op_csv.row_i == 3);
         CHECK(post_op_csv.ex_idx_i == 0);
         CHECK(post_op_csv.nr_expected_measurement_rows == 6);
-        CHECK(post_op_csv.ex_idx_v_all == std::vector<size_t>{1});
+        CHECK(post_op_csv.ex_idx_v_all == std::vector<std::size_t>{1});
         CHECK(post_op_csv.HasSingleExIdx());
         CHECK(post_op_csv.reload_table);
 
@@ -180,7 +180,7 @@ class PostOperatorCSVFixture
         CHECK(post_op_csv.row_i == 0);
         CHECK(post_op_csv.ex_idx_i == 0);
         CHECK(post_op_csv.nr_expected_measurement_rows == 6);
-        CHECK(post_op_csv.ex_idx_v_all == std::vector<size_t>{1});
+        CHECK(post_op_csv.ex_idx_v_all == std::vector<std::size_t>{1});
 
         CHECK_NOTHROW(post_op_csv.InitializePortVI(space_op));
       }
@@ -195,7 +195,7 @@ class PostOperatorCSVFixture
         CHECK(post_op_csv.row_i == 5);
         CHECK(post_op_csv.ex_idx_i == 0);
         CHECK(post_op_csv.nr_expected_measurement_rows == 6);
-        CHECK(post_op_csv.ex_idx_v_all == std::vector<size_t>{1});
+        CHECK(post_op_csv.ex_idx_v_all == std::vector<std::size_t>{1});
 
         CHECK_THROWS_WITH(post_op_csv.InitializePortVI(space_op),
                           Catch::Matchers::ContainsSubstring(
@@ -220,7 +220,7 @@ class PostOperatorCSVFixture
         CHECK(post_op_csv.row_i == 0);
         CHECK(post_op_csv.ex_idx_i == 0);
         CHECK(post_op_csv.nr_expected_measurement_rows == 6);
-        CHECK(post_op_csv.ex_idx_v_all == std::vector<size_t>{1});
+        CHECK(post_op_csv.ex_idx_v_all == std::vector<std::size_t>{1});
         CHECK(post_op_csv.HasSingleExIdx());
         CHECK(!post_op_csv.reload_table);  // Default restart
 
@@ -304,7 +304,7 @@ class PostOperatorCSVFixture
         CHECK(post_op_csv.row_i == 3);
         CHECK(post_op_csv.ex_idx_i == 0);
         CHECK(post_op_csv.nr_expected_measurement_rows == 6);
-        CHECK(post_op_csv.ex_idx_v_all == std::vector<size_t>{1, 2});
+        CHECK(post_op_csv.ex_idx_v_all == std::vector<std::size_t>{1, 2});
         CHECK(!post_op_csv.HasSingleExIdx());
         CHECK(post_op_csv.reload_table);
 
@@ -354,7 +354,7 @@ class PostOperatorCSVFixture
         CHECK(post_op_csv.row_i == 0);
         CHECK(post_op_csv.ex_idx_i == 0);
         CHECK(post_op_csv.nr_expected_measurement_rows == 6);
-        CHECK(post_op_csv.ex_idx_v_all == std::vector<size_t>{1, 2});
+        CHECK(post_op_csv.ex_idx_v_all == std::vector<std::size_t>{1, 2});
 
         // No throw since 1 restart just overwrite existing table.
         CHECK_NOTHROW(post_op_csv.InitializePortVI(space_op));
@@ -370,7 +370,7 @@ class PostOperatorCSVFixture
         CHECK(post_op_csv.row_i == 1);
         CHECK(post_op_csv.ex_idx_i == 1);
         CHECK(post_op_csv.nr_expected_measurement_rows == 6);
-        CHECK(post_op_csv.ex_idx_v_all == std::vector<size_t>{1, 2});
+        CHECK(post_op_csv.ex_idx_v_all == std::vector<std::size_t>{1, 2});
 
         CHECK_THROWS_WITH(post_op_csv.InitializePortVI(space_op),
                           Catch::Matchers::ContainsSubstring(
@@ -396,7 +396,7 @@ class PostOperatorCSVFixture
         CHECK(post_op_csv.row_i == 4);
         CHECK(post_op_csv.ex_idx_i == 1);
         CHECK(post_op_csv.nr_expected_measurement_rows == 6);
-        CHECK(post_op_csv.ex_idx_v_all == std::vector<size_t>{1, 2});
+        CHECK(post_op_csv.ex_idx_v_all == std::vector<std::size_t>{1, 2});
         CHECK(!post_op_csv.HasSingleExIdx());
         CHECK(post_op_csv.reload_table);
 
diff --git a/test/unit/test-romoperator.cpp b/test/unit/test-romoperator.cpp
diff --git a/test/unit/test-strattonchu.cpp b/test/unit/test-strattonchu.cpp
diff --git a/test/unit/test-tablecsv.cpp b/test/unit/test-tablecsv.cpp

Original file line number	Diff line number	Diff line change
`@@ -292,7 +292,7 @@ int PrecIndexCol(const ProblemType solver_t)`
`292`	`292`	`// Index checking when adding to a new excitation block: When adding data to data_col with`
`293`	`293`	`// index idx, checks that idx matches what is already written in the corresponding row of`
`294`	`294`	`// idx_col. Adds a new idx row to idx_col if needed.`
`295`		`-void CheckAppendIndex(Column &idx_col, double idx_value, size_t m_idx_row)`
	`295`	`+void CheckAppendIndex(Column &idx_col, double idx_value, std::size_t m_idx_row)`
`296`	`296`	`{`
`297`	`297`	`if (m_idx_row == idx_col.n_rows())`
`298`	`298`	`{`
`@@ -656,7 +656,7 @@ auto PostOperatorCSV<solver_t>::PrintFarFieldE(const SurfacePostOperator &surf_p`
`656`	`656`	`}`
`657`	`657`	`using fmt::format;`
`658`	`658`	`int v_dim = surf_post_op.GetVDim();`
`659`		`- for (size_t i = 0; i < measurement_cache.farfield.thetaphis.size(); i++)`
	`659`	`+ for (std::size_t i = 0; i < measurement_cache.farfield.thetaphis.size(); i++)`
`660`	`660`	`{`
`661`	`661`	`farfield_E->table["idx"] << row_idx_v;`
`662`	`662`	`if constexpr (U == ProblemType::EIGENMODE)`
`@@ -740,7 +740,7 @@ void PostOperatorCSV<solver_t>::PrintProbeE(const InterpolationOperator &interp_`
`740`	`740`
`741`	`741`	`CheckAppendIndex(probe_E->table["idx"], row_idx_v, row_i);`
`742`	`742`
`743`		`- size_t i = 0;`
	`743`	`+ std::size_t i = 0;`
`744`	`744`	`for (const auto &idx : interp_op.GetProbes())`
`745`	`745`	`{`
`746`	`746`	`for (int i_dim = 0; i_dim < v_dim; i_dim++)`
`@@ -818,7 +818,7 @@ void PostOperatorCSV<solver_t>::PrintProbeB(const InterpolationOperator &interp_`
`818`	`818`
`819`	`819`	`CheckAppendIndex(probe_B->table["idx"], row_idx_v, row_i);`
`820`	`820`
`821`		`- size_t i = 0;`
	`821`	`+ std::size_t i = 0;`
`822`	`822`	`for (const auto &idx : interp_op.GetProbes())`
`823`	`823`	`{`
`824`	`824`	`for (int i_dim = 0; i_dim < v_dim; i_dim++)`
Original file line number	Diff line number	Diff line change
`@@ -120,7 +120,7 @@ void AddStrattonChuIntegrandAtElement(const GridFunction &E, const GridFunction`
`120`	`120`	`// This is a hot loop. Manually unrolling and avoiding Vectors significantly`
`121`	`121`	`// increases performance.`
`122`	`122`	`PalacePragmaOmp(parallel for schedule(static))`
`123`		`- for (size_t i = 0; i < r_naughts.size(); i++)`
	`123`	`+ for (std::size_t i = 0; i < r_naughts.size(); i++)`
`124`	`124`	`{`
`125`	`125`	`const auto &r = r_naughts[i];`
`126`	`126`
Original file line number	Diff line number	Diff line change
`@@ -17,16 +17,16 @@`
`17`	`17`	`namespace palace`
`18`	`18`	`{`
`19`	`19`
`20`		`-[[nodiscard]] size_t Column::col_width(const ColumnOptions &defaults) const`
	`20`	`+[[nodiscard]] std::size_t Column::col_width(const ColumnOptions &defaults) const`
`21`	`21`	`{`
`22`	`22`	`// Quickfix to specify full column width in integer case to match current formatting.`
`23`	`23`	`if (print_as_int)`
`24`	`24`	`{`
`25`	`25`	`return std::max(min_left_padding.value_or(defaults.min_left_padding),`
`26`	`26`	`header_text.size());`
`27`	`27`	`}`
`28`		`- size_t pad = min_left_padding.value_or(defaults.min_left_padding);`
`29`		`- size_t prec = float_precision.value_or(defaults.float_precision);`
	`28`	`+ std::size_t pad = min_left_padding.value_or(defaults.min_left_padding);`
	`29`	`+ std::size_t prec = float_precision.value_or(defaults.float_precision);`
`30`	`30`
`31`	`31`	`// Normal float in our exponent format needs float_precision + 7 ("+" , leading digit,`
`32`	`32`	`// ".", "e", "+", +2 exponent. Sometimes exponent maybe +3 if very small or large; see`
`@@ -36,14 +36,14 @@ namespace palace`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`[[nodiscard]] auto Column::format_header(const ColumnOptions &defaults,`
`39`		`- const std::optional<size_t> &width) const`
	`39`	`+ const std::optional<std::size_t> &width) const`
`40`	`40`	`{`
`41`	`41`	`auto w = width.value_or(col_width(defaults));`
`42`	`42`	`return fmt::format("{0:>{1}s}", header_text, w);`
`43`	`43`	`}`
`44`	`44`
`45`		`-[[nodiscard]] auto Column::format_row(size_t i, const ColumnOptions &defaults,`
`46`		`- const std::optional<size_t> &width) const`
	`45`	`+[[nodiscard]] auto Column::format_row(std::size_t i, const ColumnOptions &defaults,`
	`46`	`+ const std::optional<std::size_t> &width) const`
`47`	`47`	`{`
`48`	`48`	`auto width_ = width.value_or(col_width(defaults));`
`49`	`49`	`// If data available format double.`
`@@ -68,15 +68,16 @@ namespace palace`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`Column::Column(std::string name_, std::string header_text_, long column_group_idx_,`
`71`		`- std::optional<size_t> min_left_padding_,`
`72`		`- std::optional<size_t> float_precision_, std::optional<std::string> fmt_sign_)`
	`71`	`+ std::optional<std::size_t> min_left_padding_,`
	`72`	`+ std::optional<std::size_t> float_precision_,`
	`73`	`+ std::optional<std::string> fmt_sign_)`
`73`	`74`	`: name(std::move(name_)), header_text(std::move(header_text_)),`
`74`	`75`	`column_group_idx(column_group_idx_), min_left_padding(min_left_padding_),`
`75`	`76`	`float_precision(float_precision_), fmt_sign(std::move(fmt_sign_))`
`76`	`77`	`{`
`77`	`78`	`}`
`78`	`79`
`79`		`-[[nodiscard]] size_t Table::n_rows() const`
	`80`	`+[[nodiscard]] std::size_t Table::n_rows() const`
`80`	`81`	`{`
`81`	`82`	`if (n_cols() == 0)`
`82`	`83`	`{`
`@@ -87,7 +88,7 @@ Column::Column(std::string name_, std::string header_text_, long column_group_id`
`87`	`88`	`return max_col->n_rows();`
`88`	`89`	`}`
`89`	`90`
`90`		`-void Table::reserve(size_t n_rows, size_t n_cols)`
	`91`	`+void Table::reserve(std::size_t n_rows, std::size_t n_cols)`
`91`	`92`	`{`
`92`	`93`	`reserve_n_rows = n_rows;`
`93`	`94`	`cols.reserve(n_cols);`
`@@ -127,7 +128,7 @@ Column &Table::operator[](std::string_view name)`
`127`	`128`	`template <typename T>`
`128`	`129`	`void Table::append_header(T &buf) const`
`129`	`130`	`{`
`130`		`- for (size_t i = 0; i < n_cols(); i++)`
	`131`	`+ for (std::size_t i = 0; i < n_cols(); i++)`
`131`	`132`	`{`
`132`	`133`	`if (i > 0)`
`133`	`134`	`{`
`@@ -139,9 +140,9 @@ void Table::append_header(T &buf) const`
`139`	`140`	`}`
`140`	`141`
`141`	`142`	`template <typename T>`
`142`		`-void Table::append_row(T &buf, size_t row_j) const`
	`143`	`+void Table::append_row(T &buf, std::size_t row_j) const`
`143`	`144`	`{`
`144`		`- for (size_t i = 0; i < n_cols(); i++)`
	`145`	`+ for (std::size_t i = 0; i < n_cols(); i++)`
`145`	`146`	`{`
`146`	`147`	`if (i > 0)`
`147`	`148`	`{`
`@@ -159,7 +160,7 @@ void Table::append_row(T &buf, size_t row_j) const`
`159`	`160`	`return {buf.data(), buf.size()};`
`160`	`161`	`}`
`161`	`162`
`162`		`-[[nodiscard]] std::string Table::format_row(size_t j) const`
	`163`	`+[[nodiscard]] std::string Table::format_row(std::size_t j) const`
`163`	`164`	`{`
`164`	`165`	`fmt::memory_buffer buf{};`
`165`	`166`	`append_row(buf, j);`
`@@ -170,7 +171,7 @@ void Table::append_row(T &buf, size_t row_j) const`
`170`	`171`	`{`
`171`	`172`	`fmt::memory_buffer buf{};`
`172`	`173`	`append_header(buf);`
`173`		`- for (size_t j = 0; j < n_rows(); j++)`
	`174`	`+ for (std::size_t j = 0; j < n_rows(); j++)`
`174`	`175`	`{`
`175`	`176`	`append_row(buf, j);`
`176`	`177`	`}`
`@@ -273,7 +274,7 @@ Table::Table(std::string_view table_str,`
`273`	`274`
`274`	`275`	`// explicit instantiation to avoid fmt inclusion.`
`275`	`276`	`template void Table::append_header(fmt::memory_buffer &) const;`
`276`		`-template void Table::append_row(fmt::memory_buffer &, size_t) const;`
	`277`	`+template void Table::append_row(fmt::memory_buffer &, std::size_t) const;`
`277`	`278`
`278`	`279`	`TableWithCSVFile::TableWithCSVFile(std::string csv_file_fullpath, bool load_existing_file)`
`279`	`280`	`: csv_file_fullpath_{std::move(csv_file_fullpath)}`
Original file line number	Diff line number	Diff line change
`@@ -138,13 +138,13 @@ TEST_CASE("Config Driven Solver", "[config][Serial]")`
`138`	`138`	`constexpr double delta_eps = 1.0e-9; // Precision in frequency comparisons (Hz)`
`139`	`139`	`{`
`140`	`140`	`auto sample_f = std::vector{0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1};`
`141`		`- auto save_indices = std::vector<size_t>{0, 2, 4, 6, 8, 10};`
	`141`	`+ auto save_indices = std::vector<std::size_t>{0, 2, 4, 6, 8, 10};`
`142`	`142`	`{`
`143`	`143`	`// Top level configuration`
`144`	`144`	`config::DrivenSolverData driven_solver;`
`145`	`145`	`REQUIRE_NOTHROW(driven_solver.SetUp(*config.find("driven_base_uniform_sample")));`
`146`	`146`
`147`		`- for (size_t i = 0; i < sample_f.size(); ++i)`
	`147`	`+ for (std::size_t i = 0; i < sample_f.size(); ++i)`
`148`	`148`	`{`
`149`	`149`	`CHECK_THAT(driven_solver.sample_f[i], WithinAbs(sample_f[i], delta_eps));`
`150`	`150`	`}`
`@@ -156,7 +156,7 @@ TEST_CASE("Config Driven Solver", "[config][Serial]")`
`156`	`156`	`config::DrivenSolverData driven_solver;`
`157`	`157`	`REQUIRE_NOTHROW(driven_solver.SetUp(*config.find("driven_uniform_freq_step")));`
`158`	`158`
`159`		`- for (size_t i = 0; i < sample_f.size(); ++i)`
	`159`	`+ for (std::size_t i = 0; i < sample_f.size(); ++i)`
`160`	`160`	`{`
`161`	`161`	`CHECK_THAT(driven_solver.sample_f[i], WithinAbs(sample_f[i], delta_eps));`
`162`	`162`	`}`
`@@ -170,9 +170,9 @@ TEST_CASE("Config Driven Solver", "[config][Serial]")`
`170`	`170`	`REQUIRE_NOTHROW(driven_solver.SetUp(*config.find("driven_uniform_nsample")));`
`171`	`171`
`172`	`172`	`auto sample_f = std::vector{0.0, 0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0};`
`173`		`- auto save_indices = std::vector<size_t>{0, 2, 4, 6, 8};`
	`173`	`+ auto save_indices = std::vector<std::size_t>{0, 2, 4, 6, 8};`
`174`	`174`
`175`		`- for (size_t i = 0; i < sample_f.size(); ++i)`
	`175`	`+ for (std::size_t i = 0; i < sample_f.size(); ++i)`
`176`	`176`	`{`
`177`	`177`	`CHECK_THAT(driven_solver.sample_f[i], WithinAbs(sample_f[i], delta_eps));`
`178`	`178`	`}`
`@@ -185,10 +185,10 @@ TEST_CASE("Config Driven Solver", "[config][Serial]")`
`185`	`185`	`REQUIRE_NOTHROW(driven_solver.SetUp(*config.find("driven_paired_uniform_sample")));`
`186`	`186`
`187`	`187`	`auto sample_f = std::vector{0.0, 0.25, 0.5, 0.75, 1.0, 2.5, 5.0, 7.5, 10.0};`
`188`		`- auto save_indices =`
`189`		`- std::vector<size_t>{0, 2, 4, 5, 6, 7, 8}; // 0.0, 0.5, 1.0, 2.5, 5.0, 7.5, 10.0`
	`188`	`+ auto save_indices = std::vector<std::size_t>{`
	`189`	`+ 0, 2, 4, 5, 6, 7, 8}; // 0.0, 0.5, 1.0, 2.5, 5.0, 7.5, 10.0`
`190`	`190`
`191`		`- for (size_t i = 0; i < sample_f.size(); ++i)`
	`191`	`+ for (std::size_t i = 0; i < sample_f.size(); ++i)`
`192`	`192`	`{`
`193`	`193`	`CHECK_THAT(driven_solver.sample_f[i], WithinAbs(sample_f[i], delta_eps));`
`194`	`194`	`}`
`@@ -202,10 +202,10 @@ TEST_CASE("Config Driven Solver", "[config][Serial]")`
`202`	`202`
`203`	`203`	`auto sample_f = std::vector{0.0, 0.125, 0.15, 0.25, 0.35, 0.375,`
`204`	`204`	`0.5, 0.55, 0.625, 0.75, 0.875, 1.0};`
`205`		`- auto save_indices = std::vector<size_t>{0, 2, 3, 4, 6, 7, 9, 11};`
`206`		`- auto prom_indices = std::vector<size_t>{0, sample_f.size() - 1, 2, 4, 7};`
	`205`	`+ auto save_indices = std::vector<std::size_t>{0, 2, 3, 4, 6, 7, 9, 11};`
	`206`	`+ auto prom_indices = std::vector<std::size_t>{0, sample_f.size() - 1, 2, 4, 7};`
`207`	`207`
`208`		`- for (size_t i = 0; i < sample_f.size(); ++i)`
	`208`	`+ for (std::size_t i = 0; i < sample_f.size(); ++i)`
`209`	`209`	`{`
`210`	`210`	`CHECK_THAT(driven_solver.sample_f[i], WithinAbs(sample_f[i], delta_eps));`
`211`	`211`	`}`
`@@ -219,10 +219,10 @@ TEST_CASE("Config Driven Solver", "[config][Serial]")`
`219`	`219`
`220`	`220`	`auto sample_f = std::vector{0.1, 0.15, 0.1778279410038923, 0.31622776601683794,`
`221`	`221`	`0.35, 0.55, 0.5623413251903491, 1.0};`
`222`		`- auto save_indices = std::vector<size_t>{0, 1, 3, 4, 5, 7};`
`223`		`- auto prom_indices = std::vector<size_t>{0, sample_f.size() - 1, 1, 4, 5};`
	`222`	`+ auto save_indices = std::vector<std::size_t>{0, 1, 3, 4, 5, 7};`
	`223`	`+ auto prom_indices = std::vector<std::size_t>{0, sample_f.size() - 1, 1, 4, 5};`
`224`	`224`
`225`		`- for (size_t i = 0; i < sample_f.size(); ++i)`
	`225`	`+ for (std::size_t i = 0; i < sample_f.size(); ++i)`
`226`	`226`	`{`
`227`	`227`	`CHECK_THAT(driven_solver.sample_f[i], WithinAbs(sample_f[i], delta_eps));`
`228`	`228`	`}`
Original file line number	Diff line number	Diff line change
`@@ -576,7 +576,7 @@ TEST_CASE("LumpedPort_BasicTests_3ElementPort_Cube321", "[lumped_port][Serial]")`
`576`	`576`
`577`	`577`	`std::vector<std::array<double, 2>> expected_length_width = {{1., 1.}, {2., 1.}, {3., 1.}};`
`578`	`578`	`// Properties of single rectangular element in port.`
`579`		`- for (size_t i = 0; i < port_1.elems.size(); i++)`
	`579`	`+ for (std::size_t i = 0; i < port_1.elems.size(); i++)`
`580`	`580`	`{`
`581`	`581`	`const auto [dl, dw] = expected_length_width.at(i);`
`582`	`582`	`const auto *el_ptr = port_1.elems.at(i).get();`
`@@ -609,7 +609,7 @@ TEST_CASE("LumpedPort_BasicTests_3ElementPort_Cube321", "[lumped_port][Serial]")`
`609`	`609`
`610`	`610`	`std::vector<int> perp_vec_dir_index = {0, 0, 1};`
`611`	`611`
`612`		`- for (size_t i = 0; i < port_1.elems.size(); i++)`
	`612`	`+ for (std::size_t i = 0; i < port_1.elems.size(); i++)`
`613`	`613`	`{`
`614`	`614`	`const auto *el_ptr = port_1.elems.at(i).get();`
`615`	`615`	`REQUIRE(el_ptr != nullptr);`