Fix the scientific, pep515 and engineering suggestions

Author: Pierre-Sassoulas

doc/data/messages/b/bad-float-notation/bad/scientific_notation.py

@@ -1,3 +1,3 @@
 base_not_between_one_and_ten = 10e3  # [bad-float-notation]
 above_threshold_without_exponent = 10000000  # [bad-float-notation]
-under_ten_with_exponent = 9e0  # [bad-float-notation]
+under_ten_with_exponent = 9.9e0  # [bad-float-notation]

doc/data/messages/b/bad-float-notation/good/scientific_notation.py

@@ -1,3 +1,3 @@
 base_between_one_and_ten = 1e4
 above_threshold_with_exponent = 1e7
-under_ten = 9
+under_ten = 9.9

pylint/checkers/format.py

@@ -13,6 +13,7 @@
 
 from __future__ import annotations
 
+import math
 import re
 import tokenize
 from functools import reduce
@@ -548,46 +549,81 @@ def process_tokens(self, tokens: list[tokenize.TokenInfo]) -> None:
 
     @classmethod
     def to_standard_or_engineering_base(cls, number):
-        # number is always going to be > 0 because node constants are always positive
-        # Format with high precision to capture all digits
-        s = f"{number:.15e}"
-        base, exp = s.split("e")
-        # Remove trailing zeros and possible trailing decimal point
-        base = base.rstrip("0").rstrip(".")
-        return base, exp
+        """Calculate scientific notation components (base, exponent) for a number.
+
+        Returns a tuple (base, exponent) where:
+        - base is a number between 1 and 10 (or exact 0)
+        - exponent is the power of 10 needed to represent the original number
+        """
+        if number == 0:
+            return "0", "0"
+        exponent = math.floor(math.log10(abs(number)))
+        if exponent == 0:
+            return str(number), "0"
+        base_value = number / (10**exponent)
+        # 15 significant digits because if we add more precision then
+        # we get into rounding errors territory
+        base_str = f"{base_value:.15g}".rstrip("0").rstrip(".")
+        exp_str = str(exponent)
+        return base_str, exp_str
 
     @classmethod
     def to_standard_scientific_notation(cls, number: float) -> str:
         base, exp = cls.to_standard_or_engineering_base(number)
-        return f"{base}e{int(exp)}" if exp not in ["0", "1"] else str(base)
+        if exp != "0":
+            return f"{base}e{int(exp)}"
+        if "." in base:
+            return base
+        return f"{base}.0"
 
     @classmethod
     def to_standard_engineering_notation(cls, number: float) -> str:
         base, exp = cls.to_standard_or_engineering_base(number)
-        result = f"{base}e{int(exp)}" if exp not in ["0", "1"] else str(base)
         exp_value = int(exp)
         remainder = exp_value % 3
-        if remainder != 0:
+        # For negative exponents, the adjustment is different
+        if exp_value < 0:
+            # For negative exponents, we need to round down to the next multiple of 3
+            # e.g., -5 should go to -6, so we get 3 - ((-5) % 3) = 3 - 1 = 2
+            adjustment = 3 - ((-exp_value) % 3)
+            if adjustment == 3:
+                adjustment = 0
+            exp_value = exp_value - adjustment
+            base_value = float(base) * (10**adjustment)
+        elif remainder != 0:
+            # For positive exponents, keep the existing logic
             exp_value = exp_value - remainder
             base_value = float(base) * (10**remainder)
-            base = str(base_value).rstrip("0").rstrip(".")
-        return f"{base}e{exp_value}" if exp_value > 2 else base
+        else:
+            base_value = float(base)
+        base = str(base_value).rstrip("0").rstrip(".")
+        if exp_value != 0:
+            return f"{base}e{exp_value}"
+        if "." in base:
+            return base
+        return f"{base}.0"
 
     @classmethod
     def to_standard_underscore_grouping(cls, number: float) -> str:
-        dec_part = "0"
-        if "." in str(number):
-            int_part, dec_part = str(number).split(".")
+        number_str = str(number)
+        if "e" in number_str or "E" in number_str:
+            # python itself want to display this as exponential there's no reason to
+            # not use exponential notation for very small number even for strict
+            # underscore grouping notation
+            return number_str
+        print(number_str)
+        if "." in number_str:
+            int_part, dec_part = number_str.split(".")
         else:
-            int_part = str(number)
-        if dec_part == "0":
-            dec_part = ""
+            int_part = number_str
+            dec_part = "0"
+        print("int_part", int_part, "dec_part:", dec_part)
         grouped_int_part = ""
         for i, digit in enumerate(reversed(int_part)):
             if i > 0 and i % 3 == 0:
                 grouped_int_part = "_" + grouped_int_part
             grouped_int_part = digit + grouped_int_part
-        return f"{grouped_int_part}.{dec_part}" if dec_part else grouped_int_part
+        return f"{grouped_int_part}.{dec_part}"
 
     def _check_bad_float_notation(
         self, line_num: int, start: tuple[int, int], string: str

tests/checkers/unittest_format.py

@@ -186,19 +186,37 @@ def test_disable_global_option_end_of_line() -> None:
 @pytest.mark.parametrize(
     "value,expected_scientific,expected_engineering,expected_underscore",
     [
-        ("0e10", "0", "0", "0"),
-        ("3e1", "30", "30", "30"),
-        ("30e2", "3e3", "3e3", "3_000"),
-        ("1e6", "1e6", "1e6", "1_000_000"),
-        ("10e5", "1e6", "1e6", "1_000_000"),
-        ("1_000_000", "1e6", "1e6", "1_000_000"),
-        ("1000_000", "1e6", "1e6", "1_000_000"),
-        ("20e9", "2e10", "20e9", "20_000_000_000"),
-        ("1e-10", "1e-10", "100e-12", "0.0000000001"),
+        ("0", "0.0", "0.0", "0.0"),
+        ("0e10", "0.0", "0.0", "0.0"),
+        ("0e-10", "0.0", "0.0", "0.0"),
+        ("0.0e10", "0.0", "0.0", "0.0"),
+        ("1e0", "1.0", "1.0", "1.0"),
+        ("1e10", "1e10", "10e9", "10_000_000_000.0"),
+        # no reason to not use exponential notation for very low number
+        # even for strict underscore grouping notation
+        ("1e-10", "1e-10", "100e-12", "1e-10"),
+        ("2e1", "2e1", "20.0", "20.0"),
+        ("2e-1", "2e-1", "200e-3", "0.2"),
+        ("3.456e2", "3.456e2", "345.6", "345.6"),
+        ("3.456e-2", "3.456e-2", "34.56e-3", "0.03456"),
+        ("4e2", "4e2", "400.0", "400.0"),
+        ("4e-2", "4e-2", "40e-3", "0.04"),
+        ("50e2", "5e3", "5e3", "5_000.0"),
+        ("50e-2", "5e-1", "500e-3", "0.5"),
+        ("6e6", "6e6", "6e6", "6_000_000.0"),
+        ("6e-6", "6e-6", "6e-6", "6e-06"),  # 6e-06 is what python offer on str(float)
+        ("10e5", "1e6", "1e6", "1_000_000.0"),
+        ("10e-5", "1e-4", "100e-6", "0.0001"),
+        ("1_000_000", "1e6", "1e6", "1_000_000.0"),
+        ("1000_000", "1e6", "1e6", "1_000_000.0"),
+        ("20e9", "2e10", "20e9", "20_000_000_000.0"),
+        ("20e-9", "2e-8", "20e-9", "2e-08"),  # 2e-08 is what python offer on str(float)
         (
+            # 15 significant digits because we get rounding error otherwise
+            # and 15 seems enough especially since we don't autofix
             "10_5415_456_465498.16354698489",
-            "1.054154564654982e14",
-            "105.4154564654982e12",
+            "1.05415456465498e14",
+            "105.415456465498e12",
             "105_415_456_465_498.16",
         ),
     ],
@@ -212,8 +230,14 @@ def test_to_another_standard_notation(
     """Test the conversion of numbers to all possible notations."""
     float_value = float(value)
     scientific = FormatChecker.to_standard_scientific_notation(float_value)
-    assert scientific == expected_scientific
+    assert (
+        scientific == expected_scientific
+    ), f"Scientific notation mismatch expected {expected_scientific}, got {scientific}"
     engineering = FormatChecker.to_standard_engineering_notation(float_value)
-    assert engineering == expected_engineering
+    assert (
+        engineering == expected_engineering
+    ), f"Engineering notation mismatch expected {expected_engineering}, got {engineering}"
     underscore = FormatChecker.to_standard_underscore_grouping(float_value)
-    assert underscore == expected_underscore
+    assert (
+        underscore == expected_underscore
+    ), f"Underscore grouping mismatch expected {expected_underscore}, got {underscore}"