flexfloat 0.1.3__py3-none-any.whl → 0.1.5__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.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flexfloat
-Version: 0.1.3
+Version: 0.1.5
 Summary: A library for arbitrary precision floating point arithmetic
 Author: Ferran Sanchez Llado
 License: MIT

flexfloat-0.1.5.dist-info/RECORD

@@ -0,0 +1,15 @@
+flexfloat/__init__.py,sha256=u-B9oE-zA_3wuKYhRMLiXldCKN7Xeclf5gK0vAT2OBI,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.1.5.dist-info/licenses/LICENSE,sha256=uwwkK--SUYUV3lbrv9kXJ_vDiYfHVb-t732g6c4qg7Q,1077
+flexfloat-0.1.5.dist-info/METADATA,sha256=wAYgXkZWRv9YERXb5-XygV8y506I8GW2Dg-C1uiaIu4,10375
+flexfloat-0.1.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+flexfloat-0.1.5.dist-info/top_level.txt,sha256=82S8dY2UoNZh-9pwg7tUvbwB3uw2s3mfEoyUW6vCMdU,10
+flexfloat-0.1.5.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,,