flexfloat 0.1.0__tar.gz → 0.1.1__tar.gz

{flexfloat-0.1.0 → flexfloat-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flexfloat
-Version: 0.1.0
+Version: 0.1.1
 Summary: A library for arbitrary precision floating point arithmetic
 Author: Ferran Sanchez Llado
 License: MIT

{flexfloat-0.1.0 → flexfloat-0.1.1}/flexfloat/__init__.py

@@ -7,7 +7,7 @@ with growable exponents and fixed-size fractions.
 from .bitarray import BitArray
 from .core import FlexFloat
 
-__version__ = "0.1.0"
+__version__ = "0.1.1"
 __author__ = "Ferran Sanchez Llado"
 
 __all__ = ["FlexFloat", "BitArray"]

{flexfloat-0.1.0 → flexfloat-0.1.1}/flexfloat/bitarray.py

@@ -9,8 +9,8 @@ from typing import Iterator, overload
 class BitArray:
     """A bit array class that encapsulates a list of booleans with utility methods.
 
-    This class provides all the functionality previously available through utility functions,
-    now encapsulated as methods for better object-oriented design.
+    This class provides all the functionality previously available through utility
+    functions, now encapsulated as methods for better object-oriented design.
     """
 
     def __init__(self, bits: list[bool] | None = None):
@@ -119,7 +119,8 @@ class BitArray:
         return sum((1 << i) for i, bit in enumerate(reversed(self._bits)) if bit)
 
     def to_signed_int(self) -> int:
-        """Convert a bit array into a signed integer using off-set binary representation.
+        """Convert a bit array into a signed integer using off-set binary
+        representation.
 
         Returns:
             int: The signed integer represented by the bit array.
@@ -137,13 +138,16 @@ class BitArray:
     def shift(self, shift_amount: int, fill: bool = False) -> BitArray:
         """Shift the bit array left or right by a specified number of bits.
 
-        This function shifts the bits in the array, filling in new bits with the specified fill value.
-        If the shift is positive, it shifts left and fills with the fill value at the end.
-        If the shift is negative, it shifts right and fills with the fill value at the start.
+        This function shifts the bits in the array, filling in new bits with the
+        specified fill value.
+        If the value is positive, it shifts left; if negative, it shifts right.
+        Fills the new bits with the specified fill value (default is False).
 
         Args:
-            shift_amount (int): The number of bits to shift. Positive for left shift, negative for right shift.
-            fill (bool): The value to fill in the new bits created by the shift. Defaults to False.
+            shift_amount (int): The number of bits to shift. Positive for left shift,
+                negative for right shift.
+            fill (bool): The value to fill in the new bits created by the shift.
+                Defaults to False.
         Returns:
             BitArray: A new BitArray with the bits shifted and filled.
         """

{flexfloat-0.1.0 → flexfloat-0.1.1}/flexfloat/core.py

@@ -2,22 +2,30 @@
 
 from __future__ import annotations
 
+import math
+from typing import Final
+
 from .bitarray import BitArray
 from .types import Number
 
+LOG10_2: Final[float] = math.log10(2)
+
 
 class FlexFloat:
-    """A class to represent a floating-point number with growable exponent and fixed-size fraction.
-    This class is designed to handle very large or very small numbers by adjusting the exponent dynamically.
-    While keeping the mantissa (fraction) fixed in size.
+    """A class to represent a floating-point number with growable exponent and
+    fixed-size fraction. This class is designed to handle very large or very
+    small numbers by adjusting the exponent dynamically. While keeping the
+    mantissa (fraction) fixed in size.
 
     This class follows the IEEE 754 double-precision floating-point format,
     but extends it to allow for a growable exponent and a fixed-size fraction.
 
     Attributes:
         sign (bool): The sign of the number (True for negative, False for positive).
-        exponent (BitArray): A growable bit array representing the exponent (uses off-set binary representation).
-        fraction (BitArray): A fixed-size bit array representing the fraction (mantissa) of the number.
+        exponent (BitArray): A growable bit array representing the exponent
+            (uses off-set binary representation).
+        fraction (BitArray): A fixed-size bit array representing the fraction
+            (mantissa) of the number.
     """
 
     def __init__(
@@ -30,8 +38,8 @@ class FlexFloat:
 
         Args:
             sign (bool): The sign of the number (True for negative, False for positive).
-            exponent (BitArray | None): The exponent bit array. If None, defaults to a zero exponent.
-            fraction (BitArray | None): The fraction bit array. If None, defaults to a zero fraction.
+            exponent (BitArray | None): The exponent bit array (If None, represents 0).
+            fraction (BitArray | None): The fraction bit array (If None, represents 0).
         """
         self.sign = sign
         self.exponent = exponent if exponent is not None else BitArray.zeros(11)
@@ -54,7 +62,7 @@ class FlexFloat:
     def to_float(self) -> float:
         """Convert the FlexFloat instance back to a 64-bit float.
 
-        If float is bigger than 64 bits, it will truncate the value to fit into a 64-bit float.
+        If float is bigger than 64 bits, it will truncate the value to fit.
 
         Returns:
             float: The floating-point number represented by the FlexFloat instance.
@@ -73,7 +81,12 @@ class FlexFloat:
         Returns:
             str: A string representation of the FlexFloat instance.
         """
-        return f"FlexFloat(sign={self.sign}, exponent={self.exponent}, fraction={self.fraction})"
+        return (
+            "FlexFloat("
+            f"sign={self.sign}, "
+            f"exponent={self.exponent}, "
+            f"fraction={self.fraction})"
+        )
 
     def pretty(self) -> str:
         """Return an easier to read string representation of the FlexFloat instance.
@@ -103,7 +116,7 @@ class FlexFloat:
         """Create a FlexFloat instance representing Infinity.
 
         Args:
-            sign (bool): The sign of the infinity (True for negative, False for positive).
+            sign (bool): Indicates if the infinity is negative.
         Returns:
             FlexFloat: A new FlexFloat instance representing Infinity.
         """
@@ -130,7 +143,8 @@ class FlexFloat:
         """
         # In IEEE 754, special values have all exponent bits set to 1
         # This corresponds to the maximum value in the unsigned representation
-        # For signed offset binary, the maximum value is 2^(n-1) - 1 where n is the number of bits
+        # For signed offset binary, the maximum value is 2^(n-1) - 1
+        # where n is the number of bits
         max_signed_value = (1 << (len(self.exponent) - 1)) - 1
         return self.exponent.to_signed_int() == max_signed_value
 
@@ -162,36 +176,60 @@ class FlexFloat:
         """Create a copy of the FlexFloat instance.
 
         Returns:
-            FlexFloat: A new FlexFloat instance with the same sign, exponent, and fraction.
+            FlexFloat: A new FlexFloat instance with the same data as the original.
         """
         return FlexFloat(
             sign=self.sign, exponent=self.exponent.copy(), fraction=self.fraction.copy()
         )
 
     def __str__(self) -> str:
-        """Float representation of the FlexFloat."""
-        sign = "-" if self.sign else ""
+        """Float representation of the FlexFloat using a generic algorithm.
+
+        This implementation doesn't rely on Python's float conversion and instead
+        implements the formatting logic directly, making it work for any exponent size.
+
+        Currently, it only operates in scientific notation with 5 decimal places.
+        """
+        sign_str = "-" if self.sign else ""
+        # Handle special cases first
+        if self.is_nan():
+            return "nan"
+
+        if self.is_infinity():
+            return f"{sign_str}inf"
 
-        exponent_value = self.exponent.to_signed_int()
-        if exponent_value == 0:
-            return f"{sign}0.0"
-        max_exponent = 2 ** len(self.exponent) - 1
-        # Check NaN or Infinity
-        if exponent_value == max_exponent:
-            if any(self.fraction):
-                return f"{sign}NaN"
-            return f"{sign}Infinity"
-
-        fraction_value: float = 1
+        if self.is_zero():
+            return f"{sign_str}0.00000e+00"
+
+        exponent = self.exponent.to_signed_int() + 1
+
+        # Convert fraction to decimal value between 1 and 2
+        # (starting with 1.0 for the implicit leading bit)
+        mantissa = 1.0
         for i, bit in enumerate(self.fraction):
             if bit:
-                fraction_value += 2 ** -(i + 1)
+                mantissa += 1.0 / (1 << (i + 1))
+
+        # To avoid overflow with very large exponents, work in log space
+        # log10(mantissa * 2^exponent) = log10(mantissa) + exponent * log10(2)
+        log10_mantissa = math.log10(mantissa)
+        log10_total = log10_mantissa + exponent * LOG10_2
+
+        decimal_exponent = int(log10_total)
+
+        log10_normalized = log10_total - decimal_exponent
+        normalized_mantissa = math.pow(10, log10_normalized)
 
-        if exponent_value == 0:
-            return f"{sign}{fraction_value}.0"
+        # Ensure the mantissa is properly normalized (between 1.0 and 10.0)
+        while normalized_mantissa >= 10.0:
+            normalized_mantissa /= 10.0
+            decimal_exponent += 1
+        while normalized_mantissa < 1.0:
+            normalized_mantissa *= 10.0
+            decimal_exponent -= 1
 
-        # raise NotImplementedError("String representation for non-zero exponent not implemented yet.")
-        return ""
+        # Format with 5 decimal places
+        return f"{sign_str}{normalized_mantissa:.5f}e{decimal_exponent:+03d}"
 
     def __neg__(self) -> FlexFloat:
         """Negate the FlexFloat instance."""
@@ -209,7 +247,8 @@ class FlexFloat:
             exponent (int): The current exponent value.
             exponent_length (int): The current length of the exponent in bits.
         Returns:
-            int: The new exponent length if it needs to be grown, otherwise the same length.
+            int: The new exponent length if it needs to be grown, otherwise the same
+                length.
         """
         while True:
             half = 1 << (exponent_length - 1)
@@ -239,7 +278,7 @@ class FlexFloat:
             return self - (-other)
 
         # OBJECTIVE: Add two FlexFloat instances together.
-        # Based on: https://www.sciencedirect.com/topics/computer-science/floating-point-addition
+        # https://www.sciencedirect.com/topics/computer-science/floating-point-addition
         # and: https://cse.hkust.edu.hk/~cktang/cs180/notes/lec21.pdf
         #
         # Steps:
@@ -285,8 +324,13 @@ class FlexFloat:
             mantissa_other = mantissa_other.shift(shift_amount)
 
         # Step 5: Add mantissas
-        assert len(mantissa_self) == 53, "Fraction must be 53 bits long. (1 leading bit + 52 fraction bits)"  # fmt: skip
-        assert len(mantissa_self) == len(mantissa_other), f"Mantissas must be the same length. Expected 53 bits, got {len(mantissa_other)} bits."  # fmt: skip
+        assert (
+            len(mantissa_self) == 53
+        ), "Fraction must be 53 bits long. (1 leading bit + 52 fraction bits)"
+        assert len(mantissa_self) == len(mantissa_other), (
+            f"Mantissas must be the same length. Expected 53 bits, "
+            f"got {len(mantissa_other)} bits."
+        )
 
         mantissa_result = BitArray.zeros(53)  # 1 leading bit + 52 fraction bits
         carry = False
@@ -398,8 +442,13 @@ class FlexFloat:
             result_sign = not self.sign
 
         # Step 5: Subtract mantissas (larger - smaller)
-        assert len(larger_mantissa) == 53, "Mantissa must be 53 bits long. (1 leading bit + 52 fraction bits)"  # fmt: skip
-        assert len(larger_mantissa) == len(smaller_mantissa), f"Mantissas must be the same length. Expected 53 bits, got {len(smaller_mantissa)} bits."  # fmt: skip
+        assert (
+            len(larger_mantissa) == 53
+        ), "Mantissa must be 53 bits long. (1 leading bit + 52 fraction bits)"
+        assert len(larger_mantissa) == len(smaller_mantissa), (
+            f"Mantissas must be the same length. Expected 53 bits, "
+            f"got {len(smaller_mantissa)} bits."
+        )
 
         mantissa_result = BitArray.zeros(53)
         borrow = False
@@ -451,7 +500,7 @@ class FlexFloat:
             raise TypeError("Can only multiply FlexFloat instances.")
 
         # OBJECTIVE: Multiply two FlexFloat instances together.
-        # Based on: https://www.rfwireless-world.com/tutorials/ieee-754-floating-point-arithmetic
+        # https://www.rfwireless-world.com/tutorials/ieee-754-floating-point-arithmetic
         #
         # Steps:
         # 0. Handle special cases (NaN, Infinity, zero).
@@ -567,7 +616,7 @@ class FlexFloat:
             raise TypeError("Can only divide FlexFloat instances.")
 
         # OBJECTIVE: Divide two FlexFloat instances.
-        # Based on: https://www.rfwireless-world.com/tutorials/ieee-754-floating-point-arithmetic
+        # https://www.rfwireless-world.com/tutorials/ieee-754-floating-point-arithmetic
         #
         # Steps:
         # 0. Handle special cases (NaN, Infinity, zero).
@@ -603,7 +652,8 @@ class FlexFloat:
         result_sign = self.sign ^ other.sign
 
         # Step 2: Extract exponent and fraction bits
-        # Note: The stored exponent needs +1 to get the actual value (like in multiplication)
+        # Note: The stored exponent needs +1 to get the actual value
+        # (like in multiplication)
         exponent_self = self.exponent.to_signed_int() + 1
         exponent_other = other.exponent.to_signed_int() + 1
 

{flexfloat-0.1.0 → flexfloat-0.1.1}/flexfloat.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flexfloat
-Version: 0.1.0
+Version: 0.1.1
 Summary: A library for arbitrary precision floating point arithmetic
 Author: Ferran Sanchez Llado
 License: MIT

{flexfloat-0.1.0 → flexfloat-0.1.1}/flexfloat.egg-info/SOURCES.txt

@@ -17,4 +17,5 @@ tests/test_bitarray.py
 tests/test_conversions.py
 tests/test_division.py
 tests/test_multiplication.py
+tests/test_str_representation.py
 tests/test_subtraction.py

{flexfloat-0.1.0 → flexfloat-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "flexfloat"
-version = "0.1.0"
+version = "0.1.1"
 description = "A library for arbitrary precision floating point arithmetic"
 readme = "README.md"
 authors = [
@@ -56,6 +56,11 @@ disallow_untyped_defs = true
 
 [tool.pylint.main]
 py-version = "3.11"
+ignore-paths = [
+    "venv/",
+    "env/",
+    ".venv/"
+]
 
 [tool.pylint.messages_control]
 disable = [

{flexfloat-0.1.0 → flexfloat-0.1.1}/tests/test_addition.py

@@ -57,7 +57,7 @@ class TestAddition(FlexFloatTestCase):
     def test_flexfloat_addition_rejects_non_flexfloat_operands(self):
         bf = FlexFloat.from_float(1.0)
         with self.assertRaises(TypeError):
-            bf + "not a number"
+            bf + "not a number"  # type: ignore
 
     def test_flexfloat_addition_handles_nan_operands(self):
         bf_normal = FlexFloat.from_float(1.0)

{flexfloat-0.1.0 → flexfloat-0.1.1}/tests/test_bigfloat.py

@@ -3,6 +3,7 @@
 import unittest
 
 from flexfloat import FlexFloat
+from flexfloat.bitarray import BitArray
 from tests import FlexFloatTestCase
 
 
@@ -20,8 +21,8 @@ class TestFlexFloat(FlexFloatTestCase):
     def test_flexfloat_constructor_with_custom_values(self):
         """Test FlexFloat constructor with custom sign, exponent, and fraction."""
         sign = True
-        exponent = [True, False] * 5 + [True]  # 11 bits
-        fraction = [False, True] * 26  # 52 bits
+        exponent = BitArray([True, False] * 5 + [True])  # 11 bits
+        fraction = BitArray([False, True] * 26)  # 52 bits
         bf = FlexFloat(sign=sign, exponent=exponent, fraction=fraction)
         self.assertEqual(bf.sign, sign)
         self.assertEqual(bf.exponent, exponent)
@@ -53,14 +54,18 @@ class TestFlexFloat(FlexFloatTestCase):
         self.assertTrue(bf_nan.is_nan())
 
     def test_flexfloat_to_float_raises_error_on_wrong_dimensions(self):
-        """Test that to_float raises error when exponent or fraction have wrong length."""
+        "Test that to_float raises error when exponent or fraction have wrong length."
         # Wrong exponent length
-        bf_wrong_exp = FlexFloat(exponent=[False] * 10, fraction=[False] * 52)
+        bf_wrong_exp = FlexFloat(
+            exponent=BitArray([False] * 10), fraction=BitArray([False] * 52)
+        )
         with self.assertRaises(ValueError):
             bf_wrong_exp.to_float()
 
         # Wrong fraction length
-        bf_wrong_frac = FlexFloat(exponent=[False] * 11, fraction=[False] * 51)
+        bf_wrong_frac = FlexFloat(
+            exponent=BitArray([False] * 11), fraction=BitArray([False] * 51)
+        )
         with self.assertRaises(ValueError):
             bf_wrong_frac.to_float()
 

{flexfloat-0.1.0 → flexfloat-0.1.1}/tests/test_bitarray.py

@@ -41,10 +41,8 @@ class TestBitArray(FlexFloatTestCase):
 
     def test_bitarray_to_int_converts_large_number_correctly(self):
         """Test conversion of large bit array to integer."""
-        bit_array = BitArray(
-            BitArray.parse_bitarray(
-                "11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111001"
-            )
+        bit_array = BitArray.parse_bitarray(
+            "11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111001"
         )
         expected = 18446744073709551609
         result = bit_array.to_int()
@@ -61,21 +59,21 @@ class TestBitArray(FlexFloatTestCase):
     # === Signed Integer Conversion Tests ===
     def test_bitarray_to_signed_int_converts_zero_bias_correctly(self):
         """Test signed integer conversion with zero as negative bias."""
-        bitarray = BitArray(BitArray.parse_bitarray("00000000001"))  # 11-bit array
+        bitarray = BitArray.parse_bitarray("00000000001")  # 11-bit array
         expected = -1023  # -2^(11-1) + 1 = -1024 + 1
         result = bitarray.to_signed_int()
         self.assertEqual(result, expected)
 
     def test_bitarray_to_signed_int_converts_near_zero_correctly(self):
         """Test signed integer conversion near zero."""
-        bitarray = BitArray(BitArray.parse_bitarray("01111111111"))  # 11-bit array
+        bitarray = BitArray.parse_bitarray("01111111111")  # 11-bit array
         expected = -1  # -2^(11-1) + 1023 = -1024 + 1023
         result = bitarray.to_signed_int()
         self.assertEqual(result, expected)
 
     def test_bitarray_to_signed_int_converts_maximum_value_correctly(self):
         """Test signed integer conversion at maximum value."""
-        bitarray = BitArray(BitArray.parse_bitarray("11111111111"))  # 11-bit array
+        bitarray = BitArray.parse_bitarray("11111111111")  # 11-bit array
         expected = 1023  # -2^(11-1) + 2047 = -1024 + 2047
         result = bitarray.to_signed_int()
         self.assertEqual(result, expected)
@@ -88,13 +86,13 @@ class TestBitArray(FlexFloatTestCase):
     def test_bitarray_to_signed_int_handles_different_lengths(self):
         """Test signed integer conversion with different bit array lengths."""
         # 8-bit test: bias = 2^7 = 128
-        bitarray_8bit = BitArray(BitArray.parse_bitarray("10000000"))  # 128 in unsigned
+        bitarray_8bit = BitArray.parse_bitarray("10000000")  # 128 in unsigned
         expected_8bit = 0  # 128 - 128 = 0
         result_8bit = bitarray_8bit.to_signed_int()
         self.assertEqual(result_8bit, expected_8bit)
 
         # 4-bit test: bias = 2^3 = 8
-        bitarray_4bit = BitArray(BitArray.parse_bitarray("1100"))  # 12 in unsigned
+        bitarray_4bit = BitArray.parse_bitarray("1100")  # 12 in unsigned
         expected_4bit = 4  # 12 - 8 = 4
         result_4bit = bitarray_4bit.to_signed_int()
         self.assertEqual(result_4bit, expected_4bit)
@@ -130,8 +128,8 @@ class TestBitArray(FlexFloatTestCase):
 
         # Test values within range should work
         try:
-            result = BitArray.from_signed_int(127, 8)
-            result = BitArray.from_signed_int(-128, 8)
+            BitArray.from_signed_int(127, 8)
+            BitArray.from_signed_int(-128, 8)
         except AssertionError:
             self.fail("Valid values should not raise AssertionError")
 

{flexfloat-0.1.0 → flexfloat-0.1.1}/tests/test_conversions.py

@@ -86,7 +86,7 @@ class TestConversions(FlexFloatTestCase):
             "00111111 11110000 00000000 00000000 00000000 00000000 00000000 00000000"
         )
         expected = 1.0
-        result = BitArray(bit_array).to_float()
+        result = bit_array.to_float()
         self.assertEqual(result, expected)
 
     def test_bitarray_to_float_converts_negative_number_correctly(self):
@@ -95,7 +95,7 @@ class TestConversions(FlexFloatTestCase):
             "11000010 10101100 10111000 01100010 00110000 10011110 00101010 00000000"
         )
         expected = -15789123456789.0
-        result = BitArray(bit_array).to_float()
+        result = bit_array.to_float()
         self.assertEqual(result, expected)
 
     def test_bitarray_to_float_raises_error_on_wrong_length(self):

{flexfloat-0.1.0 → flexfloat-0.1.1}/tests/test_division.py

@@ -200,7 +200,8 @@ class TestDivision(FlexFloatTestCase):
         # Alternatively, we can check if it matches the expected mathematical result
         # within a reasonable tolerance for very small numbers
         if expected == 0.0:
-            # If the expected result underflows to zero, accept either zero or very small result
+            # If the expected result underflows to zero, accept either zero or very
+            # small result
             self.assertTrue(result.to_float() < 1e-100 or result.is_zero())
         else:
             # Check relative error for non-zero expected results

flexfloat-0.1.1/tests/test_str_representation.py

@@ -0,0 +1,280 @@
+"""Tests for FlexFloat string representation (__str__ method)."""
+
+import math
+import unittest
+
+from flexfloat import BitArray, FlexFloat
+from tests import FlexFloatTestCase
+
+
+class TestStrRepresentation(FlexFloatTestCase):
+    """Test FlexFloat string representation operations."""
+
+    def test_str_zero_returns_correct_format(self):
+        """Test that zero is represented as '0.0'."""
+        ff = FlexFloat.from_float(0.0)
+        expected = f"{0.0:.5e}"
+        self.assertEqual(str(ff), expected)
+
+    def test_str_negative_zero_returns_correct_format(self):
+        """Test that negative zero is represented as '0.0'."""
+        ff = FlexFloat.from_float(-0.0)
+        expected = f"{-0.0:.5e}"
+        self.assertEqual(str(ff), expected)
+
+    def test_str_one_returns_correct_format(self):
+        """Test that 1.0 is represented correctly."""
+        ff = FlexFloat.from_float(1.0)
+        expected = f"{1.0:.5e}"
+        self.assertEqual(str(ff), expected)
+
+    def test_str_negative_one_returns_correct_format(self):
+        """Test that -1.0 is represented correctly."""
+        ff = FlexFloat.from_float(-1.0)
+        expected = f"{-1.0:.5e}"
+        self.assertEqual(str(ff), expected)
+
+    def test_str_small_decimal_returns_correct_format(self):
+        """Test that small decimal numbers are represented correctly."""
+        ff = FlexFloat.from_float(0.5)
+        expected = f"{0.5:.5e}"
+        self.assertEqual(str(ff), expected)
+
+        ff = FlexFloat.from_float(0.25)
+        expected = f"{0.25:.5e}"
+        self.assertEqual(str(ff), expected)
+
+        ff = FlexFloat.from_float(0.125)
+        expected = f"{0.125:.5e}"
+        self.assertEqual(str(ff), expected)
+
+    def test_str_large_integers_returns_correct_format(self):
+        """Test that large integers are represented correctly."""
+        ff = FlexFloat.from_float(42.0)
+        expected = f"{42.0:.5e}"
+        self.assertEqual(str(ff), expected)
+
+        ff = FlexFloat.from_float(1000.0)
+        expected = f"{1000.0:.5e}"
+        self.assertEqual(str(ff), expected)
+
+        ff = FlexFloat.from_float(123456.0)
+        expected = f"{123456.0:.5e}"
+        self.assertEqual(str(ff), expected)
+
+    def test_str_decimal_numbers_returns_correct_format(self):
+        """Test that decimal numbers are represented correctly."""
+        ff = FlexFloat.from_float(3.14159)
+        expected = f"{3.14159:.5e}"
+        self.assertEqual(str(ff), expected)
+
+        ff = FlexFloat.from_float(2.718281828)
+        expected = f"{2.718281828:.5e}"
+        self.assertEqual(str(ff), expected)
+
+    def test_str_very_small_numbers_uses_scientific_notation(self):
+        """Test that very small numbers use scientific notation."""
+        ff = FlexFloat.from_float(1e-5)
+        expected = f"{1e-5:.5e}"
+        self.assertEqual(str(ff), expected)
+
+        ff = FlexFloat.from_float(1e-10)
+        expected = f"{1e-10:.5e}"
+        self.assertEqual(str(ff), expected)
+
+        ff = FlexFloat.from_float(1.23e-6)
+        expected = f"{1.23e-6:.5e}"
+        self.assertEqual(str(ff), expected)
+
+    def test_str_very_large_numbers_uses_scientific_notation(self):
+        """Test that very large numbers use scientific notation."""
+        ff = FlexFloat.from_float(1e20)
+        expected = f"{1e20:.5e}"
+        self.assertEqual(str(ff), expected)
+
+        ff = FlexFloat.from_float(1.5e25)
+        expected = f"{1.5e25:.5e}"
+        self.assertEqual(str(ff), expected)
+
+    def test_str_special_values(self):
+        """Test that special values (NaN, Infinity) are represented correctly."""
+        # Test NaN
+        ff = FlexFloat.nan()
+        self.assertEqual(str(ff), "nan")
+
+        # Test positive infinity
+        ff = FlexFloat.infinity(sign=False)
+        self.assertEqual(str(ff), "inf")
+
+        # Test negative infinity
+        ff = FlexFloat.infinity(sign=True)
+        self.assertEqual(str(ff), "-inf")
+
+    def test_str_negative_numbers(self):
+        """Test that negative numbers are represented correctly."""
+        ff = FlexFloat.from_float(-3.14159)
+        expected = f"{-3.14159:.5e}"
+        self.assertEqual(str(ff), expected)
+
+        ff = FlexFloat.from_float(-42.0)
+        expected = f"{-42.0:.5e}"
+        self.assertEqual(str(ff), expected)
+
+        ff = FlexFloat.from_float(-1e-5)
+        expected = f"{-1e-5:.5e}"
+        self.assertEqual(str(ff), expected)
+
+    def test_str_edge_cases(self):
+        """Test edge cases for string representation."""
+        # Test minimum positive normalized number
+        ff = FlexFloat.from_float(2.2250738585072014e-308)
+        expected = f"{2.2250738585072014e-308:.5e}"
+        self.assertEqual(str(ff), expected)
+
+        # Test maximum finite number
+        ff = FlexFloat.from_float(1.7976931348623157e308)
+        expected = f"{1.7976931348623157e308:.5e}"
+        self.assertEqual(str(ff), expected)
+
+    def test_str_consistency_with_python_float(self):
+        """Test that FlexFloat str() is consistent with Python float str()."""
+        test_values = [
+            0.0,
+            1.0,
+            -1.0,
+            0.5,
+            -0.5,
+            3.14159,
+            -3.14159,
+            42.0,
+            -42.0,
+            1000.0,
+            -1000.0,
+            1e-5,
+            -1e-5,
+            1e-10,
+            -1e-10,
+            1e20,
+            -1e20,
+            1.5e25,
+            -1.5e25,
+            123.456789,
+            -123.456789,
+            0.000123456789,
+            -0.000123456789,
+        ]
+
+        for value in test_values:
+            with self.subTest(value=value):
+                ff = FlexFloat.from_float(value)
+                python_str = f"{value:.5e}"
+                flexfloat_str = str(ff)
+                self.assertEqual(
+                    flexfloat_str,
+                    python_str,
+                    f"FlexFloat str({value}) = '{flexfloat_str}' != "
+                    f"Python str({value}) = '{python_str}'",
+                )
+
+    def test_str_mathematical_constants(self):
+        """Test string representation of mathematical constants."""
+        # Test pi
+        ff = FlexFloat.from_float(math.pi)
+        expected = f"{math.pi:.5e}"
+        self.assertEqual(str(ff), expected)
+
+        # Test e
+        ff = FlexFloat.from_float(math.e)
+        expected = f"{math.e:.5e}"
+        self.assertEqual(str(ff), expected)
+
+        # Test sqrt(2)
+        sqrt2 = math.sqrt(2)
+        ff = FlexFloat.from_float(sqrt2)
+        expected = f"{sqrt2:.5e}"
+        self.assertEqual(str(ff), expected)
+
+    def test_str_powers_of_two(self):
+        """Test string representation of powers of two."""
+        for i in range(-10, 11):
+            value = 2.0**i
+            with self.subTest(power=i, value=value):
+                ff = FlexFloat.from_float(value)
+                expected = f"{value:.5e}"
+                self.assertEqual(str(ff), expected)
+
+    def test_str_powers_of_ten(self):
+        """Test string representation of powers of ten."""
+        for i in range(-5, 6):
+            value = 10.0**i
+            with self.subTest(power=i, value=value):
+                ff = FlexFloat.from_float(value)
+                expected = f"{value:.5e}"
+                self.assertEqual(str(ff), expected)
+
+    def test_str_fractional_numbers(self):
+        """Test string representation of various fractional numbers."""
+        fractions = [
+            1.0 / 3.0,  # 0.3333...
+            1.0 / 7.0,  # 0.142857...
+            22.0 / 7.0,  # approximation of pi
+            355.0 / 113.0,  # better approximation of pi
+        ]
+
+        for value in fractions:
+            with self.subTest(value=value):
+                ff = FlexFloat.from_float(value)
+                expected = f"{value:.5e}"
+                self.assertEqual(str(ff), expected)
+
+    def test_str_extended_exponent_numbers(self):
+        """Test string representation of numbers with extended exponents."""
+        # Test with large exponent
+        extended_exp = BitArray.from_signed_int(500, 12)  # 12-bit exponent
+        frac = BitArray.zeros(52)
+        ff = FlexFloat(sign=False, exponent=extended_exp, fraction=frac)
+        result = str(ff)
+        # This represents 2^501, which in decimal scientific notation is ~6.54678e+150
+        self.assertEqual(result, "6.54678e+150")
+
+        # Test with negative large exponent
+        extended_exp = BitArray.from_signed_int(-500, 12)  # 12-bit exponent
+        ff = FlexFloat(sign=False, exponent=extended_exp, fraction=frac)
+        result = str(ff)
+        # This represents 2^(-499), which in decimal scientific notation is 6.10987e-151
+        self.assertEqual(result, "6.10987e-151")
+
+        # Test with negative sign and extended exponent
+        ff = FlexFloat(sign=True, exponent=extended_exp, fraction=frac)
+        result = str(ff)
+        self.assertEqual(result, "-6.10987e-151")
+
+    def test_str_extreme_exponent_numbers(self):
+        """Test string representation of numbers with extreme exponents."""
+        # Test with very large exponent that causes overflow
+        extended_exp = BitArray.from_signed_int(2000, 15)  # 15-bit exponent
+        frac = BitArray.zeros(52)
+        ff = FlexFloat(sign=False, exponent=extended_exp, fraction=frac)
+        result = str(ff)
+        # This represents 2^2001, which in decimal scientific notation is ~2.29626e+602
+        self.assertTrue("e+" in result)
+        self.assertIn("e+602", result)
+
+    def test_str_extended_precision_arithmetic_results(self):
+        """Test string representation after arithmetic with extended precision."""
+        # Create very large numbers that will result in extended exponents
+        ff1 = FlexFloat.from_float(1e150)
+        ff2 = FlexFloat.from_float(1e150)
+
+        # Multiplication should create a very large result
+        result = ff1 * ff2
+        result_str = str(result)
+
+        # Should be in scientific notation
+        self.assertTrue("e+" in result_str)
+        # Should show approximately 1e300
+        self.assertTrue(result_str.startswith("1.00000e+"))
+
+
+if __name__ == "__main__":
+    unittest.main()

{flexfloat-0.1.0 → flexfloat-0.1.1}/tests/test_subtraction.py

@@ -81,7 +81,7 @@ class TestSubtraction(FlexFloatTestCase):
     def test_flexfloat_subtraction_rejects_non_flexfloat_operands(self):
         bf = FlexFloat.from_float(1.0)
         with self.assertRaises(TypeError):
-            bf - "not a number"
+            bf - "not a number"  # type: ignore
 
     def test_flexfloat_subtraction_handles_nan_operands(self):
         bf_normal = FlexFloat.from_float(1.0)
@@ -170,8 +170,10 @@ class TestSubtraction(FlexFloatTestCase):
         self.assertGreater(result2.to_float(), 0)
 
     def test_flexfloat_subtraction_exponent_growth_on_underflow(self):
-        """Test that subtraction causes exponent growth on underflow instead of going to zero like normal float."""
-        # Test case 1: Subtracting very close small numbers that result in extreme underflow
+        """Test that subtraction causes exponent growth on underflow instead of going
+        to zero like normal float."""
+        # Test case 1: Subtracting very close small numbers that result in extreme
+        # underflow
         # Create two very small numbers that are very close to each other
         small1 = FlexFloat.from_float(1e-300)
         small2 = FlexFloat.from_float(9.99999999999999e-301)  # Very close to small1
@@ -192,7 +194,7 @@ class TestSubtraction(FlexFloatTestCase):
         self.assertFalse(result.is_nan())
 
         # Test case 2: Subtraction that causes normalization shift and underflow
-        # Create numbers where subtraction leads to significant leading zero cancellation
+        # Create numbers where sub leads to significant leading zero cancellation
         num1 = FlexFloat.from_float(1.0000000000000002)  # Very close to 1.0
         num2 = FlexFloat.from_float(1.0)
 
@@ -226,8 +228,8 @@ class TestSubtraction(FlexFloatTestCase):
         # The result should not be zero and should require exponent growth
         self.assertFalse(result3.is_zero())
 
-        # Check that the result's exponent is longer than the original standard 11-bit exponent
-        # to handle the extreme underflow scenario
+        # Check that the result's exponent is longer than the original standard 11-bit
+        # exponent to handle the extreme underflow scenario
         if len(result3.exponent) > 11:
             # Exponent growth occurred - this is what we're testing for
             self.assertGreater(len(result3.exponent), 11)