pre-commit run

Signed-off-by: Rob Suderman <[email protected]>

Author: rsuderman

include/fusilli/support/float_types.h

@@ -6,8 +6,8 @@
 
 //===----------------------------------------------------------------------===//
 //
-// This file contains portable float16 and bfloat16 implementations represented as
-// structs with int16_t storage. These types support conversion to/from float
+// This file contains portable float16 and bfloat16 implementations represented
+// as structs with int16_t storage. These types support conversion to/from float
 // and perform arithmetic operations in 32-bit float precision.
 //
 //===----------------------------------------------------------------------===//
@@ -149,8 +149,7 @@ struct float16 {
       // Round to nearest even
       uint32_t remainder = mantissa & ((1 << shift) - 1);
       uint32_t halfway = 1 << (shift - 1);
-      if (remainder > halfway ||
-          (remainder == halfway && (fp16Mantissa & 1))) {
+      if (remainder > halfway || (remainder == halfway && (fp16Mantissa & 1))) {
         fp16Mantissa++;
       }
       return static_cast<int16_t>((sign << 15) | fp16Mantissa);

tests/test_float_types.cpp

@@ -198,10 +198,10 @@ TEST_CASE("float16 precision limits", "[float16]") {
   // float16 has ~3 decimal digits of precision
   // Values that differ by less than the precision should round to the same
   float16 a(1.0f);
-  float16 b(1.0001f);  // Very close values
+  float16 b(1.0001f); // Very close values
   // They might round to same value due to float16 precision
   float diff = std::abs(a.toFloat() - b.toFloat());
-  REQUIRE(diff < 0.002f);  // Within float16 precision
+  REQUIRE(diff < 0.002f); // Within float16 precision
 }
 
 // =============================================================================
@@ -392,17 +392,18 @@ TEST_CASE("bfloat16 explicit float conversion operator", "[bfloat16]") {
 TEST_CASE("bfloat16 precision limits", "[bfloat16]") {
   // bfloat16 has ~2 decimal digits of precision (7 mantissa bits)
   bfloat16 a(1.0f);
-  bfloat16 b(1.01f);  // Close values
+  bfloat16 b(1.01f); // Close values
   // They might round to same value due to bfloat16 precision
   float diff = std::abs(a.toFloat() - b.toFloat());
-  REQUIRE(diff < 0.02f);  // Within bfloat16 precision
+  REQUIRE(diff < 0.02f); // Within bfloat16 precision
 }
 
 // =============================================================================
 // Cross-type Tests
 // =============================================================================
 
-TEST_CASE("float16 and bfloat16 have different bit representations", "[float16][bfloat16]") {
+TEST_CASE("float16 and bfloat16 have different bit representations",
+          "[float16][bfloat16]") {
   // 1.0 has different bit patterns in float16 vs bfloat16
   float16 float16_one(1.0f);
   bfloat16 bfloat16_one(1.0f);
@@ -426,7 +427,7 @@ TEST_CASE("float16 has more precision but smaller range than bfloat16",
   float16 float16_large(large);
   bfloat16 bfloat16_large(large);
 
-  REQUIRE(std::isinf(float16_large.toFloat()));  // Overflows in float16
+  REQUIRE(std::isinf(float16_large.toFloat()));   // Overflows in float16
   REQUIRE(!std::isinf(bfloat16_large.toFloat())); // Fits in bfloat16
 
   // Small precision test - float16 is more precise