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

flexfloat/{bitarray.py → bitarray/bitarray_list.py}

@@ -1,12 +1,15 @@
-"""BitArray implementation for the flexfloat package."""
+"""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 BitArray:
+
+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
@@ -22,73 +25,32 @@ class BitArray:
         self._bits = bits if bits is not None else []
 
     @classmethod
-    def from_float(cls, value: float) -> BitArray:
-        """Convert a floating-point number to a bit array.
-
-        Args:
-            value (float): The floating-point number to convert.
-        Returns:
-            BitArray: A BitArray representing the bits of the floating-point number.
-        """
-        # Pack as double precision (64 bits)
-        packed = struct.pack("!d", value)
-        # Convert to boolean list
-        bits = [bool((byte >> bit) & 1) for byte in packed for bit in range(7, -1, -1)]
-        return cls(bits)
-
-    @classmethod
-    def from_signed_int(cls, value: int, length: int) -> BitArray:
-        """Convert a signed integer to a bit array using off-set binary representation.
-
-        Args:
-            value (int): The signed integer to convert.
-            length (int): The length of the resulting bit array.
-        Returns:
-            BitArray: A BitArray representing the bits of the signed integer.
-        Raises:
-            AssertionError: If the value is out of range for the specified length.
-        """
-        half = 1 << (length - 1)
-        max_value = half - 1
-        min_value = -half
-
-        assert (
-            min_value <= value <= max_value
-        ), "Value out of range for specified length."
-
-        # Convert to unsigned integer representation
-        unsigned_value = value - half
-
-        bits = [(unsigned_value >> i) & 1 == 1 for i in range(length - 1, -1, -1)]
-        return cls(bits)
-
-    @classmethod
-    def zeros(cls, length: int) -> BitArray:
+    def zeros(cls, length: int) -> ListBitArray:
         """Create a BitArray filled with zeros.
 
         Args:
             length: The length of the bit array.
         Returns:
-            BitArray: A BitArray filled with False values.
+            ListBitArray: A BitArray filled with False values.
         """
         return cls([False] * length)
 
     @classmethod
-    def ones(cls, length: int) -> BitArray:
+    def ones(cls, length: int) -> ListBitArray:
         """Create a BitArray filled with ones.
 
         Args:
             length: The length of the bit array.
         Returns:
-            BitArray: A BitArray filled with True values.
+            ListBitArray: A BitArray filled with True values.
         """
         return cls([True] * length)
 
     @staticmethod
-    def parse_bitarray(bitstring: str) -> BitArray:
+    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 BitArray(bits)
+        return ListBitArray(bits)
 
     def to_float(self) -> float:
         """Convert a 64-bit array to a floating-point number.
@@ -135,7 +97,7 @@ class BitArray:
         # If the sign bit is set, subtract the bias
         return int_value - bias
 
-    def shift(self, shift_amount: int, fill: bool = False) -> BitArray:
+    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
@@ -149,7 +111,7 @@ class BitArray:
             fill (bool): The value to fill in the new bits created by the shift.
                 Defaults to False.
         Returns:
-            BitArray: A new BitArray with the bits shifted and filled.
+            ListBitArray: A new BitArray with the bits shifted and filled.
         """
         if shift_amount == 0:
             return self.copy()
@@ -159,15 +121,15 @@ class BitArray:
             new_bits = [fill] * shift_amount + self._bits[:-shift_amount]
         else:
             new_bits = self._bits[-shift_amount:] + [fill] * (-shift_amount)
-        return BitArray(new_bits)
+        return ListBitArray(new_bits)
 
-    def copy(self) -> BitArray:
+    def copy(self) -> ListBitArray:
         """Create a copy of the bit array.
 
         Returns:
-            BitArray: A new BitArray with the same bits.
+            ListBitArray: A new BitArray with the same bits.
         """
-        return BitArray(self._bits.copy())
+        return ListBitArray(self._bits.copy())
 
     def __len__(self) -> int:
         """Return the length of the bit array."""
@@ -176,12 +138,12 @@ class BitArray:
     @overload
     def __getitem__(self, index: int) -> bool: ...
     @overload
-    def __getitem__(self, index: slice) -> BitArray: ...
+    def __getitem__(self, index: slice) -> ListBitArray: ...
 
-    def __getitem__(self, index: int | slice) -> bool | BitArray:
+    def __getitem__(self, index: int | slice) -> bool | ListBitArray:
         """Get an item or slice from the bit array."""
         if isinstance(index, slice):
-            return BitArray(self._bits[index])
+            return ListBitArray(self._bits[index])
         return self._bits[index]
 
     @overload
@@ -195,7 +157,7 @@ class BitArray:
         """Set an item or slice in the bit array."""
         if isinstance(index, slice):
             if isinstance(value, BitArray):
-                self._bits[index] = value._bits
+                self._bits[index] = list(value)
             elif isinstance(value, list):
                 self._bits[index] = value
             else:
@@ -210,48 +172,16 @@ class BitArray:
         """Iterate over the bits in the array."""
         return iter(self._bits)
 
-    def __add__(self, other: BitArray | list[bool]) -> BitArray:
+    def __add__(self, other: BitArray | list[bool]) -> ListBitArray:
         """Concatenate two bit arrays."""
         if isinstance(other, BitArray):
-            return BitArray(self._bits + other._bits)
-        return BitArray(self._bits + other)
+            return ListBitArray(self._bits + list(other))
+        return ListBitArray(self._bits + other)
 
-    def __radd__(self, other: list[bool]) -> BitArray:
+    def __radd__(self, other: list[bool]) -> ListBitArray:
         """Reverse concatenation with a list."""
-        return BitArray(other + self._bits)
-
-    def __eq__(self, other: object) -> bool:
-        """Check equality with another BitArray or list."""
-        if isinstance(other, BitArray):
-            return self._bits == other._bits
-        if isinstance(other, list):
-            return self._bits == other
-        return False
-
-    def __bool__(self) -> bool:
-        """Return True if any bit is set."""
-        return any(self._bits)
+        return ListBitArray(other + self._bits)
 
     def __repr__(self) -> str:
         """Return a string representation of the BitArray."""
-        return f"BitArray({self._bits})"
-
-    def __str__(self) -> str:
-        """Return a string representation of the bits."""
-        return "".join("1" if bit else "0" for bit in self._bits)
-
-    def any(self) -> bool:
-        """Return True if any bit is set to True."""
-        return any(self._bits)
-
-    def all(self) -> bool:
-        """Return True if all bits are set to True."""
-        return all(self._bits)
-
-    def count(self, value: bool = True) -> int:
-        """Count the number of bits set to the specified value."""
-        return self._bits.count(value)
-
-    def reverse(self) -> BitArray:
-        """Return a new BitArray with the bits in reverse order."""
-        return BitArray(self._bits[::-1])
+        return f"ListBitArray({self._bits})"

flexfloat/bitarray/bitarray_mixins.py

@@ -0,0 +1,93 @@
+"""Mixin classes providing common BitArray functionality."""
+
+from __future__ import annotations
+
+import struct
+from typing import Any
+
+from .bitarray import BitArray
+
+
+class BitArrayCommonMixin(BitArray):
+    """Mixin providing common methods that can be implemented using the BitArray
+    protocol.
+
+    This mixin provides default implementations for methods that can be expressed
+    in terms of the core BitArray protocol methods (__iter__, __len__, etc.).
+
+    Classes using this mixin must implement the BitArray protocol.
+    """
+
+    @classmethod
+    def from_float(cls, value: float) -> Any:
+        """Convert a floating-point number to a bit array.
+
+        Args:
+            value (float): The floating-point number to convert.
+        Returns:
+            BitArray: A BitArray representing the bits of the floating-point number.
+        """
+        # Pack as double precision (64 bits)
+        packed = struct.pack("!d", value)
+        # Convert to boolean list
+        bits = [bool((byte >> bit) & 1) for byte in packed for bit in range(7, -1, -1)]
+        return cls(bits)
+
+    @classmethod
+    def from_signed_int(cls, value: int, length: int) -> Any:
+        """Convert a signed integer to a bit array using off-set binary representation.
+
+        Args:
+            value (int): The signed integer to convert.
+            length (int): The length of the resulting bit array.
+        Returns:
+            BitArray: A BitArray representing the bits of the signed integer.
+        Raises:
+            AssertionError: If the value is out of range for the specified length.
+        """
+        half = 1 << (length - 1)
+        max_value = half - 1
+        min_value = -half
+
+        assert (
+            min_value <= value <= max_value
+        ), "Value out of range for specified length."
+
+        # Convert to unsigned integer representation
+        unsigned_value = value - half
+
+        bits = [(unsigned_value >> i) & 1 == 1 for i in range(length - 1, -1, -1)]
+        return cls(bits)
+
+    def __str__(self) -> str:
+        """Return a string representation of the bits."""
+        # This assumes self implements __iter__ as per the BitArray protocol
+        return "".join("1" if bit else "0" for bit in self)  # type: ignore
+
+    def __eq__(self, other: object) -> bool:
+        """Check equality with another BitArray or list."""
+        if hasattr(other, "__iter__") and hasattr(other, "__len__"):
+            if len(self) != len(other):  # type: ignore
+                return False
+            return all(a == b for a, b in zip(self, other))  # type: ignore
+        return False
+
+    def __bool__(self) -> bool:
+        """Return True if any bit is set."""
+        return self.any()
+
+    def any(self) -> bool:
+        """Return True if any bit is set to True."""
+        return any(self)  # type: ignore
+
+    def all(self) -> bool:
+        """Return True if all bits are set to True."""
+        return all(self)  # type: ignore
+
+    def count(self, value: bool = True) -> int:
+        """Count the number of bits set to the specified value."""
+        return sum(1 for bit in self if bit == value)  # type: ignore
+
+    def reverse(self) -> Any:
+        """Return a new BitArray with the bits in reverse order."""
+        return self.__class__(list(self)[::-1])  # type: ignore