flexfloat 0.1.0__py3-none-any.whl

flexfloat/__init__.py

@@ -0,0 +1,13 @@
+"""FlexFloat - A library for arbitrary precision floating point arithmetic.
+
+This package provides the FlexFloat class for handling floating-point numbers
+with growable exponents and fixed-size fractions.
+"""
+
+from .bitarray import BitArray
+from .core import FlexFloat
+
+__version__ = "0.1.0"
+__author__ = "Ferran Sanchez Llado"
+
+__all__ = ["FlexFloat", "BitArray"]

flexfloat/bitarray.py

@@ -0,0 +1,253 @@
+"""BitArray implementation for the flexfloat package."""
+
+from __future__ import annotations
+
+import struct
+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.
+    """
+
+    def __init__(self, bits: list[bool] | None = None):
+        """Initialize a BitArray.
+
+        Args:
+            bits: Initial list of boolean values. Defaults to empty list.
+        """
+        self._bits = bits if bits is not None else []
+
+    @classmethod
+    def from_float(cls, value: float) -> BitArray:
+        """Convert a floating-point number to a bit array.
+
+        Args:
+            value (float): The floating-point number to convert.
+        Returns:
+            BitArray: A BitArray representing the bits of the floating-point number.
+        """
+        # Pack as double precision (64 bits)
+        packed = struct.pack("!d", value)
+        # Convert to boolean list
+        bits = [bool((byte >> bit) & 1) for byte in packed for bit in range(7, -1, -1)]
+        return cls(bits)
+
+    @classmethod
+    def from_signed_int(cls, value: int, length: int) -> BitArray:
+        """Convert a signed integer to a bit array using off-set binary representation.
+
+        Args:
+            value (int): The signed integer to convert.
+            length (int): The length of the resulting bit array.
+        Returns:
+            BitArray: A BitArray representing the bits of the signed integer.
+        Raises:
+            AssertionError: If the value is out of range for the specified length.
+        """
+        half = 1 << (length - 1)
+        max_value = half - 1
+        min_value = -half
+
+        assert (
+            min_value <= value <= max_value
+        ), "Value out of range for specified length."
+
+        # Convert to unsigned integer representation
+        unsigned_value = value - half
+
+        bits = [(unsigned_value >> i) & 1 == 1 for i in range(length - 1, -1, -1)]
+        return cls(bits)
+
+    @classmethod
+    def zeros(cls, length: int) -> BitArray:
+        """Create a BitArray filled with zeros.
+
+        Args:
+            length: The length of the bit array.
+        Returns:
+            BitArray: A BitArray filled with False values.
+        """
+        return cls([False] * length)
+
+    @classmethod
+    def ones(cls, length: int) -> BitArray:
+        """Create a BitArray filled with ones.
+
+        Args:
+            length: The length of the bit array.
+        Returns:
+            BitArray: A BitArray filled with True values.
+        """
+        return cls([True] * length)
+
+    @staticmethod
+    def parse_bitarray(bitstring: str) -> BitArray:
+        """Parse a string of bits (with optional spaces) into a BitArray instance."""
+        bits = [c == "1" for c in bitstring if c in "01"]
+        return BitArray(bits)
+
+    def to_float(self) -> float:
+        """Convert a 64-bit array to a floating-point number.
+
+        Returns:
+            float: The floating-point number represented by the bit array.
+        Raises:
+            AssertionError: If the bit array is not 64 bits long.
+        """
+        assert len(self._bits) == 64, "Bit array must be 64 bits long."
+
+        byte_values = bytearray()
+        for i in range(0, 64, 8):
+            byte = 0
+            for j in range(8):
+                if self._bits[i + j]:
+                    byte |= 1 << (7 - j)
+            byte_values.append(byte)
+        # Unpack as double precision (64 bits)
+        return struct.unpack("!d", bytes(byte_values))[0]  # type: ignore
+
+    def to_int(self) -> int:
+        """Convert the bit array to an unsigned integer.
+
+        Returns:
+            int: The integer represented by the bit array.
+        """
+        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.
+
+        Returns:
+            int: The signed integer represented by the bit array.
+        Raises:
+            AssertionError: If the bit array is empty.
+        """
+        assert len(self._bits) > 0, "Bit array must not be empty."
+
+        int_value = self.to_int()
+        # Half of the maximum value
+        bias = 1 << (len(self._bits) - 1)
+        # If the sign bit is set, subtract the bias
+        return int_value - bias
+
+    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.
+
+        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.
+        Returns:
+            BitArray: A new BitArray with the bits shifted and filled.
+        """
+        if shift_amount == 0:
+            return self.copy()
+        if abs(shift_amount) > len(self._bits):
+            new_bits = [fill] * len(self._bits)
+        elif shift_amount > 0:
+            new_bits = [fill] * shift_amount + self._bits[:-shift_amount]
+        else:
+            new_bits = self._bits[-shift_amount:] + [fill] * (-shift_amount)
+        return BitArray(new_bits)
+
+    def copy(self) -> BitArray:
+        """Create a copy of the bit array.
+
+        Returns:
+            BitArray: A new BitArray with the same bits.
+        """
+        return BitArray(self._bits.copy())
+
+    def __len__(self) -> int:
+        """Return the length of the bit array."""
+        return len(self._bits)
+
+    @overload
+    def __getitem__(self, index: int) -> bool: ...
+    @overload
+    def __getitem__(self, index: slice) -> BitArray: ...
+
+    def __getitem__(self, index: int | slice) -> bool | BitArray:
+        """Get an item or slice from the bit array."""
+        if isinstance(index, slice):
+            return BitArray(self._bits[index])
+        return self._bits[index]
+
+    @overload
+    def __setitem__(self, index: int, value: bool) -> None: ...
+    @overload
+    def __setitem__(self, index: slice, value: BitArray | list[bool]) -> None: ...
+
+    def __setitem__(
+        self, index: int | slice, value: bool | list[bool] | BitArray
+    ) -> None:
+        """Set an item or slice in the bit array."""
+        if isinstance(index, slice):
+            if isinstance(value, BitArray):
+                self._bits[index] = value._bits
+            elif isinstance(value, list):
+                self._bits[index] = value
+            else:
+                raise TypeError("Cannot assign a single bool to a slice")
+            return
+        if isinstance(value, bool):
+            self._bits[index] = value
+        else:
+            raise TypeError("Cannot assign a list or BitArray to a single index")
+
+    def __iter__(self) -> Iterator[bool]:
+        """Iterate over the bits in the array."""
+        return iter(self._bits)
+
+    def __add__(self, other: BitArray | list[bool]) -> BitArray:
+        """Concatenate two bit arrays."""
+        if isinstance(other, BitArray):
+            return BitArray(self._bits + other._bits)
+        return BitArray(self._bits + other)
+
+    def __radd__(self, other: list[bool]) -> BitArray:
+        """Reverse concatenation with a list."""
+        return BitArray(other + self._bits)
+
+    def __eq__(self, other: object) -> bool:
+        """Check equality with another BitArray or list."""
+        if isinstance(other, BitArray):
+            return self._bits == other._bits
+        if isinstance(other, list):
+            return self._bits == other
+        return False
+
+    def __bool__(self) -> bool:
+        """Return True if any bit is set."""
+        return any(self._bits)
+
+    def __repr__(self) -> str:
+        """Return a string representation of the BitArray."""
+        return f"BitArray({self._bits})"
+
+    def __str__(self) -> str:
+        """Return a string representation of the bits."""
+        return "".join("1" if bit else "0" for bit in self._bits)
+
+    def any(self) -> bool:
+        """Return True if any bit is set to True."""
+        return any(self._bits)
+
+    def all(self) -> bool:
+        """Return True if all bits are set to True."""
+        return all(self._bits)
+
+    def count(self, value: bool = True) -> int:
+        """Count the number of bits set to the specified value."""
+        return self._bits.count(value)
+
+    def reverse(self) -> BitArray:
+        """Return a new BitArray with the bits in reverse order."""
+        return BitArray(self._bits[::-1])

flexfloat/core.py

@@ -0,0 +1,678 @@
+"""Core FlexFloat class implementation."""
+
+from __future__ import annotations
+
+from .bitarray import BitArray
+from .types import Number
+
+
+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.
+
+    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.
+    """
+
+    def __init__(
+        self,
+        sign: bool = False,
+        exponent: BitArray | None = None,
+        fraction: BitArray | None = None,
+    ):
+        """Initialize a FlexFloat instance.
+
+        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.
+        """
+        self.sign = sign
+        self.exponent = exponent if exponent is not None else BitArray.zeros(11)
+        self.fraction = fraction if fraction is not None else BitArray.zeros(52)
+
+    @classmethod
+    def from_float(cls, value: Number) -> FlexFloat:
+        """Create a FlexFloat instance from a number.
+
+        Args:
+            value (Number): The number to convert to FlexFloat.
+        Returns:
+            FlexFloat: A new FlexFloat instance representing the number.
+        """
+        value = float(value)
+        bits = BitArray.from_float(value)
+
+        return cls(sign=bits[0], exponent=bits[1:12], fraction=bits[12:64])
+
+    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.
+
+        Returns:
+            float: The floating-point number represented by the FlexFloat instance.
+        Raises:
+            ValueError: If the exponent or fraction lengths are not as expected.
+        """
+        if len(self.exponent) < 11 or len(self.fraction) < 52:
+            raise ValueError("Must be a standard 64-bit FlexFloat")
+
+        bits = BitArray([self.sign]) + self.exponent[:11] + self.fraction[:52]
+        return bits.to_float()
+
+    def __repr__(self) -> str:
+        """Return a string representation of the FlexFloat instance.
+
+        Returns:
+            str: A string representation of the FlexFloat instance.
+        """
+        return f"FlexFloat(sign={self.sign}, exponent={self.exponent}, fraction={self.fraction})"
+
+    def pretty(self) -> str:
+        """Return an easier to read string representation of the FlexFloat instance.
+        Mainly converts the exponent and fraction to integers for readability.
+
+        Returns:
+            str: A pretty string representation of the FlexFloat instance.
+        """
+        sign = "-" if self.sign else ""
+        exponent_value = self.exponent.to_signed_int() + 1
+        fraction_value = self.fraction.to_int()
+        return f"{sign}FlexFloat(exponent={exponent_value}, fraction={fraction_value})"
+
+    @classmethod
+    def nan(cls) -> FlexFloat:
+        """Create a FlexFloat instance representing NaN (Not a Number).
+
+        Returns:
+            FlexFloat: A new FlexFloat instance representing NaN.
+        """
+        exponent = BitArray.ones(11)
+        fraction = BitArray.ones(52)
+        return cls(sign=True, exponent=exponent, fraction=fraction)
+
+    @classmethod
+    def infinity(cls, sign: bool = False) -> FlexFloat:
+        """Create a FlexFloat instance representing Infinity.
+
+        Args:
+            sign (bool): The sign of the infinity (True for negative, False for positive).
+        Returns:
+            FlexFloat: A new FlexFloat instance representing Infinity.
+        """
+        exponent = BitArray.ones(11)
+        fraction = BitArray.zeros(52)
+        return cls(sign=sign, exponent=exponent, fraction=fraction)
+
+    @classmethod
+    def zero(cls) -> FlexFloat:
+        """Create a FlexFloat instance representing zero.
+
+        Returns:
+            FlexFloat: A new FlexFloat instance representing zero.
+        """
+        exponent = BitArray.zeros(11)
+        fraction = BitArray.zeros(52)
+        return cls(sign=False, exponent=exponent, fraction=fraction)
+
+    def _is_special_exponent(self) -> bool:
+        """Check if the exponent represents a special value (NaN or Infinity).
+
+        Returns:
+            bool: True if the exponent is at its maximum value, False otherwise.
+        """
+        # 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
+        max_signed_value = (1 << (len(self.exponent) - 1)) - 1
+        return self.exponent.to_signed_int() == max_signed_value
+
+    def is_nan(self) -> bool:
+        """Check if the FlexFloat instance represents NaN (Not a Number).
+
+        Returns:
+            bool: True if the FlexFloat instance is NaN, False otherwise.
+        """
+        return self._is_special_exponent() and any(self.fraction)
+
+    def is_infinity(self) -> bool:
+        """Check if the FlexFloat instance represents Infinity.
+
+        Returns:
+            bool: True if the FlexFloat instance is Infinity, False otherwise.
+        """
+        return self._is_special_exponent() and not any(self.fraction)
+
+    def is_zero(self) -> bool:
+        """Check if the FlexFloat instance represents zero.
+
+        Returns:
+            bool: True if the FlexFloat instance is zero, False otherwise.
+        """
+        return not any(self.exponent) and not any(self.fraction)
+
+    def copy(self) -> FlexFloat:
+        """Create a copy of the FlexFloat instance.
+
+        Returns:
+            FlexFloat: A new FlexFloat instance with the same sign, exponent, and fraction.
+        """
+        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 ""
+
+        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
+        for i, bit in enumerate(self.fraction):
+            if bit:
+                fraction_value += 2 ** -(i + 1)
+
+        if exponent_value == 0:
+            return f"{sign}{fraction_value}.0"
+
+        # raise NotImplementedError("String representation for non-zero exponent not implemented yet.")
+        return ""
+
+    def __neg__(self) -> FlexFloat:
+        """Negate the FlexFloat instance."""
+        return FlexFloat(
+            sign=not self.sign,
+            exponent=self.exponent.copy(),
+            fraction=self.fraction.copy(),
+        )
+
+    @staticmethod
+    def _grow_exponent(exponent: int, exponent_length: int) -> int:
+        """Grow the exponent if it exceeds the maximum value for the current length.
+
+        Args:
+            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.
+        """
+        while True:
+            half = 1 << (exponent_length - 1)
+            min_exponent = -half
+            max_exponent = half - 1
+
+            if min_exponent <= exponent <= max_exponent:
+                break
+            exponent_length += 1
+
+        return exponent_length
+
+    def __add__(self, other: FlexFloat | Number) -> FlexFloat:
+        """Add two FlexFloat instances together.
+
+        Args:
+            other (FlexFloat | float | int): The other FlexFloat instance to add.
+        Returns:
+            FlexFloat: A new FlexFloat instance representing the sum.
+        """
+        if isinstance(other, Number):
+            other = FlexFloat.from_float(other)
+        if not isinstance(other, FlexFloat):
+            raise TypeError("Can only add FlexFloat instances.")
+
+        if self.sign != other.sign:
+            return self - (-other)
+
+        # OBJECTIVE: Add two FlexFloat instances together.
+        # Based on: https://www.sciencedirect.com/topics/computer-science/floating-point-addition
+        # and: https://cse.hkust.edu.hk/~cktang/cs180/notes/lec21.pdf
+        #
+        # Steps:
+        # 0. Handle special cases (NaN, Infinity).
+        # 1. Extract exponent and fraction bits.
+        # 2. Prepend leading 1 to form the mantissa.
+        # 3. Compare exponents.
+        # 4. Shift smaller mantissa if necessary.
+        # 5. Add mantissas.
+        # 6. Normalize mantissa and adjust exponent if necessary.
+        # 7. Grow exponent if necessary.
+        # 8. Round result.
+        # 9. Return new FlexFloat instance.
+
+        # Step 0: Handle special cases
+        if self.is_zero() or other.is_zero():
+            return self.copy() if other.is_zero() else other.copy()
+
+        if self.is_nan() or other.is_nan():
+            return FlexFloat.nan()
+
+        if self.is_infinity() and other.is_infinity():
+            return self.copy() if self.sign == other.sign else FlexFloat.nan()
+        if self.is_infinity() or other.is_infinity():
+            return self.copy() if self.is_infinity() else other.copy()
+
+        # Step 1: Extract exponent and fraction bits
+        exponent_self = self.exponent.to_signed_int() + 1
+        exponent_other = other.exponent.to_signed_int() + 1
+
+        # Step 2: Prepend leading 1 to form the mantissa
+        mantissa_self = [True] + self.fraction
+        mantissa_other = [True] + other.fraction
+
+        # Step 3: Compare exponents (self is always larger or equal)
+        if exponent_self < exponent_other:
+            exponent_self, exponent_other = exponent_other, exponent_self
+            mantissa_self, mantissa_other = mantissa_other, mantissa_self
+
+        # Step 4: Shift smaller mantissa if necessary
+        if exponent_self > exponent_other:
+            shift_amount = exponent_self - exponent_other
+            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
+
+        mantissa_result = BitArray.zeros(53)  # 1 leading bit + 52 fraction bits
+        carry = False
+        for i in range(52, -1, -1):
+            total = mantissa_self[i] + mantissa_other[i] + carry
+            mantissa_result[i] = total % 2 == 1
+            carry = total > 1
+
+        # Step 6: Normalize mantissa and adjust exponent if necessary
+        # Only need to normalize if there is a carry
+        if carry:
+            # Insert the carry bit and shift right
+            mantissa_result = mantissa_result.shift(1, fill=True)
+            exponent_self += 1
+
+        # Step 7: Grow exponent if necessary
+        exp_result_length = self._grow_exponent(exponent_self, len(self.exponent))
+        assert (
+            exponent_self - (1 << (exp_result_length - 1)) < 2
+        ), "Exponent growth should not exceed 1 bit."
+
+        exponent_result = BitArray.from_signed_int(exponent_self - 1, exp_result_length)
+        return FlexFloat(
+            sign=self.sign,
+            exponent=exponent_result,
+            fraction=mantissa_result[1:],  # Exclude leading bit
+        )
+
+    def __sub__(self, other: FlexFloat | Number) -> FlexFloat:
+        """Subtract one FlexFloat instance from another.
+
+        Args:
+            other (FlexFloat | float | int): The FlexFloat instance to subtract.
+        Returns:
+            FlexFloat: A new FlexFloat instance representing the difference.
+        """
+        if isinstance(other, Number):
+            other = FlexFloat.from_float(other)
+        if not isinstance(other, FlexFloat):
+            raise TypeError("Can only subtract FlexFloat instances.")
+
+        # If signs are different, subtraction becomes addition
+        if self.sign != other.sign:
+            return self + (-other)
+
+        # OBJECTIVE: Subtract two FlexFloat instances.
+        # Based on floating-point subtraction algorithms
+        #
+        # Steps:
+        # 0. Handle special cases (NaN, Infinity, zero).
+        # 1. Extract exponent and fraction bits.
+        # 2. Prepend leading 1 to form the mantissa.
+        # 3. Compare exponents and align mantissas.
+        # 4. Compare magnitudes to determine result sign.
+        # 5. Subtract mantissas (larger - smaller).
+        # 6. Normalize mantissa and adjust exponent if necessary.
+        # 7. Grow exponent if necessary.
+        # 8. Return new FlexFloat instance.
+
+        # Step 0: Handle special cases
+        if self.is_zero() or other.is_zero():
+            return self.copy() if other.is_zero() else -other.copy()
+
+        if self.is_nan() or other.is_nan():
+            return FlexFloat.nan()
+
+        if self.is_infinity() and other.is_infinity():
+            if self.sign == other.sign:
+                return FlexFloat.nan()  # inf - inf = NaN
+            return self.copy()  # inf - (-inf) = inf
+
+        if self.is_infinity():
+            return self.copy()
+
+        if other.is_infinity():
+            return -other
+
+        # Step 1: Extract exponent and fraction bits
+        exponent_self = self.exponent.to_signed_int() + 1
+        exponent_other = other.exponent.to_signed_int() + 1
+
+        # Step 2: Prepend leading 1 to form the mantissa
+        mantissa_self = [True] + self.fraction
+        mantissa_other = [True] + other.fraction
+
+        # Step 3: Align mantissas by shifting the smaller exponent
+        result_sign = self.sign
+        shift_amount = abs(exponent_self - exponent_other)
+        if exponent_self >= exponent_other:
+            mantissa_other = mantissa_other.shift(shift_amount)
+            result_exponent = exponent_self
+        else:
+            mantissa_self = mantissa_self.shift(shift_amount)
+            result_exponent = exponent_other
+
+        # Step 4: Compare magnitudes to determine which mantissa is larger
+        # Convert mantissas to integers for comparison
+        mantissa_self_int = mantissa_self.to_int()
+        mantissa_other_int = mantissa_other.to_int()
+
+        if mantissa_self_int >= mantissa_other_int:
+            larger_mantissa = mantissa_self
+            smaller_mantissa = mantissa_other
+            result_sign = self.sign
+        else:
+            larger_mantissa = mantissa_other
+            smaller_mantissa = mantissa_self
+            # Flip sign since we're computing -(smaller - larger)
+            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
+
+        mantissa_result = BitArray.zeros(53)
+        borrow = False
+        for i in range(52, -1, -1):
+            diff = int(larger_mantissa[i]) - int(smaller_mantissa[i]) - int(borrow)
+
+            mantissa_result[i] = diff % 2 == 1
+            borrow = diff < 0
+
+        assert not borrow, "Subtraction should not result in a negative mantissa."
+
+        # Step 6: Normalize mantissa and adjust exponent if necessary
+        # Find the first 1 bit (leading bit might have been canceled out)
+        leading_zero_count = next(
+            (i for i, bit in enumerate(mantissa_result) if bit), len(mantissa_result)
+        )
+
+        # Handle case where result becomes zero or denormalized
+        if leading_zero_count >= 53:
+            return FlexFloat.from_float(0.0)
+
+        if leading_zero_count > 0:
+            # Shift left to normalize
+            mantissa_result = mantissa_result.shift(-leading_zero_count)
+            result_exponent -= leading_zero_count
+
+        # Step 7: Grow exponent if necessary (handle underflow)
+        exp_result_length = self._grow_exponent(result_exponent, len(self.exponent))
+
+        exp_result = BitArray.from_signed_int(result_exponent - 1, exp_result_length)
+
+        return FlexFloat(
+            sign=result_sign,
+            exponent=exp_result,
+            fraction=mantissa_result[1:],  # Exclude leading bit
+        )
+
+    def __mul__(self, other: FlexFloat | Number) -> FlexFloat:
+        """Multiply two FlexFloat instances together.
+
+        Args:
+            other (FlexFloat | float | int): The other FlexFloat instance to multiply.
+        Returns:
+            FlexFloat: A new FlexFloat instance representing the product.
+        """
+        if isinstance(other, Number):
+            other = FlexFloat.from_float(other)
+        if not isinstance(other, 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
+        #
+        # Steps:
+        # 0. Handle special cases (NaN, Infinity, zero).
+        # 1. Calculate result sign (XOR of operand signs).
+        # 2. Extract and add exponents (subtract bias).
+        # 3. Multiply mantissas.
+        # 4. Normalize mantissa and adjust exponent if necessary.
+        # 5. Check for overflow/underflow.
+        # 6. Grow exponent if necessary.
+        # 7. Return new FlexFloat instance.
+
+        # Step 0: Handle special cases
+        if self.is_nan() or other.is_nan():
+            return FlexFloat.nan()
+
+        if self.is_zero() or other.is_zero():
+            return FlexFloat.zero()
+
+        if self.is_infinity() or other.is_infinity():
+            result_sign = self.sign ^ other.sign
+            return FlexFloat.infinity(sign=result_sign)
+
+        # Step 1: Calculate result sign (XOR of signs)
+        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 addition)
+        exponent_self = self.exponent.to_signed_int() + 1
+        exponent_other = other.exponent.to_signed_int() + 1
+
+        # Step 3: Add exponents
+        # When multiplying, we add the unbiased exponents
+        result_exponent = exponent_self + exponent_other
+
+        # Step 4: Multiply mantissas
+        # Prepend leading 1 to form the mantissa (1.fraction)
+        mantissa_self = [True] + self.fraction
+        mantissa_other = [True] + other.fraction
+
+        # Convert mantissas to integers for multiplication
+        mantissa_self_int = mantissa_self.to_int()
+        mantissa_other_int = mantissa_other.to_int()
+
+        # Multiply the mantissas
+        product = mantissa_self_int * mantissa_other_int
+
+        # Convert back to bit array
+        # The product will have up to 106 bits (53 + 53)
+        if product == 0:
+            return FlexFloat.zero()
+
+        product_bits = BitArray.zeros(106)
+        for i in range(105, -1, -1):
+            product_bits[i] = product & 1 == 1
+            product >>= 1
+            if product <= 0:
+                break
+
+        # Step 5: Normalize mantissa and adjust exponent if necessary
+        # Find the position of the most significant bit
+        msb_position = next((i for i, bit in enumerate(product_bits) if bit), None)
+
+        assert msb_position is not None, "Product should not be zero here."
+
+        # The mantissa multiplication gives us a result with 2 integer bits
+        # We need to normalize to have exactly 1 integer bit
+        # If MSB is at position 0, we have a 2-bit integer part (11.xxxxx)
+        # If MSB is at position 1, we have a 1-bit integer part (1.xxxxx)
+        if msb_position == 0:
+            result_exponent += 1
+        normalized_mantissa = product_bits[msb_position : msb_position + 53]
+
+        # Pad with zeros if we don't have enough bits
+        missing_bits = 53 - len(normalized_mantissa)
+        if missing_bits > 0:
+            normalized_mantissa += [False] * missing_bits
+
+        # Step 6: Grow exponent if necessary to accommodate the result
+        exp_result_length = max(len(self.exponent), len(other.exponent))
+
+        # Check if we need to grow the exponent to accommodate the result
+        exp_result_length = self._grow_exponent(result_exponent, exp_result_length)
+
+        exp_result = BitArray.from_signed_int(result_exponent - 1, exp_result_length)
+
+        return FlexFloat(
+            sign=result_sign,
+            exponent=exp_result,
+            fraction=normalized_mantissa[1:],  # Exclude leading bit
+        )
+
+    def __rmul__(self, other: Number) -> FlexFloat:
+        """Right-hand multiplication for Number types.
+
+        Args:
+            other (float | int): The number to multiply with this FlexFloat.
+        Returns:
+            FlexFloat: A new FlexFloat instance representing the product.
+        """
+        return self * other
+
+    def __truediv__(self, other: FlexFloat | Number) -> FlexFloat:
+        """Divide this FlexFloat by another FlexFloat or number.
+
+        Args:
+            other (FlexFloat | float | int): The divisor.
+        Returns:
+            FlexFloat: A new FlexFloat instance representing the quotient.
+        """
+        if isinstance(other, Number):
+            other = FlexFloat.from_float(other)
+        if not isinstance(other, 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
+        #
+        # Steps:
+        # 0. Handle special cases (NaN, Infinity, zero).
+        # 1. Calculate result sign (XOR of operand signs).
+        # 2. Extract and subtract exponents (add bias).
+        # 3. Divide mantissas.
+        # 4. Normalize mantissa and adjust exponent if necessary.
+        # 5. Check for overflow/underflow.
+        # 6. Grow exponent if necessary.
+        # 7. Return new FlexFloat instance.
+
+        # Step 0: Handle special cases
+        if self.is_nan() or other.is_nan():
+            return FlexFloat.nan()
+
+        # Zero cases
+        if self.is_zero() and other.is_zero():
+            return FlexFloat.nan()  # 0 / 0 = NaN
+        if self.is_zero() and not other.is_zero():
+            return FlexFloat.zero()  # 0 / finite = 0
+        if not self.is_zero() and other.is_zero():
+            return FlexFloat.infinity(sign=self.sign ^ other.sign)  # finite / 0 = inf
+
+        # Infinity cases
+        if self.is_infinity() and other.is_infinity():
+            return FlexFloat.nan()  # inf / inf = NaN
+        if self.is_infinity():
+            return FlexFloat.infinity(sign=self.sign ^ other.sign)  # inf / finite = inf
+        if other.is_infinity():
+            return FlexFloat.zero()  # finite / inf = 0
+
+        # Step 1: Calculate result sign (XOR of signs)
+        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)
+        exponent_self = self.exponent.to_signed_int() + 1
+        exponent_other = other.exponent.to_signed_int() + 1
+
+        # Step 3: Subtract exponents (for division, we subtract the divisor's exponent)
+        result_exponent = exponent_self - exponent_other
+
+        # Step 4: Divide mantissas
+        # Prepend leading 1 to form the mantissa (1.fraction)
+        mantissa_self = [True] + self.fraction
+        mantissa_other = [True] + other.fraction
+
+        # Convert mantissas to integers for division
+        mantissa_self_int = mantissa_self.to_int()
+        mantissa_other_int = mantissa_other.to_int()
+
+        # Normalize mantissa for division (avoid overflow) -> scale the dividend
+        if mantissa_self_int < mantissa_other_int:
+            scale_factor = 1 << 53
+            result_exponent -= 1  # Adjust exponent since result < 1.0
+        else:
+            scale_factor = 1 << 52
+        scaled_dividend = mantissa_self_int * scale_factor
+        quotient = scaled_dividend // mantissa_other_int
+
+        if quotient == 0:
+            return FlexFloat.zero()
+
+        # Convert quotient to BitArray for easier bit manipulation
+        quotient_bitarray = BitArray.zeros(64)  # Use a fixed size for consistency
+        temp_quotient = quotient
+        bit_pos = 63
+        while temp_quotient > 0 and bit_pos >= 0:
+            quotient_bitarray[bit_pos] = (temp_quotient & 1) == 1
+            temp_quotient >>= 1
+            bit_pos -= 1
+
+        # Step 5: Normalize mantissa and adjust exponent if necessary
+        # Find the position of the most significant bit (first 1)
+        msb_pos = next((i for i, bit in enumerate(quotient_bitarray) if bit), None)
+
+        if msb_pos is None:
+            return FlexFloat.zero()
+
+        # Extract exactly 53 bits starting from the MSB (1 integer + 52 fraction)
+        normalized_mantissa = quotient_bitarray[msb_pos : msb_pos + 53]
+        normalized_mantissa = normalized_mantissa.shift(
+            53 - len(normalized_mantissa), fill=False
+        )
+
+        # Step 6: Grow exponent if necessary to accommodate the result
+        exp_result_length = max(len(self.exponent), len(other.exponent))
+
+        # Check if we need to grow the exponent to accommodate the result
+        exp_result_length = self._grow_exponent(result_exponent, exp_result_length)
+
+        exp_result = BitArray.from_signed_int(result_exponent - 1, exp_result_length)
+
+        return FlexFloat(
+            sign=result_sign,
+            exponent=exp_result,
+            fraction=normalized_mantissa[1:],  # Exclude leading bit
+        )
+
+    def __rtruediv__(self, other: Number) -> FlexFloat:
+        """Right-hand division for Number types.
+
+        Args:
+            other (float | int): The number to divide by this FlexFloat.
+        Returns:
+            FlexFloat: A new FlexFloat instance representing the quotient.
+        """
+        return FlexFloat.from_float(other) / self

flexfloat/types.py

@@ -0,0 +1,5 @@
+"""Type definitions for the flexfloat package."""
+
+from typing import TypeAlias
+
+Number: TypeAlias = int | float

flexfloat-0.1.0.dist-info/METADATA

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: flexfloat
+Version: 0.1.0
+Summary: A library for arbitrary precision floating point arithmetic
+Author: Ferran Sanchez Llado
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Requires-Dist: isort>=5.0; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+Requires-Dist: pylint>=3.0; extra == "dev"
+Requires-Dist: flake8>=6.0; extra == "dev"
+
+# FlexFloat
+
+A Python library for arbitrary precision floating point arithmetic with a flexible exponent and fixed-size fraction.
+
+## Features
+
+- **Growable Exponents**: Handle very large or very small numbers by dynamically adjusting the exponent size
+- **Fixed-Size Fractions**: Maintain precision consistency with IEEE 754-compatible 52-bit fractions  
+- **IEEE 754 Compatibility**: Follows IEEE 754 double-precision format as the baseline
+- **Special Value Support**: Handles NaN, positive/negative infinity, and zero values
+- **Arithmetic Operations**: Addition and subtraction with proper overflow/underflow handling
+
+## Installation
+
+```bash
+pip install flexfloat
+```
+
+## Development Installation
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Usage
+
+```python
+from flexfloat import FlexFloat
+
+# Create FlexFloat instances
+a = FlexFloat.from_float(1.5)
+b = FlexFloat.from_float(2.5)
+
+# Perform arithmetic operations
+result = a + b
+print(result.to_float())  # 4.0
+
+# Handle very large numbers
+large_a = FlexFloat.from_float(1e308)
+large_b = FlexFloat.from_float(1e308)
+large_result = large_a + large_b
+# Result has grown exponent to handle overflow
+print(len(large_result.exponent))  # > 11 (grows beyond IEEE 754 standard)
+```
+
+## Running Tests
+
+```bash
+python -m pytest tests
+```
+
+
+## License
+
+MIT License

flexfloat-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+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,,

flexfloat-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

flexfloat-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+flexfloat