style: clang-format applied to the remaining files

example/aliases/avg_speed.cpp

@@ -21,12 +21,12 @@
 // SOFTWARE.
 
 #include <units/isq/si/cgs/length.h>
-#include <units/isq/si/cgs/speed.h> // IWYU pragma: keep
+#include <units/isq/si/cgs/speed.h>  // IWYU pragma: keep
 #include <units/isq/si/international/length.h>
-#include <units/isq/si/international/speed.h> // IWYU pragma: keep
-#include <units/isq/si/length.h> // IWYU pragma: keep
-#include <units/isq/si/time.h>
+#include <units/isq/si/international/speed.h>  // IWYU pragma: keep
+#include <units/isq/si/length.h>               // IWYU pragma: keep
 #include <units/isq/si/speed.h>
+#include <units/isq/si/time.h>
 #include <units/quantity_io.h>
 #include <exception>
 #include <iostream>
@@ -35,38 +35,31 @@ namespace {
 
 using namespace units::isq;
 
-constexpr si::speed<si::metre_per_second, int>
-fixed_int_si_avg_speed(si::length<si::metre, int> d,
-                       si::time<si::second, int> t)
+constexpr si::speed<si::metre_per_second, int> fixed_int_si_avg_speed(si::length<si::metre, int> d,
+                                                                      si::time<si::second, int> t)
 {
   return d / t;
 }
 
-constexpr si::speed<si::metre_per_second>
-fixed_double_si_avg_speed(si::length<si::metre> d,
-                          si::time<si::second> t)
+constexpr si::speed<si::metre_per_second> fixed_double_si_avg_speed(si::length<si::metre> d, si::time<si::second> t)
 {
   return d / t;
 }
 
 template<typename U1, typename R1, typename U2, typename R2>
-constexpr Speed auto si_avg_speed(si::length<U1, R1> d,
-                                  si::time<U2, R2> t)
+constexpr Speed auto si_avg_speed(si::length<U1, R1> d, si::time<U2, R2> t)
 {
   return d / t;
 }
 
-constexpr Speed auto avg_speed(Length auto d, Time auto t)
-{
-  return d / t;
-}
+constexpr Speed auto avg_speed(Length auto d, Time auto t) { return d / t; }
 
 template<Length D, Time T, Speed V>
 void print_result(D distance, T duration, V speed)
 {
   const auto result_in_kmph = units::quantity_cast<si::speed<si::kilometre_per_hour>>(speed);
-  std::cout << "Average speed of a car that makes " << distance << " in "
-            << duration << " is " << result_in_kmph << ".\n";
+  std::cout << "Average speed of a car that makes " << distance << " in " << duration << " is " << result_in_kmph
+            << ".\n";
 }
 
 void example()
@@ -94,7 +87,8 @@ void example()
     std::cout << "\nSI units with 'double' as representation\n";
 
     // conversion from a floating-point to an integral type is a truncating one so an explicit cast is needed
-    print_result(distance, duration, fixed_int_si_avg_speed(quantity_cast<int>(distance), quantity_cast<int>(duration)));
+    print_result(distance, duration,
+                 fixed_int_si_avg_speed(quantity_cast<int>(distance), quantity_cast<int>(duration)));
 
     print_result(distance, duration, fixed_double_si_avg_speed(distance, duration));
     print_result(distance, duration, si_avg_speed(distance, duration));
@@ -130,7 +124,9 @@ void example()
     // conversion from a floating-point to an integral type is a truncating one so an explicit cast is needed
     // also it is not possible to make a lossless conversion of miles to meters on an integral type
     // (explicit cast needed)
-    print_result(distance, duration, fixed_int_si_avg_speed(quantity_cast<si::length<si::metre, int>>(distance), quantity_cast<int>(duration)));
+    print_result(
+      distance, duration,
+      fixed_int_si_avg_speed(quantity_cast<si::length<si::metre, int>>(distance), quantity_cast<int>(duration)));
 
     print_result(distance, duration, fixed_double_si_avg_speed(distance, duration));
     print_result(distance, duration, si_avg_speed(distance, duration));
@@ -169,7 +165,9 @@ void example()
     // conversion from a floating-point to an integral type is a truncating one so an explicit cast is needed
     // it is not possible to make a lossless conversion of centimeters to meters on an integral type
     // (explicit cast needed)
-    print_result(distance, duration, fixed_int_si_avg_speed(quantity_cast<si::length<si::metre, int>>(distance), quantity_cast<int>(duration)));
+    print_result(
+      distance, duration,
+      fixed_int_si_avg_speed(quantity_cast<si::length<si::metre, int>>(distance), quantity_cast<int>(duration)));
 
     print_result(distance, duration, fixed_double_si_avg_speed(distance, duration));
 
@@ -178,20 +176,17 @@ void example()
 
     print_result(distance, duration, avg_speed(distance, duration));
   }
-
 }
 
-} // namespace
+}  // namespace
 
 int main()
 {
   try {
     example();
-  }
-  catch (const std::exception& ex) {
+  } catch (const std::exception& ex) {
     std::cerr << "Unhandled std exception caught: " << ex.what() << '\n';
-  }
-  catch (...) {
+  } catch (...) {
     std::cerr << "Unhandled unknown exception caught\n";
   }
 }

example/aliases/box_example.cpp

@@ -29,7 +29,7 @@
 #include <units/isq/si/force.h>
 #include <units/isq/si/length.h>
 #include <units/isq/si/mass.h>
-#include <units/isq/si/speed.h> // IWYU pragma: keep
+#include <units/isq/si/speed.h>  // IWYU pragma: keep
 #include <units/isq/si/time.h>
 #include <units/isq/si/volume.h>
 #include <cassert>
@@ -40,7 +40,7 @@ namespace {
 
 using namespace units::aliases::isq::si;
 
-inline constexpr auto g = units::isq::si::si2019::standard_gravity<>;
+inline constexpr auto g = units::isq::si::si2019::standard_gravity<>;  // NOLINT(readability-identifier-length)
 inline constexpr auto air_density = kg_per_m3<>(1.225);
 
 class Box {
@@ -48,7 +48,10 @@ class Box {
   length::m<> height_;
   density::kg_per_m3<> density_ = air_density;
 public:
-  constexpr Box(const length::m<>& length, const length::m<>& width, length::m<> height): base_(length * width), height_(std::move(height)) {}
+  constexpr Box(const length::m<>& length, const length::m<>& width, length::m<> height) :
+      base_(length * width), height_(std::move(height))
+  {
+  }
 
   [[nodiscard]] constexpr force::N<> filled_weight() const
   {
@@ -86,13 +89,13 @@ int main()
   auto box = Box(mm<>(1000.0), mm<>(500.0), height);
   box.set_contents_density(kg_per_m3<>(1000.0));
 
-  const auto fill_time = s<>(200.0);        // time since starting fill
-  const auto measured_mass = kg<>(20.0);    // measured mass at fill_time
+  const auto fill_time = s<>(200.0);      // time since starting fill
+  const auto measured_mass = kg<>(20.0);  // measured mass at fill_time
 
   const Length auto fill_level = box.fill_level(measured_mass);
   const Dimensionless auto fill_percent = quantity_cast<percent>(fill_level / height);
   const Volume auto spare_capacity = box.spare_capacity(measured_mass);
-  const auto input_flow_rate = measured_mass / fill_time;    // unknown dimension
+  const auto input_flow_rate = measured_mass / fill_time;  // unknown dimension
   const Speed auto float_rise_rate = fill_level / fill_time;
   const Time auto fill_time_left = (height / fill_level - 1) * fill_time;
 

example/aliases/capacitor_time_curve.cpp

@@ -25,7 +25,7 @@
 #include <units/isq/si/resistance.h>
 #include <units/isq/si/time.h>
 #include <units/isq/si/voltage.h>
-#include <units/math.h> // IWYU pragma: keep
+#include <units/math.h>  // IWYU pragma: keep
 #include <units/quantity_io.h>
 #include <iostream>
 

example/aliases/foot_pound_second.cpp

@@ -52,7 +52,7 @@ struct Ship {
 };
 
 // Print 'a' in its current units and print its value cast to the units in each of Args
-template<class ...Args, units::Quantity Q>
+template<class... Args, units::Quantity Q>
 auto fmt_line(const Q a)
 {
   return STD_FMT::format("{:22}", a) + (STD_FMT::format(",{:20}", units::quantity_cast<Args>(a)) + ...);
@@ -63,16 +63,21 @@ void print_details(std::string_view description, const Ship& ship)
 {
   const auto waterDensity = si::fps::density::lb_per_ft3<>(62.4);
   std::cout << STD_FMT::format("{}\n", description);
-  std::cout << STD_FMT::format("{:20} : {}\n", "length",    fmt_line<si::fps::length::yd<>, si::length::m<>>(ship.length))
-            << STD_FMT::format("{:20} : {}\n", "draft",     fmt_line<si::fps::length::yd<>, si::length::m<>>(ship.draft))
-            << STD_FMT::format("{:20} : {}\n", "beam",      fmt_line<si::fps::length::yd<>, si::length::m<>>(ship.beam))
-            << STD_FMT::format("{:20} : {}\n", "mass",      fmt_line<si::fps::mass::lton<>, si::mass::t<>>(ship.mass))
-            << STD_FMT::format("{:20} : {}\n", "speed",     fmt_line<si::fps::speed::knot<>, si::speed::km_per_h<>>(ship.speed))
-            << STD_FMT::format("{:20} : {}\n", "power",     fmt_line<si::fps::power::hp<>, si::power::kW<>>(ship.power))
-            << STD_FMT::format("{:20} : {}\n", "main guns", fmt_line<si::fps::length::in<>, si::length::mm<>>(ship.mainGuns))
-            << STD_FMT::format("{:20} : {}\n", "fire shells weighing",fmt_line<si::fps::mass::lton<>, si::mass::kg<>>(ship.shellMass))
-            << STD_FMT::format("{:20} : {}\n", "fire shells at",fmt_line<si::fps::speed::mph<>, si::speed::km_per_h<>>(ship.shellSpeed))
-            << STD_FMT::format("{:20} : {}\n", "volume underwater", fmt_line<si::volume::m3<>, si::volume::l<>>(ship.mass / waterDensity));
+  std::cout << STD_FMT::format("{:20} : {}\n", "length", fmt_line<si::fps::length::yd<>, si::length::m<>>(ship.length))
+            << STD_FMT::format("{:20} : {}\n", "draft", fmt_line<si::fps::length::yd<>, si::length::m<>>(ship.draft))
+            << STD_FMT::format("{:20} : {}\n", "beam", fmt_line<si::fps::length::yd<>, si::length::m<>>(ship.beam))
+            << STD_FMT::format("{:20} : {}\n", "mass", fmt_line<si::fps::mass::lton<>, si::mass::t<>>(ship.mass))
+            << STD_FMT::format("{:20} : {}\n", "speed",
+                               fmt_line<si::fps::speed::knot<>, si::speed::km_per_h<>>(ship.speed))
+            << STD_FMT::format("{:20} : {}\n", "power", fmt_line<si::fps::power::hp<>, si::power::kW<>>(ship.power))
+            << STD_FMT::format("{:20} : {}\n", "main guns",
+                               fmt_line<si::fps::length::in<>, si::length::mm<>>(ship.mainGuns))
+            << STD_FMT::format("{:20} : {}\n", "fire shells weighing",
+                               fmt_line<si::fps::mass::lton<>, si::mass::kg<>>(ship.shellMass))
+            << STD_FMT::format("{:20} : {}\n", "fire shells at",
+                               fmt_line<si::fps::speed::mph<>, si::speed::km_per_h<>>(ship.shellSpeed))
+            << STD_FMT::format("{:20} : {}\n", "volume underwater",
+                               fmt_line<si::volume::m3<>, si::volume::l<>>(ship.mass / waterDensity));
 }
 
 int main()
@@ -82,13 +87,37 @@ int main()
   using units::aliases::isq::si::fps::length::ft;  // to disambiguate from si::femptotonne
 
   // KMS Bismark, using the units the Germans would use, taken from Wiki
-  auto bismark = Ship{.length{m<>(251.)}, .draft{m<>(9.3)}, .beam{m<>(36)}, .speed{km_per_h<>(56)}, .mass{t<>(50'300)}, .mainGuns{mm<>(380)}, .shellMass{kg<>(800)}, .shellSpeed{m_per_s<>(820.)}, .power{kW<>(110.45)}};
+  auto bismark = Ship{.length{m<>(251.)},
+                      .draft{m<>(9.3)},
+                      .beam{m<>(36)},
+                      .speed{km_per_h<>(56)},
+                      .mass{t<>(50'300)},
+                      .mainGuns{mm<>(380)},
+                      .shellMass{kg<>(800)},
+                      .shellSpeed{m_per_s<>(820.)},
+                      .power{kW<>(110.45)}};
 
   // USS Iowa, using units from the foot-pound-second system
-  auto iowa = Ship{.length{ft<>(860.)}, .draft{ft<>(37.) + in<>(2.)}, .beam{ft<>(108.) + in<>(2.)}, .speed{knot<>(33)}, .mass{lton<>(57'540)}, .mainGuns{in<>(16)}, .shellMass{lb<>(2700)}, .shellSpeed{ft_per_s<>(2690.)}, .power{hp<>(212'000)}};
+  auto iowa = Ship{.length{ft<>(860.)},
+                   .draft{ft<>(37.) + in<>(2.)},
+                   .beam{ft<>(108.) + in<>(2.)},
+                   .speed{knot<>(33)},
+                   .mass{lton<>(57'540)},
+                   .mainGuns{in<>(16)},
+                   .shellMass{lb<>(2700)},
+                   .shellSpeed{ft_per_s<>(2690.)},
+                   .power{hp<>(212'000)}};
 
   // HMS King George V, using units from the foot-pound-second system
-  auto kgv = Ship{.length{ft<>(745.1)}, .draft{ft<>(33.) + in<>(7.5)}, .beam{ft<>(103.2) + in<>(2.5)}, .speed{knot<>(28.3)}, .mass{lton<>(42'245)}, .mainGuns{in<>(14)}, .shellMass{lb<>(1'590)}, .shellSpeed{ft_per_s<>(2483)}, .power{hp<>(110'000)}};
+  auto kgv = Ship{.length{ft<>(745.1)},
+                  .draft{ft<>(33.) + in<>(7.5)},
+                  .beam{ft<>(103.2) + in<>(2.5)},
+                  .speed{knot<>(28.3)},
+                  .mass{lton<>(42'245)},
+                  .mainGuns{in<>(14)},
+                  .shellMass{lb<>(1'590)},
+                  .shellSpeed{ft_per_s<>(2483)},
+                  .power{hp<>(110'000)}};
 
   print_details("KMS Bismark, defined in appropriate units from the SI system", bismark);
   std::cout << "\n\n";

example/aliases/glide_computer_example.cpp

@@ -25,7 +25,6 @@
 #include <units/chrono.h>
 #include <units/generic/dimensionless.h>
 #include <units/isq/si/international/length.h>
-
 #include <array>
 #include <exception>
 #include <iostream>
@@ -43,14 +42,14 @@ using namespace units::isq;
 auto get_gliders()
 {
   using namespace units::aliases::isq::si;
-UNITS_DIAGNOSTIC_PUSH
-UNITS_DIAGNOSTIC_IGNORE_MISSING_BRACES
+  UNITS_DIAGNOSTIC_PUSH
+  UNITS_DIAGNOSTIC_IGNORE_MISSING_BRACES
   static const std::array gliders = {
-      glider{"SZD-30 Pirat", {velocity(km_per_h<>(83)), rate_of_climb(m_per_s<>(-0.7389))}},
-      glider{"SZD-51 Junior", {velocity(km_per_h<>(80)), rate_of_climb(m_per_s<>(-0.6349))}},
-      glider{"SZD-48 Jantar Std 3", {velocity(km_per_h<>(110)), rate_of_climb(m_per_s<>(-0.77355))}},
-      glider{"SZD-56 Diana", {velocity(km_per_h<>(110)), rate_of_climb(m_per_s<>(-0.63657))}}};
-UNITS_DIAGNOSTIC_POP
+    glider{"SZD-30 Pirat", {velocity(km_per_h<>(83)), rate_of_climb(m_per_s<>(-0.7389))}},
+    glider{"SZD-51 Junior", {velocity(km_per_h<>(80)), rate_of_climb(m_per_s<>(-0.6349))}},
+    glider{"SZD-48 Jantar Std 3", {velocity(km_per_h<>(110)), rate_of_climb(m_per_s<>(-0.77355))}},
+    glider{"SZD-56 Diana", {velocity(km_per_h<>(110)), rate_of_climb(m_per_s<>(-0.63657))}}};
+  UNITS_DIAGNOSTIC_POP
   return gliders;
 }
 
@@ -58,9 +57,9 @@ auto get_weather_conditions()
 {
   using namespace units::aliases::isq::si;
   static const std::array weather_conditions = {
-      std::pair("Good", weather{height(m<>(1900)), rate_of_climb(m_per_s<>(4.3))}),
-      std::pair("Medium", weather{height(m<>(1550)), rate_of_climb(m_per_s<>(2.8))}),
-      std::pair("Bad", weather{height(m<>(850)), rate_of_climb(m_per_s<>(1.8))})};
+    std::pair("Good", weather{height(m<>(1900)), rate_of_climb(m_per_s<>(4.3))}),
+    std::pair("Medium", weather{height(m<>(1550)), rate_of_climb(m_per_s<>(2.8))}),
+    std::pair("Bad", weather{height(m<>(850)), rate_of_climb(m_per_s<>(1.8))})};
   return weather_conditions;
 }
 
@@ -69,14 +68,14 @@ auto get_waypoints()
   using namespace geographic::literals;
   using namespace units::aliases::isq::si::international;
   static const std::array waypoints = {
-      waypoint{"EPPR", {54.24772_N, 18.6745_E}, altitude(ft<>(16))},    // N54°14'51.8" E18°40'28.2"
-      waypoint{"EPGI", {53.52442_N, 18.84947_E}, altitude(ft<>(115))}   // N53°31'27.9" E18°50'58.1"
+    waypoint{"EPPR", {54.24772_N, 18.6745_E}, altitude(ft<>(16))},   // N54°14'51.8" E18°40'28.2"
+    waypoint{"EPGI", {53.52442_N, 18.84947_E}, altitude(ft<>(115))}  // N53°31'27.9" E18°50'58.1"
   };
   return waypoints;
 }
 
 template<std::ranges::input_range R>
-  requires std::same_as<std::ranges::range_value_t<R>, glider>
+  requires(std::same_as<std::ranges::range_value_t<R>, glider>)
 void print(const R& gliders)
 {
   std::cout << "Gliders:\n";
@@ -85,13 +84,14 @@ void print(const R& gliders)
     std::cout << "- Name: " << g.name << "\n";
     std::cout << "- Polar:\n";
     for (const auto& p : g.polar)
-      std::cout << STD_FMT::format("  * {:%.4Q %q} @ {:%.1Q %q} -> {:%.1Q %q}\n", p.climb, p.v, units::quantity_cast<units::one>(glide_ratio(g.polar[0])));
+      std::cout << STD_FMT::format("  * {:%.4Q %q} @ {:%.1Q %q} -> {:%.1Q %q}\n", p.climb, p.v,
+                                   units::quantity_cast<units::one>(glide_ratio(g.polar[0])));
     std::cout << "\n";
   }
 }
 
 template<std::ranges::input_range R>
-  requires std::same_as<std::ranges::range_value_t<R>, std::pair<const char*, weather>>
+  requires(std::same_as<std::ranges::range_value_t<R>, std::pair<const char*, weather>>)
 void print(const R& conditions)
 {
   std::cout << "Weather:\n";
@@ -106,7 +106,7 @@ void print(const R& conditions)
 }
 
 template<std::ranges::input_range R>
-  requires std::same_as<std::ranges::range_value_t<R>, waypoint>
+  requires(std::same_as<std::ranges::range_value_t<R>, waypoint>)
 void print(const R& waypoints)
 {
   std::cout << "Waypoints:\n";
@@ -125,7 +125,8 @@ void print(const task& t)
   std::cout << "- Finish: " << t.get_finish().name << "\n";
   std::cout << "- Length:  " << STD_FMT::format("{:%.1Q %q}", t.get_length()) << "\n";
 
-  std::cout << "- Legs: " << "\n";
+  std::cout << "- Legs: "
+            << "\n";
   for (const auto& l : t.get_legs())
     std::cout << STD_FMT::format("  * {} -> {} ({:%.1Q %q})\n", l.begin().name, l.end().name, l.get_length());
   std::cout << "\n";

example/aliases/linear_algebra.cpp

@@ -20,14 +20,14 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
-#include <units/isq/si/energy.h> // IWYU pragma: keep
+#include <units/format.h>
+#include <units/isq/si/energy.h>  // IWYU pragma: keep
 #include <units/isq/si/force.h>
 #include <units/isq/si/length.h>
-#include <units/isq/si/speed.h> // IWYU pragma: keep
-#include <units/format.h>
+#include <units/isq/si/speed.h>  // IWYU pragma: keep
 #include <units/quantity_io.h>
-#include <linear_algebra.hpp>
 #include <iostream>
+#include <linear_algebra.hpp>
 
 namespace STD_LA {
 
@@ -72,9 +72,9 @@ void vector_of_quantity_add()
 {
   std::cout << "\nvector_of_quantity_add:\n";
 
-  vector<length::m<>> v = { m<>(1), m<>(2), m<>(3) };
-  vector<length::m<>> u = { m<>(3), m<>(2), m<>(1) };
-  vector<length::km<>> t = { km<>(3), km<>(2), km<>(1) };
+  vector<length::m<>> v = {m<>(1), m<>(2), m<>(3)};
+  vector<length::m<>> u = {m<>(3), m<>(2), m<>(1)};
+  vector<length::km<>> t = {km<>(3), km<>(2), km<>(1)};
 
   std::cout << "v = " << v << "\n";
   std::cout << "u = " << u << "\n";
@@ -89,8 +89,8 @@ void vector_of_quantity_multiply_same()
 {
   std::cout << "\nvector_of_quantity_multiply_same:\n";
 
-  vector<length::m<>> v = { m<>(1), m<>(2), m<>(3) };
-  vector<length::m<>> u = { m<>(3), m<>(2), m<>(1) };
+  vector<length::m<>> v = {m<>(1), m<>(2), m<>(3)};
+  vector<length::m<>> u = {m<>(3), m<>(2), m<>(1)};
 
   std::cout << "v = " << v << "\n";
   std::cout << "u = " << u << "\n";
@@ -103,8 +103,8 @@ void vector_of_quantity_multiply_different()
 {
   std::cout << "\nvector_of_quantity_multiply_different:\n";
 
-  vector<force::N<>> v = { N<>(1), N<>(2), N<>(3) };
-  vector<length::m<>> u = { m<>(3), m<>(2), m<>(1) };
+  vector<force::N<>> v = {N<>(1), N<>(2), N<>(3)};
+  vector<length::m<>> u = {m<>(3), m<>(2), m<>(1)};
 
   std::cout << "v = " << v << "\n";
   std::cout << "u = " << u << "\n";
@@ -118,7 +118,7 @@ void vector_of_quantity_divide_by_scalar()
 {
   std::cout << "\nvector_of_quantity_divide_by_scalar:\n";
 
-  vector<length::m<>> v = { m<>(4), m<>(8), m<>(12) };
+  vector<length::m<>> v = {m<>(4), m<>(8), m<>(12)};
 
   std::cout << "v = " << v << "\n";
 
@@ -139,9 +139,9 @@ void matrix_of_quantity_add()
 {
   std::cout << "\nmatrix_of_quantity_add:\n";
 
-  matrix<length::m<>> v = {{ m<>(1), m<>(2), m<>(3) }, { m<>(4), m<>(5), m<>(6) }, { m<>(7), m<>(8), m<>(9) }};
-  matrix<length::m<>> u = {{ m<>(3), m<>(2), m<>(1) }, { m<>(3), m<>(2), m<>(1) }, { m<>(3), m<>(2), m<>(1) }};
-  matrix<length::mm<>> t = {{ mm<>(3), mm<>(2), mm<>(1) }, { mm<>(3), mm<>(2), mm<>(1) }, { mm<>(3), mm<>(2), mm<>(1) }};
+  matrix<length::m<>> v = {{m<>(1), m<>(2), m<>(3)}, {m<>(4), m<>(5), m<>(6)}, {m<>(7), m<>(8), m<>(9)}};
+  matrix<length::m<>> u = {{m<>(3), m<>(2), m<>(1)}, {m<>(3), m<>(2), m<>(1)}, {m<>(3), m<>(2), m<>(1)}};
+  matrix<length::mm<>> t = {{mm<>(3), mm<>(2), mm<>(1)}, {mm<>(3), mm<>(2), mm<>(1)}, {mm<>(3), mm<>(2), mm<>(1)}};
 
   std::cout << "v =\n" << v << "\n";
   std::cout << "u =\n" << u << "\n";
@@ -158,8 +158,8 @@ void matrix_of_quantity_multiply_same()
 {
   std::cout << "\nmatrix_of_quantity_multiply_same:\n";
 
-  matrix<length::m<>> v = {{ m<>(1), m<>(2), m<>(3) }, { m<>(4), m<>(5), m<>(6) }, { m<>(7), m<>(8), m<>(9) }};
-  vector<length::m<>> u = { m<>(3), m<>(2), m<>(1) };
+  matrix<length::m<>> v = {{m<>(1), m<>(2), m<>(3)}, {m<>(4), m<>(5), m<>(6)}, {m<>(7), m<>(8), m<>(9)}};
+  vector<length::m<>> u = {m<>(3), m<>(2), m<>(1)};
 
   std::cout << "v =\n" << v << "\n";
   std::cout << "u =\n" << u << "\n";
@@ -172,8 +172,8 @@ void matrix_of_quantity_multiply_different()
 {
   std::cout << "\nmatrix_of_quantity_multiply_different:\n";
 
-  vector<force::N<>> v = { N<>(1), N<>(2), N<>(3) };
-  matrix<length::m<>> u = {{ m<>(1), m<>(2), m<>(3) }, { m<>(4), m<>(5), m<>(6) }, { m<>(7), m<>(8), m<>(9) }};
+  vector<force::N<>> v = {N<>(1), N<>(2), N<>(3)};
+  matrix<length::m<>> u = {{m<>(1), m<>(2), m<>(3)}, {m<>(4), m<>(5), m<>(6)}, {m<>(7), m<>(8), m<>(9)}};
 
   std::cout << "v =\n" << v << "\n";
   std::cout << "u =\n" << u << "\n";
@@ -187,7 +187,7 @@ void matrix_of_quantity_divide_by_scalar()
 {
   std::cout << "\nmatrix_of_quantity_divide_by_scalar:\n";
 
-  matrix<length::m<>> v = {{ m<>(2), m<>(4), m<>(6) }, { m<>(4), m<>(6), m<>(8) }, { m<>(8), m<>(4), m<>(2) }};
+  matrix<length::m<>> v = {{m<>(2), m<>(4), m<>(6)}, {m<>(4), m<>(6), m<>(8)}, {m<>(8), m<>(4), m<>(2)}};
 
   std::cout << "v =\n" << v << "\n";
 
@@ -216,9 +216,9 @@ void quantity_of_vector_add()
 {
   std::cout << "\nquantity_of_vector_add:\n";
 
-  length_v<> v(vector<>{ 1, 2, 3 });
-  length_v<> u(vector<>{ 3, 2, 1 });
-  length_v<si::kilometre> t(vector<>{ 3, 2, 1 });
+  length_v<> v(vector<>{1, 2, 3});
+  length_v<> u(vector<>{3, 2, 1});
+  length_v<si::kilometre> t(vector<>{3, 2, 1});
 
   std::cout << "v = " << v << "\n";
   std::cout << "u = " << u << "\n";
@@ -233,8 +233,8 @@ void quantity_of_vector_multiply_same()
 {
   std::cout << "\nquantity_of_vector_multiply_same:\n";
 
-  length_v<> v(vector<>{ 1, 2, 3 });
-  length_v<> u(vector<>{ 3, 2, 1 });
+  length_v<> v(vector<>{1, 2, 3});
+  length_v<> u(vector<>{3, 2, 1});
 
   std::cout << "v = " << v << "\n";
   std::cout << "u = " << u << "\n";
@@ -247,8 +247,8 @@ void quantity_of_vector_multiply_different()
 {
   std::cout << "\nquantity_of_vector_multiply_different:\n";
 
-  force_v<> v(vector<>{ 1, 2, 3 });
-  length_v<> u(vector<>{ 3, 2, 1 });
+  force_v<> v(vector<>{1, 2, 3});
+  length_v<> u(vector<>{3, 2, 1});
 
   std::cout << "v = " << v << "\n";
   std::cout << "u = " << u << "\n";
@@ -262,7 +262,7 @@ void quantity_of_vector_divide_by_scalar()
 {
   std::cout << "\nquantity_of_vector_divide_by_scalar:\n";
 
-  length_v<> v(vector<>{ 4, 8, 12 });
+  length_v<> v(vector<>{4, 8, 12});
 
   std::cout << "v = " << v << "\n";
 
@@ -286,9 +286,9 @@ void quantity_of_matrix_add()
 {
   std::cout << "\nquantity_of_matrix_add:\n";
 
-  length_m<> v(matrix<>{{ 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 }});
-  length_m<> u(matrix<>{{ 3, 2, 1 }, { 3, 2, 1 }, { 3, 2, 1 }});
-  length_m<si::kilometre> t(matrix<>{{ 3, 2, 1 }, { 3, 2, 1 }, { 3, 2, 1 }});
+  length_m<> v(matrix<>{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}});
+  length_m<> u(matrix<>{{3, 2, 1}, {3, 2, 1}, {3, 2, 1}});
+  length_m<si::kilometre> t(matrix<>{{3, 2, 1}, {3, 2, 1}, {3, 2, 1}});
 
   std::cout << "v =\n" << v << "\n";
   std::cout << "u =\n" << u << "\n";
@@ -305,8 +305,8 @@ void quantity_of_matrix_multiply_same()
 {
   std::cout << "\nquantity_of_matrix_multiply_same:\n";
 
-  length_m<> v(matrix<>{{ 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 }});
-  length_v<> u(vector<>{ 3, 2, 1 });
+  length_m<> v(matrix<>{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}});
+  length_v<> u(vector<>{3, 2, 1});
 
   std::cout << "v =\n" << v << "\n";
   std::cout << "u =\n" << u << "\n";
@@ -319,8 +319,8 @@ void quantity_of_matrix_multiply_different()
 {
   std::cout << "\nquantity_of_matrix_multiply_different:\n";
 
-  force_v<> v(vector<>{ 1, 2, 3 });
-  length_m<> u(matrix<>{{ 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 }});
+  force_v<> v(vector<>{1, 2, 3});
+  length_m<> u(matrix<>{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}});
 
   std::cout << "v =\n" << v << "\n";
   std::cout << "u =\n" << u << "\n";
@@ -334,7 +334,7 @@ void quantity_of_matrix_divide_by_scalar()
 {
   std::cout << "\nquantity_of_matrix_divide_by_scalar:\n";
 
-  length_m<> v(matrix<>{{ 2, 4, 6 }, { 4, 6, 8 }, { 8, 4, 2 }});
+  length_m<> v(matrix<>{{2, 4, 6}, {4, 6, 8}, {8, 4, 2}});
 
   std::cout << "v =\n" << v << "\n";
 

example/aliases/measurement.cpp

@@ -38,8 +38,7 @@ public:
 
   measurement() = default;
 
-  constexpr explicit measurement(const value_type& val, const value_type& err = {}) :
-      value_(val)
+  constexpr explicit measurement(const value_type& val, const value_type& err = {}) : value_(val)
   {
     // it sucks that using declaration cannot be provided for a constructor initializer list
     using namespace std;

example/aliases/total_energy.cpp

@@ -21,11 +21,11 @@
 // SOFTWARE.
 
 #include <units/isq/natural/natural.h>
+#include <units/isq/si/constants.h>
 #include <units/isq/si/energy.h>
 #include <units/isq/si/mass.h>
 #include <units/isq/si/momentum.h>
-#include <units/isq/si/speed.h> // IWYU pragma: keep
-#include <units/isq/si/constants.h>
+#include <units/isq/si/speed.h>  // IWYU pragma: keep
 #include <units/math.h>
 #include <units/quantity_io.h>
 #include <exception>
@@ -85,18 +85,16 @@ void natural_example()
             << "E = " << E << "\n";
 }
 
-} // namespace
+}  // namespace
 
 int main()
 {
   try {
     si_example();
     natural_example();
-  }
-  catch (const std::exception& ex) {
+  } catch (const std::exception& ex) {
     std::cerr << "Unhandled std exception caught: " << ex.what() << '\n';
-  }
-  catch (...) {
+  } catch (...) {
     std::cerr << "Unhandled unknown exception caught\n";
   }
 }

example/aliases/unknown_dimension.cpp

@@ -21,7 +21,7 @@
 // SOFTWARE.
 
 #include <units/isq/si/length.h>
-#include <units/isq/si/speed.h> // IWYU pragma: keep
+#include <units/isq/si/speed.h>  // IWYU pragma: keep
 #include <units/isq/si/time.h>
 #include <units/quantity_io.h>
 #include <exception>
@@ -44,8 +44,9 @@ void example()
   Time auto t1 = s<>(10);
   Speed auto v1 = avg_speed(d1, t1);
 
-  auto temp1 = v1 * m<>(50);  // produces intermediate unknown dimension with 'unknown_coherent_unit' as its 'coherent_unit'
-  Speed auto v2 = temp1 / m<>(100); // back to known dimensions again
+  auto temp1 =
+    v1 * m<>(50);  // produces intermediate unknown dimension with 'unknown_coherent_unit' as its 'coherent_unit'
+  Speed auto v2 = temp1 / m<>(100);  // back to known dimensions again
   Length auto d2 = v2 * s<>(60);
 
   std::cout << "d1 = " << d1 << '\n';
@@ -56,17 +57,15 @@ void example()
   std::cout << "d2 = " << d2 << '\n';
 }
 
-} // namespace
+}  // namespace
 
 int main()
 {
   try {
     example();
-  }
-  catch (const std::exception& ex) {
+  } catch (const std::exception& ex) {
     std::cerr << "Unhandled std exception caught: " << ex.what() << '\n';
-  }
-  catch (...) {
+  } catch (...) {
     std::cerr << "Unhandled unknown exception caught\n";
   }
 }