Improve bit size validation in ByteSize.cs (#1595)

Author: clairernovotny

src/Humanizer/Bytes/ByteSize.cs

@@ -467,17 +467,13 @@ public static bool TryParse(CharSpan s, IFormatProvider? formatProvider, out Byt
             case ByteSymbol:
                 if (sizePart.SequenceEqual(BitSymbol))
                 {
-                    // Bits
-                    if (number % 1 != 0) // Can't have partial bits
-                    {
-                        return false;
-                    }
-
-                    result = FromBits((long) number);
+                    if (!double.IsFinite(number)) return false;
+                    if (number != Math.Truncate(number)) return false;
+                    if (number < long.MinValue || number > long.MaxValue) return false;
+                    result = FromBits((long)number);
                 }
                 else
                 {
-                    // Bytes
                     result = FromBytes(number);
                 }
 

src/Humanizer/MathExtensionShims.cs

@@ -0,0 +1,83 @@
+#if !(NET5_0_OR_GREATER)
+
+using System.Runtime.CompilerServices;
+
+namespace System;
+
+
+// C# 14 static extension members on the *type* itself.
+// Usage on old TFMs:  Double.IsFinite(x), Double.IsIntegral(x), Single.IsFinite(x), ...
+static class FloatCompat
+{
+    // ---- Double ----
+    extension(double)
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool IsFinite(double x)
+        {
+            var bits = (ulong)BitConverter.DoubleToInt64Bits(x);
+            return (bits & 0x7FF0_0000_0000_0000UL) != 0x7FF0_0000_0000_0000UL;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool IsIntegral(double x)
+        {
+            if (!IsFinite(x)) return false;
+            return x == Math.Truncate(x);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool IsInfinityFast(double x)
+        {
+            var bits = (ulong)BitConverter.DoubleToInt64Bits(x);
+            return (bits & 0x7FFF_FFFF_FFFF_FFFFUL) == 0x7FF0_0000_0000_0000UL;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool IsNaNFast(double x)
+        {
+            var bits = (ulong)BitConverter.DoubleToInt64Bits(x);
+            return (bits & 0x7FF0_0000_0000_0000UL) == 0x7FF0_0000_0000_0000UL
+                && (bits & 0x000F_FFFF_FFFF_FFFFUL) != 0;
+        }
+
+
+    }
+
+    // ---- float ----
+    extension(float)
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool IsFinite(float x)
+        {
+            // netstandard2.0 / net48: fastest is unsafe bit-cast
+            unsafe { var bits = *(uint*)&x; return (bits & 0x7F80_0000u) != 0x7F80_0000u; }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool IsIntegral(float x)
+        {
+            if (!IsFinite(x)) return false;
+            return x == Math.Truncate(x);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool IsInfinityFast(float x)
+        {
+            unsafe { var bits = *(uint*)&x; return (bits & 0x7FFF_FFFFu) == 0x7F80_0000u; }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool IsNaNFast(float x)
+        {
+            unsafe
+            {
+                var bits = *(uint*)&x;
+                var isExpAllOnes = (bits & 0x7F80_0000u) == 0x7F80_0000u;
+                var hasMantissa = (bits & 0x007F_FFFFu) != 0;
+                return isExpAllOnes && hasMantissa;
+            }
+        }
+    }
+}
+#endif

src/Humanizer/ToQuantityExtensions.cs

@@ -62,7 +62,7 @@ public static string ToQuantity(this string input, long quantity, string? format
 
     static string ToQuantity(this string input, long quantity, ShowQuantityAs showQuantityAs = ShowQuantityAs.Numeric, string? format = null, IFormatProvider? formatProvider = null)
     {
-        var transformedInput = quantity == 1 || quantity == -1
+        var transformedInput = quantity is 1 or -1
             ? input.Singularize(inputIsKnownToBePlural: false)
             : input.Pluralize(inputIsKnownToBeSingular: false);
 
@@ -93,7 +93,10 @@ static string ToQuantity(this string input, long quantity, ShowQuantityAs showQu
     /// </example>
     public static string ToQuantity(this string input, double quantity, string? format = null, IFormatProvider? formatProvider = null)
     {
-        var transformedInput = quantity == 1 || quantity == -1
+        var isFinite = !(double.IsNaN(quantity) || double.IsInfinity(quantity));
+        var isSingular = isFinite && quantity == Math.Truncate(quantity) && Math.Abs(quantity) == 1d;
+
+        var transformedInput = isSingular
             ? input.Singularize(inputIsKnownToBePlural: false)
             : input.Pluralize(inputIsKnownToBeSingular: false);