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

flexfloat/core.py

@@ -3,9 +3,9 @@
 from __future__ import annotations
 
 import math
-from typing import Final
+from typing import ClassVar, Final
 
-from .bitarray import BitArray
+from .bitarray import BitArray, BitArrayType
 from .types import Number
 
 LOG10_2: Final[float] = math.log10(2)
@@ -28,6 +28,8 @@ class FlexFloat:
             (mantissa) of the number.
     """
 
+    e: ClassVar[FlexFloat]
+
     def __init__(
         self,
         sign: bool = False,
@@ -42,8 +44,8 @@ class FlexFloat:
             fraction (BitArray | None): The fraction bit array (If None, represents 0).
         """
         self.sign = sign
-        self.exponent = exponent if exponent is not None else BitArray.zeros(11)
-        self.fraction = fraction if fraction is not None else BitArray.zeros(52)
+        self.exponent = exponent if exponent is not None else BitArrayType.zeros(11)
+        self.fraction = fraction if fraction is not None else BitArrayType.zeros(52)
 
     @classmethod
     def from_float(cls, value: Number) -> FlexFloat:
@@ -55,7 +57,7 @@ class FlexFloat:
             FlexFloat: A new FlexFloat instance representing the number.
         """
         value = float(value)
-        bits = BitArray.from_float(value)
+        bits = BitArrayType.from_float(value)
 
         return cls(sign=bits[0], exponent=bits[1:12], fraction=bits[12:64])
 
@@ -72,7 +74,7 @@ class FlexFloat:
         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 = BitArrayType([self.sign]) + self.exponent[:11] + self.fraction[:52]
         return bits.to_float()
 
     def __repr__(self) -> str:
@@ -107,8 +109,8 @@ class FlexFloat:
         Returns:
             FlexFloat: A new FlexFloat instance representing NaN.
         """
-        exponent = BitArray.ones(11)
-        fraction = BitArray.ones(52)
+        exponent = BitArrayType.ones(11)
+        fraction = BitArrayType.ones(52)
         return cls(sign=True, exponent=exponent, fraction=fraction)
 
     @classmethod
@@ -120,8 +122,8 @@ class FlexFloat:
         Returns:
             FlexFloat: A new FlexFloat instance representing Infinity.
         """
-        exponent = BitArray.ones(11)
-        fraction = BitArray.zeros(52)
+        exponent = BitArrayType.ones(11)
+        fraction = BitArrayType.zeros(52)
         return cls(sign=sign, exponent=exponent, fraction=fraction)
 
     @classmethod
@@ -131,8 +133,8 @@ class FlexFloat:
         Returns:
             FlexFloat: A new FlexFloat instance representing zero.
         """
-        exponent = BitArray.zeros(11)
-        fraction = BitArray.zeros(52)
+        exponent = BitArrayType.zeros(11)
+        fraction = BitArrayType.zeros(52)
         return cls(sign=False, exponent=exponent, fraction=fraction)
 
     def _is_special_exponent(self) -> bool:
@@ -224,6 +226,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
@@ -332,7 +335,7 @@ class FlexFloat:
             f"got {len(mantissa_other)} bits."
         )
 
-        mantissa_result = BitArray.zeros(53)  # 1 leading bit + 52 fraction bits
+        mantissa_result = BitArrayType.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
@@ -352,7 +355,9 @@ 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 = BitArrayType.from_signed_int(
+            exponent_self - 1, exp_result_length
+        )
         return FlexFloat(
             sign=self.sign,
             exponent=exponent_result,
@@ -450,7 +455,7 @@ class FlexFloat:
             f"got {len(smaller_mantissa)} bits."
         )
 
-        mantissa_result = BitArray.zeros(53)
+        mantissa_result = BitArrayType.zeros(53)
         borrow = False
         for i in range(52, -1, -1):
             diff = int(larger_mantissa[i]) - int(smaller_mantissa[i]) - int(borrow)
@@ -478,7 +483,9 @@ 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 = BitArrayType.from_signed_int(
+            result_exponent - 1, exp_result_length
+        )
 
         return FlexFloat(
             sign=result_sign,
@@ -552,7 +559,7 @@ class FlexFloat:
         if product == 0:
             return FlexFloat.zero()
 
-        product_bits = BitArray.zeros(106)
+        product_bits = BitArrayType.zeros(106)
         for i in range(105, -1, -1):
             product_bits[i] = product & 1 == 1
             product >>= 1
@@ -584,7 +591,9 @@ 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 = BitArrayType.from_signed_int(
+            result_exponent - 1, exp_result_length
+        )
 
         return FlexFloat(
             sign=result_sign,
@@ -682,7 +691,7 @@ class FlexFloat:
             return FlexFloat.zero()
 
         # Convert quotient to BitArray for easier bit manipulation
-        quotient_bitarray = BitArray.zeros(64)  # Use a fixed size for consistency
+        quotient_bitarray = BitArrayType.zeros(64)  # Use a fixed size for consistency
         temp_quotient = quotient
         bit_pos = 63
         while temp_quotient > 0 and bit_pos >= 0:
@@ -709,7 +718,9 @@ 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 = BitArrayType.from_signed_int(
+            result_exponent - 1, exp_result_length
+        )
 
         return FlexFloat(
             sign=result_sign,
@@ -726,3 +737,278 @@ class FlexFloat:
             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:
+            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:
+        """Calculate 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:
+        """Calculate 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:
+        """Power operation for FlexFloat instances.
+
+        Args:
+            other (FlexFloat | Number): The exponent.
+        Returns:
+            FlexFloat: A new FlexFloat instance representing the power.
+        """
+        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 = BitArrayType.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)
+                )
+            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 = BitArrayType.from_signed_int(
+                            estimated_exp, required_exp_bits
+                        )
+                        result = FlexFloat(
+                            sign=False,
+                            exponent=small_exp,
+                            fraction=BitArrayType.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 = BitArrayType.from_signed_int(
+                        int(estimated_exp_float), required_exp_bits
+                    )
+                    result = FlexFloat(
+                        sign=False, exponent=large_exp, fraction=BitArrayType.ones(52)
+                    )
+                else:
+                    # Very small positive result
+                    small_exp = BitArrayType.from_signed_int(
+                        int(estimated_exp_float), required_exp_bits
+                    )
+                    result = FlexFloat(
+                        sign=False, exponent=small_exp, fraction=BitArrayType.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 (float | int): 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)