Stopping using variables names shorter than 3 characters

Author: php1ic

include/inch/converter.hpp

@@ -30,7 +30,7 @@ class Converter
   Converter(const Converter&) = default;
   Converter(Converter&&)      = default;
 
-  Converter& operator=(Converter&&) = default;
+  Converter& operator=(Converter&&)      = default;
   Converter& operator=(const Converter&) = default;
 
   ~Converter() = default;
@@ -48,7 +48,7 @@ class Converter
   using seconds      = std::chrono::duration<double, std::ratio<1, 1>>;
   using minutes      = std::chrono::duration<double, std::ratio<60, 1>>;
   using hours        = std::chrono::duration<double, std::ratio<3600, 1>>;
-  using days         = std::chrono::duration<double, std::ratio<24 * 3600, 1>>;
+  using days         = std::chrono::duration<double, std::ratio<static_cast<intmax_t>(24 * 3600), 1>>;
   using years        = std::chrono::duration<double, std::ratio<year, 1>>;
   using kiloyears    = std::chrono::duration<double, std::ratio<1000 * year, 1>>;
   using millionyears = std::chrono::duration<double, std::ratio<1000000 * year, 1>>;
@@ -122,7 +122,7 @@ class Converter
    *
    * \return std::tuple of std:string containing Ax10^{BC} where B is either +/-, A and C are decimal numbers
    */
-  [[nodiscard]] static std::tuple<std::string, std::string, std::string> FloatToExponent(const double in);
+  [[nodiscard]] static std::tuple<std::string, std::string, std::string> FloatToExponent(const double value);
 
   /**
    * Convert a floating point number to a std::string with the specified number of dp
@@ -145,7 +145,7 @@ class Converter
    *
    * \return A std::string of the given number with required precision and sensible units
    */
-  [[nodiscard]] static std::string IsomerEnergyToHuman(const double in, const int numDP = 1);
+  [[nodiscard]] static std::string IsomerEnergyToHuman(const double number, const int numDP = 1);
 
   /**
    * Convert a time, in units of seconds, into scientific parlance i.e. 2.3ms rather than 0.0023s
@@ -170,7 +170,7 @@ class Converter
    *
    * \return The symbol as a std:string
    */
-  [[nodiscard]] static std::string ZToSymbol(const int Z);
+  [[nodiscard]] static std::string ZToSymbol(const int proton_number);
 
   /**
    * Convert elemental symbol to proton number

src/converter.cpp

@@ -25,20 +25,20 @@ int Converter::StringToInt(const std::string& var)
 }
 
 
-std::string Converter::ZToSymbol(const int Z)
+std::string Converter::ZToSymbol(const int proton_number)
 {
-  const auto it = std::find_if(symbolZmap.cbegin(), symbolZmap.cend(), [Z](const std::pair<std::string, int>& element) {
-    return element.second == Z;
+  const auto match = std::find_if(symbolZmap.cbegin(), symbolZmap.cend(), [proton_number](const auto element) {
+    return element.second == proton_number;
   });
 
   return [&]() {
-    if (it == symbolZmap.end())
+    if (match == symbolZmap.end())
       {
-        fmt::print("\n**WARNING**: {} is not a valid proton number\n", Z);
+        fmt::print("\n**WARNING**: {} is not a valid proton number\n", proton_number);
         return std::string{ "Xy" };
       }
 
-    return it->first;
+    return match->first;
   }();
 }
 
@@ -47,19 +47,17 @@ int Converter::SymbolToZ(std::string _symbol)
 {
   const std::string symbol = caseCorrection(std::move(_symbol));
 
-  const auto it =
-      std::find_if(symbolZmap.cbegin(), symbolZmap.cend(), [&symbol](const std::pair<std::string, int>& element) {
-        return element.first == symbol;
-      });
+  const auto match = std::find_if(
+      symbolZmap.cbegin(), symbolZmap.cend(), [&symbol](const auto element) { return element.first == symbol; });
 
   return [&]() {
-    if (it == symbolZmap.end())
+    if (match == symbolZmap.end())
       {
         fmt::print("\n**WARNING**: {} is not a valid symbol\n", symbol);
         return 200;
       }
 
-    return it->second;
+    return match->second;
   }();
 }
 
@@ -86,29 +84,30 @@ std::string Converter::caseCorrection(std::string symbol)
 }
 
 
-std::tuple<std::string, std::string, std::string> Converter::FloatToExponent(const double in)
+std::tuple<std::string, std::string, std::string> Converter::FloatToExponent(const double value)
 {
   // Force the number to be scientific, i.e. follow the regex: -?\d*\.?\d+e[+-]?\d+
-  const std::string number = fmt::format("{0:e}", in);
+  const auto number = fmt::format("{0:e}", value);
 
   const std::regex pieces_regex(R"((-?\d*\.?\d+)e([+-]?)(\d+))");
   std::smatch matches;
 
   // Always get 1dp from the first number
   // If it's negative take an extra char for the sign
-  const int digits = (in < 0.0) ? 4 : 3;
+  const int digits = (value < 0.0) ? 4 : 3;
 
   return (std::regex_match(number, matches, pieces_regex))
              //              coefficient(1dp)               exponent sign            exponent
              ? std::make_tuple(
-                 std::string(matches[1]).substr(0, digits), std::string(matches[2]), std::string(matches[3]))
-             : std::make_tuple(std::string(), std::string(), std::string());
+                 std::string{ matches[1] }.substr(0, digits), std::string{ matches[2] }, std::string{ matches[3] })
+             : std::make_tuple(std::string{}, std::string{}, std::string{});
 }
 
 
-std::string Converter::IsomerEnergyToHuman(const double in, const int numDP)
+std::string Converter::IsomerEnergyToHuman(const double number, const int numDP)
 {
-  return (in < 1000.0) ? fmt::format("{0:0.{1}f} keV", in, numDP) : fmt::format("{0:0.{1}f} MeV", in / 1000.0, numDP);
+  return (number < 1000.0) ? fmt::format("{0:0.{1}f} keV", number, numDP)
+                           : fmt::format("{0:0.{1}f} MeV", number / 1000.0, numDP);
 }