flexfloat 0.1.2__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 Final
+from typing import ClassVar, Final, Type
 
-from .bitarray import BitArray
+from .bitarray import BitArray, ListBoolBitArray
 from .types import Number
 
 LOG10_2: Final[float] = math.log10(2)
@@ -28,55 +42,98 @@ class FlexFloat:
             (mantissa) of the number.
     """
 
+    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,
         sign: bool = False,
         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 BitArray.zeros(11)
-        self.fraction = fraction if fraction is not None else BitArray.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 = BitArray.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 = BitArray([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.
@@ -89,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:
@@ -102,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 = BitArray.ones(11)
-        fraction = BitArray.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 = BitArray.ones(11)
-        fraction = BitArray.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 = BitArray.zeros(11)
-        fraction = BitArray.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.
@@ -157,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.
@@ -165,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.
@@ -173,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.
@@ -183,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
@@ -206,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))
 
@@ -224,6 +280,7 @@ class FlexFloat:
         while normalized_mantissa >= 10.0:
             normalized_mantissa /= 10.0
             decimal_exponent += 1
+
         while normalized_mantissa < 1.0:
             normalized_mantissa *= 10.0
             decimal_exponent -= 1
@@ -232,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(),
@@ -241,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.
@@ -262,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)
@@ -309,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:
@@ -332,9 +398,10 @@ class FlexFloat:
             f"got {len(mantissa_other)} bits."
         )
 
-        mantissa_result = BitArray.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
@@ -352,20 +419,26 @@ class FlexFloat:
             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)
+        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)
@@ -412,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
@@ -450,9 +523,9 @@ class FlexFloat:
             f"got {len(smaller_mantissa)} bits."
         )
 
-        mantissa_result = BitArray.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
@@ -463,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
@@ -478,21 +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 = BitArray.from_signed_int(result_exponent - 1, exp_result_length)
+        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)
@@ -536,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()
@@ -552,8 +632,8 @@ class FlexFloat:
         if product == 0:
             return FlexFloat.zero()
 
-        product_bits = BitArray.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:
@@ -561,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))
@@ -584,31 +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 = BitArray.from_signed_int(result_exponent - 1, exp_result_length)
+        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)
@@ -661,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()
@@ -682,26 +775,32 @@ class FlexFloat:
             return FlexFloat.zero()
 
         # Convert quotient to BitArray for easier bit manipulation
-        quotient_bitarray = BitArray.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))
@@ -709,20 +808,309 @@ 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 = BitArray.from_signed_int(result_exponent - 1, exp_result_length)
+        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:
+        """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).
+        """
+        return FlexFloat(
+            sign=False,
+            exponent=self.exponent.copy(),
+            fraction=self.fraction.copy(),
+        )
+
+    def abs(self) -> FlexFloat:
+        """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).
+        """
+        return abs(self)
+
+    def exp(self) -> FlexFloat:
+        """Calculates the exponential of the FlexFloat instance.
+
+        Returns:
+            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:
+        """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)
+        if not isinstance(other, FlexFloat):
+            raise TypeError("Can only raise FlexFloat instances to a power.")
+
+        # OBJECTIVE: Compute self^other using the identity: a^b = exp(b * ln(a))
+        # For most cases, we use logarithmic computation for generality
+        # Handle special cases first for performance and correctness
+        #
+        # Steps:
+        # 0. Handle special cases (NaN, infinity, zero, one)
+        # 1. Handle negative base with fractional exponent (returns NaN)
+        # 2. For general case: compute ln(|base|) * exponent
+        # 3. Compute exp(result) to get the final power
+        # 4. Handle sign for negative base with integer exponent
+        # 5. Return new FlexFloat instance
+
+        # Step 0: Handle special cases
+        if self.is_nan() or other.is_nan():
+            return FlexFloat.nan()
+
+        # Zero base cases
+        if self.is_zero():
+            if other.is_zero():
+                return FlexFloat.from_float(1.0)  # 0^0 = 1 (by convention)
+            if other.sign:  # negative exponent
+                return FlexFloat.infinity(sign=False)  # 0^(-n) = +infinity
+            return FlexFloat.zero()  # 0^n = 0 for positive n
+
+        # One base: 1^anything = 1
+        if (
+            not self.sign
+            and self.exponent.to_signed_int() == -1
+            and not any(self.fraction)
+        ):
+            # Check if self is exactly 1.0 (exponent = -1, fraction = 0)
+            return FlexFloat.from_float(1.0)
+
+        # Zero exponent: anything^0 = 1 (except 0^0 handled above)
+        if other.is_zero():
+            return FlexFloat.from_float(1.0)
+
+        # One exponent: anything^1 = anything
+        if (
+            not other.sign
+            and other.exponent.to_signed_int() == -1
+            and not any(other.fraction)
+        ):
+            # Check if other is exactly 1.0 (exponent = -1, fraction = 0)
+            return self.copy()
+
+        # Infinity cases
+        if self.is_infinity():
+            if other.is_zero():
+                return FlexFloat.from_float(1.0)  # inf^0 = 1
+            if other.sign:  # negative exponent
+                return FlexFloat.zero()  # inf^(-n) = 0
+            # inf^n = inf, but need to handle sign for negative infinity
+            if not self.sign:  # positive infinity
+                return FlexFloat.infinity(sign=False)  # (+inf)^n = +inf
+
+            # Check if exponent is an integer for sign determination
+            try:
+                exp_float = other.to_float()
+                if exp_float == int(exp_float):  # integer exponent
+                    result_sign = int(exp_float) % 2 == 1  # odd = negative
+                else:
+                    return FlexFloat.nan()  # (-inf)^(non-integer) = NaN
+            except (ValueError, OverflowError):
+                # For very large exponents, assume positive result
+                result_sign = False
+            return FlexFloat.infinity(sign=result_sign)
+
+        if other.is_infinity():
+            try:
+                base_abs = abs(self.to_float())
+                if base_abs == 1.0:
+                    return FlexFloat.from_float(1.0)  # 1^inf = 1
+                if base_abs > 1.0:
+                    return (
+                        FlexFloat.infinity(sign=False)
+                        if not other.sign
+                        else FlexFloat.zero()
+                    )
+                # base_abs < 1.0
+                return (
+                    FlexFloat.zero()
+                    if not other.sign
+                    else FlexFloat.infinity(sign=False)
+                )
+            except (ValueError, OverflowError):
+                # For very large/small bases, use log-based approach
+                pass
+
+        # Step 1: Handle negative base with fractional exponent
+        if self.sign:
+            try:
+                # Check if exponent is an integer
+                exp_float = other.to_float()
+                if exp_float != int(exp_float):
+                    return FlexFloat.nan()  # (-base)^(non-integer) = NaN
+                is_odd_exponent = int(exp_float) % 2 == 1
+            except (ValueError, OverflowError):
+                # For very large exponents, we can't easily determine if integer
+                # Conservative approach: return NaN for negative base
+                return FlexFloat.nan()
+        else:
+            is_odd_exponent = False
+
+        # Step 2-3: General case using a^b = exp(b * ln(a))
+        # We need to compute ln(|self|) * other, then exp of that result
+
+        # For the logarithmic approach, we work with the absolute value
+        abs_base = self.abs()
+
+        # Use the mathematical identity: a^b = exp(b * ln(a))
+        # However, since we don't have ln implemented, we'll use Python's math
+        # for the core calculation and then convert back to FlexFloat
+        try:
+            # Convert to float for the mathematical computation
+            base_float = abs_base.to_float()
+            exp_float = other.to_float()
+
+            # For very small results that would underflow in float arithmetic,
+            # we need to use extended precision
+            log_result_estimate = exp_float * math.log(base_float)
+
+            # Check if the result would be too small for standard float
+            if log_result_estimate < -700:  # This would underflow to 0 in float
+                # Use extended precision approach
+                # Estimate the required exponent bits for the very small result
+                estimated_exp = int(log_result_estimate / LOG10_2)
+                required_exp_bits = max(11, abs(estimated_exp).bit_length() + 2)
+
+                # Create a small result with extended exponent
+                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=self._bitarray_implementation.ones(52),
+                )
+            else:
+                # Compute the power using Python's built-in pow
+                result_float = pow(base_float, exp_float)
+
+                # Handle potential overflow/underflow
+                if math.isinf(result_float):
+                    return FlexFloat.infinity(sign=False)
+                if result_float == 0.0:
+                    # Even if Python returns 0, we might want extended precision
+                    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 = self._bitarray_implementation.from_signed_int(
+                            estimated_exp, required_exp_bits
+                        )
+                        result = FlexFloat(
+                            sign=False,
+                            exponent=small_exp,
+                            fraction=self._bitarray_implementation.ones(52),
+                        )
+                    else:
+                        return FlexFloat.zero()
+                if math.isnan(result_float):
+                    return FlexFloat.nan()
+
+                # Convert result back to FlexFloat
+                result = FlexFloat.from_float(result_float)
+
+        except (ValueError, OverflowError):
+            # If float computation overflows, use extended precision approach
+            # This is a fallback for when the result is too large for float
+
+            # For very large results, we estimate the exponent growth needed
+            try:
+                # Estimate log(result) = exponent * log(base)
+                log_base = (
+                    math.log(abs(self.to_float()))
+                    if not self.is_zero()
+                    else -float("inf")
+                )
+                exp_float = other.to_float()
+                estimated_log_result = exp_float * log_base
+
+                # Estimate the required exponent bits
+                estimated_exp_float = estimated_log_result / LOG10_2
+                required_exp_bits = max(
+                    11, int(abs(estimated_exp_float)).bit_length() + 2
+                )
+
+                # Create a result with extended exponent
+                # This is a simplified approach - a full implementation would
+                # use arbitrary precision arithmetic
+                if estimated_exp_float > 0:
+                    # Very large positive result
+                    large_exp = self._bitarray_implementation.from_signed_int(
+                        int(estimated_exp_float), required_exp_bits
+                    )
+                    result = FlexFloat(
+                        sign=False,
+                        exponent=large_exp,
+                        fraction=self._bitarray_implementation.ones(52),
+                    )
+                else:
+                    # Very small positive result
+                    small_exp = self._bitarray_implementation.from_signed_int(
+                        int(estimated_exp_float), required_exp_bits
+                    )
+                    result = FlexFloat(
+                        sign=False,
+                        exponent=small_exp,
+                        fraction=self._bitarray_implementation.ones(52),
+                    )
+
+            except (ValueError, OverflowError, ZeroDivisionError):
+                # Ultimate fallback
+                return FlexFloat.nan()
+
+        # Step 4: Handle sign for negative base with integer exponent
+        if self.sign and is_odd_exponent:
+            result.sign = True
+
+        return result
+
+    def __rpow__(self, base: Number) -> FlexFloat:
+        """Right-hand power operation for Number types.
+
+        Args:
+            base (Number): The base to raise to the power of this FlexFloat.
+
+        Returns:
+            FlexFloat: A new FlexFloat instance representing the power.
+        """
+        return FlexFloat.from_float(base) ** self
+
+
+# Initialize class variable after class definition
+FlexFloat.e = FlexFloat.from_float(math.e)