flexfloat 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

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/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/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.dist-info → flexfloat-0.1.1.dist-info}/METADATA

@@ -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.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+flexfloat/__init__.py,sha256=SFtec_6Rr65_Sr83rhoh9VT7Egj8N-e2F0fyMQbBqKg,378
+flexfloat/bitarray.py,sha256=hlJtoe50Lx6KdNTyMNFkJCBON4t_gtCDc3hWfX_bza4,9196
+flexfloat/core.py,sha256=7bnw7aJvnFOD1RTtZvH9nc4QCKcSowqsSGhcncAMlJI,28771
+flexfloat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flexfloat/types.py,sha256=SFTYmG3BHLiCJc0LvNwOnByRLRcRXH2erINeqLyHLKs,118
+flexfloat-0.1.1.dist-info/METADATA,sha256=SMM9FyWRr08gI32_gssW0bkCLxPF-MTm9lim3J_-Wdk,2459
+flexfloat-0.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+flexfloat-0.1.1.dist-info/top_level.txt,sha256=82S8dY2UoNZh-9pwg7tUvbwB3uw2s3mfEoyUW6vCMdU,10
+flexfloat-0.1.1.dist-info/RECORD,,

flexfloat-0.1.0.dist-info/RECORD

@@ -1,9 +0,0 @@
-flexfloat/__init__.py,sha256=fvimTZm80CHm8bp11bID5twYoISERcatgx21snQxsz8,378
-flexfloat/bitarray.py,sha256=Ss0bZUUpfsBPJkPaGymXd2O-4e-UCanUva_encnc4MI,9172
-flexfloat/core.py,sha256=KK8LfRlqReZuVgyN-fQwYDsM1TlaJtYjHcafPYSPZeQ,27570
-flexfloat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-flexfloat/types.py,sha256=SFTYmG3BHLiCJc0LvNwOnByRLRcRXH2erINeqLyHLKs,118
-flexfloat-0.1.0.dist-info/METADATA,sha256=8QUYOP_vFgljckHUm02jixPFfDYkt-XZdW5Wahm8TbQ,2459
-flexfloat-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-flexfloat-0.1.0.dist-info/top_level.txt,sha256=82S8dY2UoNZh-9pwg7tUvbwB3uw2s3mfEoyUW6vCMdU,10
-flexfloat-0.1.0.dist-info/RECORD,,