flexfloat 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

flexfloat/core.py

@@ -1,11 +1,25 @@
-"""Core FlexFloat class implementation."""
+"""Core FlexFloat class implementation.
+
+This module defines the FlexFloat class, which represents a floating-point number with a
+growable exponent and a fixed-size fraction. The class is designed for arbitrary
+precision floating-point arithmetic, supporting very large or small values by
+dynamically adjusting the exponent size.
+
+Example:
+    from flexfloat import FlexFloat
+    a = FlexFloat(3.14, exponent_length=10, fraction_length=20)
+    b = FlexFloat(2.71, exponent_length=10, fraction_length=20)
+    c = a + b
+    print(c)
+    # Output: FlexFloat(...)
+"""
 
 from __future__ import annotations
 
 import math
-from typing import ClassVar, Final
+from typing import ClassVar, Final, Type
 
-from .bitarray import BitArray, BitArrayType
+from .bitarray import BitArray, ListBoolBitArray
 from .types import Number
 
 LOG10_2: Final[float] = math.log10(2)
@@ -29,6 +43,26 @@ class FlexFloat:
     """
 
     e: ClassVar[FlexFloat]
+    """The mathematical constant e as a FlexFloat instance."""
+    _bitarray_implementation: ClassVar[Type[BitArray]] = ListBoolBitArray
+    """The BitArray implementation class used for all FlexFloat instances."""
+
+    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."""
+
+    @classmethod
+    def set_bitarray_implementation(cls, implementation: Type[BitArray]) -> None:
+        """Set the BitArray implementation to use for all FlexFloat instances.
+
+        Args:
+            implementation (Type[BitArray]): The BitArray implementation class to use.
+        """
+        cls._bitarray_implementation = implementation
 
     def __init__(
         self,
@@ -36,49 +70,70 @@ class FlexFloat:
         exponent: BitArray | None = None,
         fraction: BitArray | None = None,
     ):
-        """Initialize a FlexFloat instance.
+        """Initializes a FlexFloat instance.
+
+        BitArrays are expected to be LSB-first (least significant bit at index 0,
+        increasing to MSB).
 
         Args:
-            sign (bool): The sign of the number (True for negative, False for positive).
-            exponent (BitArray | None): The exponent bit array (If None, represents 0).
-            fraction (BitArray | None): The fraction bit array (If None, represents 0).
+            sign (bool, optional): The sign of the number (True for negative, False for
+                positive). Defaults to False.
+            exponent (BitArray | None, optional): The exponent bit array. If None,
+                represents 0. Defaults to None.
+            fraction (BitArray | None, optional): The fraction bit array. If None,
+                represents 0. Defaults to None.
         """
         self.sign = sign
-        self.exponent = exponent if exponent is not None else BitArrayType.zeros(11)
-        self.fraction = fraction if fraction is not None else BitArrayType.zeros(52)
+        self.exponent = (
+            exponent
+            if exponent is not None
+            else self._bitarray_implementation.zeros(11)
+        )
+        self.fraction = (
+            fraction
+            if fraction is not None
+            else self._bitarray_implementation.zeros(52)
+        )
 
     @classmethod
     def from_float(cls, value: Number) -> FlexFloat:
-        """Create a FlexFloat instance from a number.
+        """Creates 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 = BitArrayType.from_float(value)
+        bits = cls._bitarray_implementation.from_float(value)
 
-        return cls(sign=bits[0], exponent=bits[1:12], fraction=bits[12:64])
+        return cls(sign=bits[63], exponent=bits[52:63], fraction=bits[:52])
 
     def to_float(self) -> float:
-        """Convert the FlexFloat instance back to a 64-bit float.
+        """Converts the FlexFloat instance back to 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.
+
         Raises:
-            ValueError: If the exponent or fraction lengths are not as expected.
+            ValueError: If the FlexFloat does not have standard 64-bit exponent and
+                fraction.
         """
         if len(self.exponent) < 11 or len(self.fraction) < 52:
             raise ValueError("Must be a standard 64-bit FlexFloat")
 
-        bits = BitArrayType([self.sign]) + self.exponent[:11] + self.fraction[:52]
+        bits = (
+            self.fraction[:52]
+            + self.exponent[:11]
+            + self._bitarray_implementation.from_bits([self.sign])
+        )
         return bits.to_float()
 
     def __repr__(self) -> str:
-        """Return a string representation of the FlexFloat instance.
+        """Returns a string representation of the FlexFloat instance.
 
         Returns:
             str: A string representation of the FlexFloat instance.
@@ -91,7 +146,7 @@ class FlexFloat:
         )
 
     def pretty(self) -> str:
-        """Return an easier to read string representation of the FlexFloat instance.
+        """Returns an easier to read string representation of the FlexFloat instance.
         Mainly converts the exponent and fraction to integers for readability.
 
         Returns:
@@ -104,54 +159,52 @@ class FlexFloat:
 
     @classmethod
     def nan(cls) -> FlexFloat:
-        """Create a FlexFloat instance representing NaN (Not a Number).
+        """Creates a FlexFloat instance representing NaN (Not a Number).
 
         Returns:
             FlexFloat: A new FlexFloat instance representing NaN.
         """
-        exponent = BitArrayType.ones(11)
-        fraction = BitArrayType.ones(52)
+        exponent = cls._bitarray_implementation.ones(11)
+        fraction = cls._bitarray_implementation.ones(52)
         return cls(sign=True, exponent=exponent, fraction=fraction)
 
     @classmethod
     def infinity(cls, sign: bool = False) -> FlexFloat:
-        """Create a FlexFloat instance representing Infinity.
+        """Creates a FlexFloat instance representing Infinity.
 
         Args:
-            sign (bool): Indicates if the infinity is negative.
+            sign (bool, optional): Indicates if the infinity is negative. Defaults to
+                False.
+
         Returns:
             FlexFloat: A new FlexFloat instance representing Infinity.
         """
-        exponent = BitArrayType.ones(11)
-        fraction = BitArrayType.zeros(52)
+        exponent = cls._bitarray_implementation.ones(11)
+        fraction = cls._bitarray_implementation.zeros(52)
         return cls(sign=sign, exponent=exponent, fraction=fraction)
 
     @classmethod
     def zero(cls) -> FlexFloat:
-        """Create a FlexFloat instance representing zero.
+        """Creates a FlexFloat instance representing zero.
 
         Returns:
             FlexFloat: A new FlexFloat instance representing zero.
         """
-        exponent = BitArrayType.zeros(11)
-        fraction = BitArrayType.zeros(52)
+        exponent = cls._bitarray_implementation.zeros(11)
+        fraction = cls._bitarray_implementation.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).
+        """Checks 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).
+        """Checks if the FlexFloat instance represents NaN (Not a Number).
 
         Returns:
             bool: True if the FlexFloat instance is NaN, False otherwise.
@@ -159,7 +212,7 @@ class FlexFloat:
         return self._is_special_exponent() and any(self.fraction)
 
     def is_infinity(self) -> bool:
-        """Check if the FlexFloat instance represents Infinity.
+        """Checks if the FlexFloat instance represents Infinity.
 
         Returns:
             bool: True if the FlexFloat instance is Infinity, False otherwise.
@@ -167,7 +220,7 @@ class FlexFloat:
         return self._is_special_exponent() and not any(self.fraction)
 
     def is_zero(self) -> bool:
-        """Check if the FlexFloat instance represents zero.
+        """Checks if the FlexFloat instance represents zero.
 
         Returns:
             bool: True if the FlexFloat instance is zero, False otherwise.
@@ -175,7 +228,7 @@ class FlexFloat:
         return not any(self.exponent) and not any(self.fraction)
 
     def copy(self) -> FlexFloat:
-        """Create a copy of the FlexFloat instance.
+        """Creates a copy of the FlexFloat instance.
 
         Returns:
             FlexFloat: A new FlexFloat instance with the same data as the original.
@@ -185,12 +238,13 @@ class FlexFloat:
         )
 
     def __str__(self) -> str:
-        """Float representation of the FlexFloat using a generic algorithm.
+        """Returns a 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 one format: scientific notation with 5 decimal
+        places.
 
-        Currently, it only operates in scientific notation with 5 decimal places.
+        Returns:
+            str: The string representation in scientific notation.
         """
         sign_str = "-" if self.sign else ""
         # Handle special cases first
@@ -208,7 +262,7 @@ class FlexFloat:
         # 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):
+        for i, bit in enumerate(reversed(self.fraction)):
             if bit:
                 mantissa += 1.0 / (1 << (i + 1))
 
@@ -235,7 +289,11 @@ class FlexFloat:
         return f"{sign_str}{normalized_mantissa:.5f}e{decimal_exponent:+03d}"
 
     def __neg__(self) -> FlexFloat:
-        """Negate the FlexFloat instance."""
+        """Negates the FlexFloat instance.
+
+        Returns:
+            FlexFloat: A new FlexFloat instance with the sign flipped.
+        """
         return FlexFloat(
             sign=not self.sign,
             exponent=self.exponent.copy(),
@@ -244,11 +302,12 @@ class FlexFloat:
 
     @staticmethod
     def _grow_exponent(exponent: int, exponent_length: int) -> int:
-        """Grow the exponent if it exceeds the maximum value for the current length.
+        """Grows 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.
@@ -265,12 +324,16 @@ class FlexFloat:
         return exponent_length
 
     def __add__(self, other: FlexFloat | Number) -> FlexFloat:
-        """Add two FlexFloat instances together.
+        """Adds two FlexFloat instances together.
 
         Args:
-            other (FlexFloat | float | int): The other FlexFloat instance to add.
+            other (FlexFloat | Number): The other FlexFloat instance to add.
+
         Returns:
             FlexFloat: A new FlexFloat instance representing the sum.
+
+        Raises:
+            TypeError: If other is not a FlexFloat or numeric type.
         """
         if isinstance(other, Number):
             other = FlexFloat.from_float(other)
@@ -312,9 +375,9 @@ class FlexFloat:
         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 2: Append the implicit leading 1 to form the mantissa
+        mantissa_self = self.fraction + [True]
+        mantissa_other = other.fraction + [True]
 
         # Step 3: Compare exponents (self is always larger or equal)
         if exponent_self < exponent_other:
@@ -335,9 +398,10 @@ class FlexFloat:
             f"got {len(mantissa_other)} bits."
         )
 
-        mantissa_result = BitArrayType.zeros(53)  # 1 leading bit + 52 fraction bits
+        # 1 leading bit + 52 fraction bits
+        mantissa_result = self._bitarray_implementation.zeros(53)
         carry = False
-        for i in range(52, -1, -1):
+        for i in range(53):
             total = mantissa_self[i] + mantissa_other[i] + carry
             mantissa_result[i] = total % 2 == 1
             carry = total > 1
@@ -355,22 +419,26 @@ class FlexFloat:
             exponent_self - (1 << (exp_result_length - 1)) < 2
         ), "Exponent growth should not exceed 1 bit."
 
-        exponent_result = BitArrayType.from_signed_int(
+        exponent_result = self._bitarray_implementation.from_signed_int(
             exponent_self - 1, exp_result_length
         )
         return FlexFloat(
             sign=self.sign,
             exponent=exponent_result,
-            fraction=mantissa_result[1:],  # Exclude leading bit
+            fraction=mantissa_result[:-1],  # Exclude leading bit
         )
 
     def __sub__(self, other: FlexFloat | Number) -> FlexFloat:
-        """Subtract one FlexFloat instance from another.
+        """Subtracts one FlexFloat instance from another.
 
         Args:
-            other (FlexFloat | float | int): The FlexFloat instance to subtract.
+            other (FlexFloat | Number): The FlexFloat instance to subtract.
+
         Returns:
             FlexFloat: A new FlexFloat instance representing the difference.
+
+        Raises:
+            TypeError: If other is not a FlexFloat or numeric type.
         """
         if isinstance(other, Number):
             other = FlexFloat.from_float(other)
@@ -417,9 +485,9 @@ class FlexFloat:
         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 2: Append the implicit leading 1 to form the mantissa
+        mantissa_self = self.fraction + [True]
+        mantissa_other = other.fraction + [True]
 
         # Step 3: Align mantissas by shifting the smaller exponent
         result_sign = self.sign
@@ -455,9 +523,9 @@ class FlexFloat:
             f"got {len(smaller_mantissa)} bits."
         )
 
-        mantissa_result = BitArrayType.zeros(53)
+        mantissa_result = self._bitarray_implementation.zeros(53)
         borrow = False
-        for i in range(52, -1, -1):
+        for i in range(53):
             diff = int(larger_mantissa[i]) - int(smaller_mantissa[i]) - int(borrow)
 
             mantissa_result[i] = diff % 2 == 1
@@ -468,7 +536,8 @@ class FlexFloat:
         # 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)
+            (i for i, bit in enumerate(reversed(mantissa_result)) if bit),
+            len(mantissa_result),
         )
 
         # Handle case where result becomes zero or denormalized
@@ -483,23 +552,27 @@ class FlexFloat:
         # Step 7: Grow exponent if necessary (handle underflow)
         exp_result_length = self._grow_exponent(result_exponent, len(self.exponent))
 
-        exp_result = BitArrayType.from_signed_int(
+        exp_result = self._bitarray_implementation.from_signed_int(
             result_exponent - 1, exp_result_length
         )
 
         return FlexFloat(
             sign=result_sign,
             exponent=exp_result,
-            fraction=mantissa_result[1:],  # Exclude leading bit
+            fraction=mantissa_result[:-1],  # Exclude leading bit
         )
 
     def __mul__(self, other: FlexFloat | Number) -> FlexFloat:
-        """Multiply two FlexFloat instances together.
+        """Multiplies two FlexFloat instances together.
 
         Args:
-            other (FlexFloat | float | int): The other FlexFloat instance to multiply.
+            other (FlexFloat | Number): The other FlexFloat instance to multiply.
+
         Returns:
             FlexFloat: A new FlexFloat instance representing the product.
+
+        Raises:
+            TypeError: If other is not a FlexFloat or numeric type.
         """
         if isinstance(other, Number):
             other = FlexFloat.from_float(other)
@@ -543,9 +616,9 @@ class FlexFloat:
         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
+        # Append the implicit leading 1 to form the mantissa
+        mantissa_self = self.fraction + [True]
+        mantissa_other = other.fraction + [True]
 
         # Convert mantissas to integers for multiplication
         mantissa_self_int = mantissa_self.to_int()
@@ -559,8 +632,8 @@ class FlexFloat:
         if product == 0:
             return FlexFloat.zero()
 
-        product_bits = BitArrayType.zeros(106)
-        for i in range(105, -1, -1):
+        product_bits = self._bitarray_implementation.zeros(106)
+        for i in range(106):
             product_bits[i] = product & 1 == 1
             product >>= 1
             if product <= 0:
@@ -568,22 +641,28 @@ class FlexFloat:
 
         # 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)
+        msb_position = next(
+            (i for i, bit in enumerate(reversed(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
+        # The mantissa multiplication gives us a result with a 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)
+        # Mantissa goes from LSB to MSB, so we need to adjust the exponent accordingly
         if msb_position == 0:
             result_exponent += 1
-        normalized_mantissa = product_bits[msb_position : msb_position + 53]
+
+        # Extract the normalized mantissa
+        lsb_position = 53 - msb_position
+        normalized_mantissa = product_bits[lsb_position : lsb_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
+            normalized_mantissa = normalized_mantissa.shift(-missing_bits, fill=False)
 
         # Step 6: Grow exponent if necessary to accommodate the result
         exp_result_length = max(len(self.exponent), len(other.exponent))
@@ -591,33 +670,38 @@ class FlexFloat:
         # 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 = BitArrayType.from_signed_int(
+        exp_result = self._bitarray_implementation.from_signed_int(
             result_exponent - 1, exp_result_length
         )
 
         return FlexFloat(
             sign=result_sign,
             exponent=exp_result,
-            fraction=normalized_mantissa[1:],  # Exclude leading bit
+            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.
+            other (Number): The number to multiply with this FlexFloat.
+
         Returns:
             FlexFloat: A new FlexFloat instance representing the product.
         """
-        return self * other
+        return self * FlexFloat.from_float(other)
 
     def __truediv__(self, other: FlexFloat | Number) -> FlexFloat:
-        """Divide this FlexFloat by another FlexFloat or number.
+        """Divides this FlexFloat by another FlexFloat or number.
 
         Args:
-            other (FlexFloat | float | int): The divisor.
+            other (FlexFloat | Number): The divisor.
+
         Returns:
             FlexFloat: A new FlexFloat instance representing the quotient.
+
+        Raises:
+            TypeError: If other is not a FlexFloat or numeric type.
         """
         if isinstance(other, Number):
             other = FlexFloat.from_float(other)
@@ -670,9 +754,9 @@ class FlexFloat:
         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
+        # Append the implicit leading 1 to form the mantissa
+        mantissa_self = self.fraction + [True]
+        mantissa_other = other.fraction + [True]
 
         # Convert mantissas to integers for division
         mantissa_self_int = mantissa_self.to_int()
@@ -691,26 +775,32 @@ class FlexFloat:
             return FlexFloat.zero()
 
         # Convert quotient to BitArray for easier bit manipulation
-        quotient_bitarray = BitArrayType.zeros(64)  # Use a fixed size for consistency
+        # Use a fixed size for consistency
+        quotient_bitarray = self._bitarray_implementation.zeros(64)
         temp_quotient = quotient
-        bit_pos = 63
-        while temp_quotient > 0 and bit_pos >= 0:
+        bit_pos = 0
+        while temp_quotient > 0 and bit_pos < 64:
             quotient_bitarray[bit_pos] = (temp_quotient & 1) == 1
             temp_quotient >>= 1
-            bit_pos -= 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)
+        msb_pos = next(
+            (i for i, bit in enumerate(reversed(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
-        )
+        lsb_pos = 11 - msb_pos
+        normalized_mantissa = quotient_bitarray[lsb_pos : lsb_pos + 53]
+
+        # If we don't have enough bits, pad with zeros
+        missing_bits = 53 - len(normalized_mantissa)
+        if missing_bits > 0:
+            normalized_mantissa = normalized_mantissa.shift(-missing_bits, fill=False)
 
         # Step 6: Grow exponent if necessary to accommodate the result
         exp_result_length = max(len(self.exponent), len(other.exponent))
@@ -718,32 +808,33 @@ class FlexFloat:
         # 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 = BitArrayType.from_signed_int(
+        exp_result = self._bitarray_implementation.from_signed_int(
             result_exponent - 1, exp_result_length
         )
 
         return FlexFloat(
             sign=result_sign,
             exponent=exp_result,
-            fraction=normalized_mantissa[1:],  # Exclude leading bit
+            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.
+            other (Number): The number to divide by this FlexFloat.
+
         Returns:
             FlexFloat: A new FlexFloat instance representing the quotient.
         """
         return FlexFloat.from_float(other) / self
 
     def __abs__(self) -> FlexFloat:
-        """Return the absolute value of the FlexFloat instance.
+        """Returns the absolute value of the FlexFloat instance.
 
         Returns:
-            FlexFloat: A new FlexFloat instance with the same exponent and fraction,
-                but with the sign set to False (positive).
+            FlexFloat: A new FlexFloat instance with the same exponent and fraction, but
+                with the sign set to False (positive).
         """
         return FlexFloat(
             sign=False,
@@ -752,31 +843,35 @@ class FlexFloat:
         )
 
     def abs(self) -> FlexFloat:
-        """Calculate the absolute value of the FlexFloat instance.
+        """Calculates the absolute value of the FlexFloat instance.
 
         Returns:
-            FlexFloat: A new FlexFloat instance with the same exponent and fraction,
-                but with the sign set to False (positive).
+            FlexFloat: A new FlexFloat instance with the same exponent and fraction, but
+                with the sign set to False (positive).
         """
         return abs(self)
 
     def exp(self) -> FlexFloat:
-        """Calculate the exponential of the FlexFloat instance.
+        """Calculates the exponential of the FlexFloat instance.
 
         Returns:
-            FlexFloat: A new FlexFloat instance representing e raised to the power
-                of this instance.
+            FlexFloat: A new FlexFloat instance representing e raised to the power of
+                this instance.
         """
         # Use Python's math.exp for the base calculation
         return FlexFloat.e**self
 
     def __pow__(self, other: FlexFloat | Number) -> FlexFloat:
-        """Power operation for FlexFloat instances.
+        """Raises this FlexFloat to the power of another FlexFloat or number.
 
         Args:
             other (FlexFloat | Number): The exponent.
+
         Returns:
             FlexFloat: A new FlexFloat instance representing the power.
+
+        Raises:
+            TypeError: If other is not a FlexFloat or numeric type.
         """
         if isinstance(other, Number):
             other = FlexFloat.from_float(other)
@@ -913,12 +1008,14 @@ class FlexFloat:
                 required_exp_bits = max(11, abs(estimated_exp).bit_length() + 2)
 
                 # Create a small result with extended exponent
-                small_exp = BitArrayType.from_signed_int(
+                small_exp = self._bitarray_implementation.from_signed_int(
                     estimated_exp, required_exp_bits
                 )
                 # Use a normalized mantissa (leading 1 + some fraction bits)
                 result = FlexFloat(
-                    sign=False, exponent=small_exp, fraction=BitArrayType.ones(52)
+                    sign=False,
+                    exponent=small_exp,
+                    fraction=self._bitarray_implementation.ones(52),
                 )
             else:
                 # Compute the power using Python's built-in pow
@@ -932,13 +1029,13 @@ class FlexFloat:
                     if log_result_estimate < -300:  # Very small but not quite underflow
                         estimated_exp = int(log_result_estimate / LOG10_2)
                         required_exp_bits = max(11, abs(estimated_exp).bit_length() + 2)
-                        small_exp = BitArrayType.from_signed_int(
+                        small_exp = self._bitarray_implementation.from_signed_int(
                             estimated_exp, required_exp_bits
                         )
                         result = FlexFloat(
                             sign=False,
                             exponent=small_exp,
-                            fraction=BitArrayType.ones(52),
+                            fraction=self._bitarray_implementation.ones(52),
                         )
                     else:
                         return FlexFloat.zero()
@@ -974,19 +1071,23 @@ class FlexFloat:
                 # use arbitrary precision arithmetic
                 if estimated_exp_float > 0:
                     # Very large positive result
-                    large_exp = BitArrayType.from_signed_int(
+                    large_exp = self._bitarray_implementation.from_signed_int(
                         int(estimated_exp_float), required_exp_bits
                     )
                     result = FlexFloat(
-                        sign=False, exponent=large_exp, fraction=BitArrayType.ones(52)
+                        sign=False,
+                        exponent=large_exp,
+                        fraction=self._bitarray_implementation.ones(52),
                     )
                 else:
                     # Very small positive result
-                    small_exp = BitArrayType.from_signed_int(
+                    small_exp = self._bitarray_implementation.from_signed_int(
                         int(estimated_exp_float), required_exp_bits
                     )
                     result = FlexFloat(
-                        sign=False, exponent=small_exp, fraction=BitArrayType.ones(52)
+                        sign=False,
+                        exponent=small_exp,
+                        fraction=self._bitarray_implementation.ones(52),
                     )
 
             except (ValueError, OverflowError, ZeroDivisionError):
@@ -1003,7 +1104,8 @@ class FlexFloat:
         """Right-hand power operation for Number types.
 
         Args:
-            base (float | int): The base to raise to the power of this FlexFloat.
+            base (Number): The base to raise to the power of this FlexFloat.
+
         Returns:
             FlexFloat: A new FlexFloat instance representing the power.
         """