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

flexfloat/types.py

@@ -1,4 +1,10 @@
-"""Type definitions for the flexfloat package."""
+"""Type definitions for the flexfloat package.
+
+This module provides type aliases used throughout the flexfloat package.
+
+Type Aliases:
+    Number: Alias for int | float, used for numeric arguments.
+"""
 
 from typing import TypeAlias
 

{flexfloat-0.1.3.dist-info → flexfloat-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flexfloat
-Version: 0.1.3
+Version: 0.3.0
 Summary: A library for arbitrary precision floating point arithmetic
 Author: Ferran Sanchez Llado
 License: MIT
@@ -45,7 +45,7 @@ A high-precision Python library for arbitrary precision floating-point arithmeti
 - **🔢 Growable Exponents**: Dynamically expand exponent size to handle extremely large (>10^308) or small (<10^-308) numbers
 - **🎯 Fixed-Size Fractions**: Maintain IEEE 754-compatible 52-bit fraction precision for consistent accuracy
 - **⚡ Full Arithmetic Support**: Addition, subtraction, multiplication, division, and power operations
-- **🔧 Multiple BitArray Backends**: Choose between list-based and int64-based implementations for optimal performance
+- **🔧 Multiple BitArray Backends**: Choose between bool-list, int64-list, and big-integer implementations for optimal performance
 - **🌟 Special Value Handling**: Complete support for NaN, ±infinity, and zero values
 - **🛡️ Overflow Protection**: Automatic exponent growth prevents overflow/underflow errors
 - **📊 IEEE 754 Baseline**: Fully compatible with standard double-precision format as the starting point
@@ -81,12 +81,15 @@ print(f"Exponent bits: {len(large_result.exponent)}")  # > 11 (grown beyond IEEE
 print(f"Can represent: {large_result}")  # No overflow!
 ```
 
-### Advanced Examples
+### Advanced Features
 
 ```python
-from flexfloat import FlexFloat
+from flexfloat import FlexFloat, BigIntBitArray
+
+# Use different BitArray implementations for specific needs
+FlexFloat.set_bitarray_implementation(BigIntBitArray)
 
-# Mathematical operations
+# Mathematical operations with unlimited precision
 x = FlexFloat.from_float(2.0)
 y = FlexFloat.from_float(3.0)
 
@@ -98,10 +101,13 @@ print(power_result.to_float())  # 8.0
 e_result = FlexFloat.e ** x  # e^2
 print(f"e^2 ≈ {e_result.to_float()}")
 
+# Absolute value operations
+abs_result = abs(FlexFloat.from_float(-42.0))
+print(f"|-42| = {abs_result.to_float()}")  # 42.0
+
 # Working with extreme values
-tiny = FlexFloat.from_float(1e-300)
 huge = FlexFloat.from_float(1e300)
-extreme_product = tiny * huge
+extreme_product = huge * huge
 print(f"Product: {extreme_product.to_float()}")  # Still computable!
 
 # Precision demonstration
@@ -111,35 +117,40 @@ print(f"1/3 with 52-bit precision: {precise_calc}")
 
 ## 🔧 BitArray Backends
 
-FlexFloat supports multiple BitArray implementations for different performance characteristics:
+FlexFloat supports multiple BitArray implementations for different performance characteristics. You can use them directly or configure FlexFloat to use a specific implementation:
 
 ```python
 from flexfloat import (
     FlexFloat, 
-    set_default_implementation, 
-    get_available_implementations
+    ListBoolBitArray,
+    ListInt64BitArray,
+    BigIntBitArray
 )
 
-# View available implementations
-print(get_available_implementations())  # ['list', 'int64']
-
-# Use list-based implementation (default, more flexible)
-set_default_implementation('list')
-flex_list = FlexFloat.from_float(42.0)
+# Configure FlexFloat to use a specific BitArray implementation
+FlexFloat.set_bitarray_implementation(ListBoolBitArray)  # Default
+flex_bool = FlexFloat.from_float(42.0)
 
-# Use int64-based implementation (faster for small bit arrays)
-set_default_implementation('int64')
+FlexFloat.set_bitarray_implementation(ListInt64BitArray)  # For performance
 flex_int64 = FlexFloat.from_float(42.0)
 
-# Both produce the same results with different performance characteristics
+FlexFloat.set_bitarray_implementation(BigIntBitArray)  # For very large arrays
+flex_bigint = FlexFloat.from_float(42.0)
+
+# Use BitArray implementations directly
+bits = [True, False, True, False]
+bool_array = ListBoolBitArray.from_bits(bits)
+int64_array = ListInt64BitArray.from_bits(bits)
+bigint_array = BigIntBitArray.from_bits(bits)
 ```
 
 ### Implementation Comparison
 
 | Implementation | Best For | Pros | Cons |
 |---------------|----------|------|------|
-| `list[bool]` | Smaller exponents and testing | Flexible, easy to understand | Slower for large numbers |
-| `list[int64]` | Standard operations | Fast for bigger numbers, efficient memory | Overhead for small numbers |
+| `ListBoolBitArray` | Testing and development | Simple, flexible, easy to debug | Slower for large operations |
+| `ListInt64BitArray` | Standard operations | Fast for medium-sized arrays, memory efficient | Some overhead for very small arrays |
+| `BigIntBitArray` | Any usescases | Python already optimizes it | Overhead for small arrays |
 
 ## 📚 API Reference
 
@@ -159,6 +170,11 @@ abs(a), -a
 
 # Mathematical functions
 FlexFloat.e ** x  # Exponential function
+flexfloat.exp()   # Natural exponential
+flexfloat.abs()   # Absolute value
+
+# BitArray configuration
+FlexFloat.set_bitarray_implementation(implementation: Type[BitArray])
 ```
 
 ### Special Values
@@ -269,8 +285,9 @@ flexfloat/
 ├── types.py             # Type definitions
 ├── bitarray/            # BitArray implementations
 │   ├── bitarray.py          # Abstract base class
-│   ├── bitarray_list.py     # List-based implementation
-│   ├── bitarray_int64.py    # Int64-based implementation
+│   ├── bitarray_bool.py     # List[bool] implementation
+│   ├── bitarray_int64.py    # List[int64] implementation  
+│   ├── bitarray_bigint.py   # Python int implementation
 │   └── bitarray_mixins.py   # Common functionality
 └── __init__.py          # Public API exports
 ```
@@ -301,8 +318,14 @@ flexfloat/
 ### Optimization Tips
 
 ```python
-# Prefer int64 implementation for standard operations
-set_default_implementation('int64')
+from flexfloat import FlexFloat, ListInt64BitArray, BigIntBitArray
+
+# Choose the right BitArray implementation for your use case
+# For standard operations with moderate precision
+FlexFloat.set_bitarray_implementation(ListInt64BitArray)
+
+# For most use cases, Python's int is already optimized
+FlexFloat.set_bitarray_implementation(BigIntBitArray)
 
 # Batch operations when possible
 values = [FlexFloat.from_float(x) for x in range(1000)]

flexfloat-0.3.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+flexfloat/__init__.py,sha256=Y7oR-CRyfDv_ImzcS4jkVveMzaXc2BHvAyzItgUaF3E,933
+flexfloat/core.py,sha256=EQiBMmUtDreWFLjVeuaEiEj-PyNNcOV9BmRtOCs4neU,42821
+flexfloat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flexfloat/types.py,sha256=Enm4-oyGnvxGI-7MOK6eEIH2IzWafk0wQBsPaTqFYrE,266
+flexfloat/bitarray/__init__.py,sha256=aFnw7HSlFwWnFwmLhmjvRwt6qOakbUochHwT8di0v14,979
+flexfloat/bitarray/bitarray.py,sha256=L8CYFSxyMgfV-CpvtrKJ_kO3nexsHK2E2pNN9BfnNyI,8428
+flexfloat/bitarray/bitarray_bigint.py,sha256=yLfAreZ9hhP2f2dIS7ptYSuAFlUTXJiv-LtHhRWN5dc,9986
+flexfloat/bitarray/bitarray_bool.py,sha256=naTUcTycvP9BfU1_CJRgajgvsJoQz9jvi5aI224pphE,6429
+flexfloat/bitarray/bitarray_int64.py,sha256=FLfbg2gk_Ia-9_4UjoiWYZNK3CbD4teAYU5SGSV3WF0,10856
+flexfloat/bitarray/bitarray_mixins.py,sha256=HJkyseP_yat0tE3_XElFEqBgKk8oWEiHEKjzqIRwUnw,5026
+flexfloat-0.3.0.dist-info/licenses/LICENSE,sha256=uwwkK--SUYUV3lbrv9kXJ_vDiYfHVb-t732g6c4qg7Q,1077
+flexfloat-0.3.0.dist-info/METADATA,sha256=l9sXHmygreTApX2unPPQny_I8vVekmGUl-A0SLcbXSU,11510
+flexfloat-0.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+flexfloat-0.3.0.dist-info/top_level.txt,sha256=82S8dY2UoNZh-9pwg7tUvbwB3uw2s3mfEoyUW6vCMdU,10
+flexfloat-0.3.0.dist-info/RECORD,,

flexfloat/bitarray/bitarray_list.py

@@ -1,187 +0,0 @@
-"""List-based BitArray implementation for the flexfloat package."""
-
-from __future__ import annotations
-
-import struct
-from typing import Iterator, overload
-
-from .bitarray import BitArray
-from .bitarray_mixins import BitArrayCommonMixin
-
-
-class ListBitArray(BitArrayCommonMixin):
-    """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 zeros(cls, length: int) -> ListBitArray:
-        """Create a BitArray filled with zeros.
-
-        Args:
-            length: The length of the bit array.
-        Returns:
-            ListBitArray: A BitArray filled with False values.
-        """
-        return cls([False] * length)
-
-    @classmethod
-    def ones(cls, length: int) -> ListBitArray:
-        """Create a BitArray filled with ones.
-
-        Args:
-            length: The length of the bit array.
-        Returns:
-            ListBitArray: A BitArray filled with True values.
-        """
-        return cls([True] * length)
-
-    @staticmethod
-    def parse_bitarray(bitstring: str) -> ListBitArray:
-        """Parse a string of bits (with optional spaces) into a BitArray instance."""
-        bits = [c == "1" for c in bitstring if c in "01"]
-        return ListBitArray(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) -> ListBitArray:
-        """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 value is positive, it shifts left; if negative, it shifts right.
-        Fills the new bits with the specified fill value (default is False).
-
-        Args:
-            shift_amount (int): The number of bits to shift. Positive for left shift,
-                negative for right shift.
-            fill (bool): The value to fill in the new bits created by the shift.
-                Defaults to False.
-        Returns:
-            ListBitArray: 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 ListBitArray(new_bits)
-
-    def copy(self) -> ListBitArray:
-        """Create a copy of the bit array.
-
-        Returns:
-            ListBitArray: A new BitArray with the same bits.
-        """
-        return ListBitArray(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) -> ListBitArray: ...
-
-    def __getitem__(self, index: int | slice) -> bool | ListBitArray:
-        """Get an item or slice from the bit array."""
-        if isinstance(index, slice):
-            return ListBitArray(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] = list(value)
-            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]) -> ListBitArray:
-        """Concatenate two bit arrays."""
-        if isinstance(other, BitArray):
-            return ListBitArray(self._bits + list(other))
-        return ListBitArray(self._bits + other)
-
-    def __radd__(self, other: list[bool]) -> ListBitArray:
-        """Reverse concatenation with a list."""
-        return ListBitArray(other + self._bits)
-
-    def __repr__(self) -> str:
-        """Return a string representation of the BitArray."""
-        return f"ListBitArray({self._bits})"

flexfloat-0.1.3.dist-info/RECORD

@@ -1,14 +0,0 @@
-flexfloat/__init__.py,sha256=QynzrIicNr9asICyJbity5QdrFop7xEDlKkrS7rZfKk,725
-flexfloat/core.py,sha256=u5TVNxGxsb0_H4vc9p6PvjeBYRJrYBABhZxOTcS5sAg,39658
-flexfloat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-flexfloat/types.py,sha256=_vRC7gQl5ua76QfKco4L3jQ4uPtEPUxPNGy4zWBFbns,113
-flexfloat/bitarray/__init__.py,sha256=nyHA70JnEuDVOYWfHjhNNu0zm4xVLWADkuMo0kqsJ7c,2512
-flexfloat/bitarray/bitarray.py,sha256=ASq8L1Ky84H41AzhLlZjY1u1k6zOtyf2czuD-ixGsJA,5912
-flexfloat/bitarray/bitarray_int64.py,sha256=kq-vULiA0lk8GaSDUf9U41q12qCREdn83ywKxiNjv_M,10585
-flexfloat/bitarray/bitarray_list.py,sha256=OTH6MjA1kBHPZP2Mi2mIViN2aOdxHVVrCybV-9ko99c,6586
-flexfloat/bitarray/bitarray_mixins.py,sha256=Cfm0dt1gRIG5kNb9wPPH62Tzd5B0Ck6YZupHia1jKmo,3302
-flexfloat-0.1.3.dist-info/licenses/LICENSE,sha256=uwwkK--SUYUV3lbrv9kXJ_vDiYfHVb-t732g6c4qg7Q,1077
-flexfloat-0.1.3.dist-info/METADATA,sha256=Iea-nvdjZCsfvrhfNQTEHnCozLgPLRotRG8RqskwjXs,10375
-flexfloat-0.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-flexfloat-0.1.3.dist-info/top_level.txt,sha256=82S8dY2UoNZh-9pwg7tUvbwB3uw2s3mfEoyUW6vCMdU,10
-flexfloat-0.1.3.dist-info/RECORD,,