bool-hybrid-array 9.11.14__py3-none-any.whl → 9.11.16__py3-none-any.whl

bool_hybrid_array/core.py

@@ -15,7 +15,6 @@ from functools import lru_cache
 from typing import _GenericAlias
 from typing import Callable, Union, Sequence, MutableSequence, Any, overload, Sized
 hybrid_array_cache:list[tuple[Any]] = []
-index_range=lambda BHA:(BHA[i] for i in itertools.count(0) if i < BHA.size)
 try:
     msvcrt = ctypes.CDLL('msvcrt.dll')
     memcpy = msvcrt.memcpy
@@ -359,7 +358,7 @@ class BoolHybridArray(MutableSequence,Exception,metaclass=ResurrectMeta):# type:
         return int(self.size)
     def __iter__(self):
         if not self:return BHA_Iterator([])
-        return BHA_Iterator(map(self.__getitem__,index_range(size)))
+        return BHA_Iterator(map(self.__getitem__,itertools.takewhile(lambda x: x < self.size, itertools.count(0))))
     def __next__(self):
         return next(self.generator)
     def __contains__(self, value:Any) -> bool:
@@ -449,13 +448,13 @@ class BoolHybridArray(MutableSequence,Exception,metaclass=ResurrectMeta):# type:
             raise ValueError(f"异或运算要求数组长度相同（{len(self)} vs {len(other)}）")
         return BoolHybridArr(map(operator.xor, self, other),hash_ = self.hash_)
     def __gt__(self,other):
-        if self.size!=len(other)
+        if self.size!=len(other):
             return self.size>len(other)
-        return any(map(operator.gt,self,other)
+        return any(map(operator.gt,self,other))
     def __lt__(self,other):
-        if self.size!=len(other)
+        if self.size!=len(other):
             return self.size<len(other)
-        return any(map(operator.lt,self,other)
+        return any(map(operator.lt,self,other))
     def __rxor__(self, other) -> BoolHybridArray:
         return self^other
     def __invert__(self) -> BoolHybridArray:
@@ -947,6 +946,13 @@ def numba_opt():
     bisect.bisect_left = numba.njit(sig, cache=True)(bisect.bisect_left)
     bisect.bisect_right = numba.njit(sig, cache=True)(bisect.bisect_right)
 from ._cppiostream import cin,cout,endl
+def namespace(name,bases,namespace_):
+    tmp = {}
+    for base in bases:tmp.update(base.__namespace__)
+    self = ProtectedBuiltinsDict({**tmp,**namespace_},name = name,protected_names = namespace_.get("protected_names",()))
+    self["__namespace__"] = self
+    return self
+
 builtins.np = np
 builtins.T = BHA_bool(1)
 builtins.F = BHA_bool(0)

bool_hybrid_array/float_array/__init__.py

@@ -0,0 +1,3 @@
+try:from .compile_core import *
+except:from .core import*
+__all__ = tuple(globals())

bool_hybrid_array/float_array/core.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+from collections.abc import Sequence
+from ..int_array import IntHybridArray
+from ..core import BHA_Iterator
+import operator,math,itertools
+class BHA_Float:
+    def __init__(self, data: int | str | float | BHA_Float | tuple):
+        if isinstance(data, tuple):
+            self.a,self.b,self.length = data
+            return
+        if isinstance(data, BHA_Float):
+            self.a = data.a
+            self.b = data.b
+            self.length = data.length
+            return
+        if isinstance(data, int):
+            data = float(data)
+        if isinstance(data, float):
+            data = repr(data)
+        a, b = data.split('.')
+        b = b.rstrip('0')
+        self.length = len(b) if b else 1
+        self.a, self.b = int(a) if a else 0, int(b) if b else 0
+
+    def _align_decimal(self, other):
+        max_len = max(self.length, other.length)
+        self_num = self.a * (10 ** max_len) + self.b * (10 ** (max_len - self.length))
+        other_num = other.a * (10 ** max_len) + other.b * (10 ** (max_len - other.length))
+        return self_num, other_num, max_len
+
+    def __add__(self, other):
+        other = BHA_Float(other)
+        self_num, other_num, max_len = self._align_decimal(other)
+        sum_num = self_num + other_num
+        string = repr(sum_num)
+        integer_part = string[:-max_len] if len(string) > max_len else '0'
+        decimal_part = string[-max_len:] if len(string) >= max_len else string.zfill(max_len)
+        return BHA_Float(f"{integer_part}.{decimal_part}")
+
+    def __sub__(self, other):
+        other = BHA_Float(other)
+        self_num, other_num, max_len = self._align_decimal(other)
+        sub_num = self_num - other_num
+        if sub_num < 0:
+            string = repr(-sub_num)
+            sign = '-'
+        else:
+            string = repr(sub_num)
+            sign = ''
+        integer_part = string[:-max_len] if len(string) > max_len else '0'
+        decimal_part = string[-max_len:] if len(string) >= max_len else string.zfill(max_len)
+        return BHA_Float(f"{sign}{integer_part}.{decimal_part}")
+    def __mul__(self, other):
+        other = BHA_Float(other)
+        self_num = self.a * (10 ** self.length) + self.b
+        other_num = other.a * (10 ** other.length) + other.b
+        product = self_num * other_num
+        string = repr(product)
+        total_decimal = self.length + other.length
+        string = string.zfill(total_decimal + 1)
+        integer_part = string[:-total_decimal]
+        decimal_part = string[-total_decimal:]
+        return BHA_Float(f"{integer_part}.{decimal_part}")
+
+    def __truediv__(self, other, total_decimal = 22):
+        other = BHA_Float(other)
+        self_num = self.a * (10 ** self.length) + self.b
+        other_num = other.a * (10 ** other.length) + other.b
+        if other_num == 0:
+            raise ZeroDivisionError("Cannot divide by zero")
+        div_num = (self_num * (10 ** total_decimal)) // other_num
+        string = repr(div_num)
+        if len(string) <= total_decimal:
+            string = '0' * (total_decimal - len(string) + 1) + string
+        integer_part = string[:-total_decimal]
+        decimal_part = string[-total_decimal:]
+        return BHA_Float(f"{integer_part}.{decimal_part}")
+    def __repr__(self):
+        return f"BHA_Float({self.a}.{str(self.b).zfill(self.length)})"
+    def __str__(self):
+        return f"{self.a}.{str(self.b).zfill(self.length)}"
+    __radd__ = __add__
+    __rmul__ = __mul__
+    __rsub__ = lambda self,other:BHA_Float(other)-self
+    __rtruediv__ = lambda self,other:BHA_Float(other)/self
+    def __float__(self):
+        return float(str(self))
+    def __int__(self):
+        return self.a
+    is_integer = lambda self:not self.b
+    __bool__ = lambda self:self.a or self.b
+    def as_integer_ratio(self) -> tuple[int, int]:
+        denominator = 10 ** self.length
+        numerator = self.a * denominator + self.b
+        if numerator < 0:
+            numerator = -numerator
+            sign = -1
+        else:
+            sign = 1
+        gcd_val = math.gcd(numerator, denominator)
+        if gcd_val == 0:
+            gcd_val = 1
+        simplified_num = sign * (numerator // gcd_val)
+        simplified_den = denominator // gcd_val
+        return (simplified_num, simplified_den)
+    def __eq__(self,other):
+        try:
+            other = BHA_Float(other)
+            self_num, other_num, _ = self._align_decimal(other)
+            return self_num == other_num
+        except (ValueError, AttributeError):
+            return False
+    def __floordiv__(self, other):
+        return BHA_Float(int(float(self / other)))
+    def __mod__(self, other):
+        return self - (self // other) * other
+    def __pow__(self, power, m = None):
+        return BHA_Float(pow(float(self),float(BHA_Float(power)),m))
+    def __neg__(self):
+        return BHA_Float((-self.a, self.b, self.length))
+    def __pos__(self):
+        return self
+    def __abs__(self):
+        return BHA_Float((abs(self.a), self.b, self.length))
+    def __lt__(self,other):
+        a, b, _ = self._align_decimal(other)
+        return a<b
+    def __gt__(self,other):
+        a, b, _ = self._align_decimal(other)
+        return a>b
+    def __round__(self,n = None):
+        return round(float(self),n)
+    __rmod__ = lambda self,other:BHA_Float(other)%self
+    __rfloordiv__ = lambda self,other:BHA_Float(other)//self
+    __rpow__ = lambda self,other,m=None:pow(BHA_Float(other),self,m)
+class FloatHybridArray(Sequence):
+    def __init__(self,data,Type = BHA_Float):
+        self.Type = Type
+        data = BHA_Iterator(map(BHA_Float,data))
+        self.lengths = IntHybridArray(map(operator.attrgetter('length'),data))
+        self.a = IntHybridArray(map(operator.attrgetter('a'),data))
+        self.b = IntHybridArray(map(operator.attrgetter('b'),data))
+    def __getitem__(self,index):
+        return self.Type(BHA_Float((self.a[index],self.b[index],self.lengths[index])))
+    def __setitem__(self,index,value):
+        value = BHA_Float(value)
+        self.lengths[index] = value.length
+        self.a[index] = value.a
+        self.b[index] = value.b
+    def append(self,value):
+        value = BHA_Float(value)
+        self.lengths.append(value.length)
+        self.a.append(value.a)
+        self.b.append(value.b)
+    def __len__(self):
+        return len(self.a)
+    def __iter__(self):
+        return BHA_Iterator(value for value in itertools.takewhile(lambda x: x < len(self), itertools.count(0)))

bool_hybrid_array/int_array/core.py

@@ -129,7 +129,8 @@ class IntHybridArray(BoolHybridArray,metaclass=ResurrectMeta):
         tmp1 = IntHybridArray([value],bit_length = self.bit_length)
         tmp = tmp1.view()
         if tmp1[0] == value:
-            super().__setitem__(slice(key*self.bit_length,(key+1)*self.bit_length),tmp)
+            for i,v in zip(range(key*self.bit_length,(key+1)*self.bit_length),tmp):
+                super().__setitem__(i,v)
         else:
             lst = list(self)
             lst[key] = value

{bool_hybrid_array-9.11.14.dist-info → bool_hybrid_array-9.11.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bool-hybrid-array
-Version: 9.11.14
+Version: 9.11.16
 Summary: 一个高效的布尔数组（密集+稀疏混合存储，节省内存）
 Home-page: https://github.com/BKsell/bool-hybrid-array
 Author: 蔡靖杰
@@ -449,7 +449,44 @@ print(f"第二次出队: {q.dequeue()}")  # 输出：F（直接从 self.b 弹出
 
 print(f"出队2个元素后: {q}")  # 输出：BHA_Queue([T,T,F,T,F])
 
+#float_array子包（9.11.15版本新增）
 
+# 1. 初始化数组
+f_arr = float_array.FloatHybridArray([1.1, 2.2, 3.3, 4.4, 5.5])
+
+# 2. 获取元素
+first_elem = f_arr[0]     # 获取第一个元素：BHA_Float(1.1)
+print(f"第一个元素：{first_elem}")
+
+# 3. 修改元素
+f_arr[1] = 9.9            # 修改第二个元素为 9.9
+print(f"修改后第二个元素：{f_arr[1]}")
+
+# 4. 添加元素
+f_arr.append(6.6)         # 追加元素 6.6
+print(f"数组长度：{len(f_arr)}")  # 输出：6
+
+# 5. 遍历数组
+for elem in f_arr:
+    print(f"数组元素：{elem}")
+
+#namespace元类（9.11.15版本新增）
+class BaseMathTools(metaclass = namespace):
+    pi = 3.141
+    def add(a,b):
+        return a+b
+    protected_names = ("pi","add")
+
+class MathTools(BaseMathTools,metaclass = namespace):
+    pi = 3.1415926535897932
+    def mul(a,b):
+        return a*b
+    def sub(a,b):
+        return a-b
+    e = 2.718281828
+    protected_names = (*BaseMathTools.protected_names,"e","sub","mul")
+
+print(MathTools.mul(10,23))#输出：230
 ```
 
 ## 性能优势
@@ -626,6 +663,8 @@ print(f"出队2个元素后: {q}")  # 输出：BHA_Queue([T,T,F,T,F])
 * **9.11.12**：优化了IntHybridArray的__setitem__，新增了IntHybridArray的sort
 * **9.11.13**：修复IndexError的错误
 * **9.11.14**：新增BoolHybridArray数组的大小比较
+* **9.11.15**：新增float_array子包和namespace元类
+* **9.11.16**：修复SyntaxError错误
 
 
 

bool_hybrid_array-9.11.16.dist-info/RECORD

@@ -0,0 +1,15 @@
+bool_hybrid_array/__init__.py,sha256=Zluk7xAYl3eL8dcMj2lFmMQVAkvWTNoWFELjDBrkq6Y,1112
+bool_hybrid_array/__main__.py,sha256=vJd9O_raREHIRCU0hkYzXM-lzRhgybhJqsKze6YcSDg,10058
+bool_hybrid_array/_cppiostream.py,sha256=1i973ag_8XgivQkeIbqzHivflcQkVFtX77R_UwChSAg,9205
+bool_hybrid_array/core.c,sha256=32k6ov1QiLS4OhMZoshe3Xie8ttBu3RANsOkP-UfL9w,3306682
+bool_hybrid_array/core.py,sha256=LaOW0HXEms6FbNQYfkmY3m40m9lX4wxbVGWjU4xXDcI,42864
+bool_hybrid_array/秘密.md,sha256=Ii2NvXmv-Ktu04zJsGLcQZvlzT4gOatByE4B2wTK1Ks,48
+bool_hybrid_array/float_array/__init__.py,sha256=tnOiqeZ4AIvNgPV16tt0ydz0NWzSa6e4arInS6F8Y-0,86
+bool_hybrid_array/float_array/core.py,sha256=LVC0YOINBoHVB5sGZcuzlsVYs_cUgfxC4idCgIzTZ78,6639
+bool_hybrid_array/int_array/__init__.py,sha256=CCKDUL5GBAXOprc9FhtLNL_rP4IDhvGVWJ-Dporp6YI,112
+bool_hybrid_array/int_array/core.py,sha256=ZH_UzPduamvqoYDB2tobg3zQTfZzIjrQ1qc8xi4QvP0,7974
+bool_hybrid_array-9.11.16.dist-info/licenses/LICENSE,sha256=Sg4rnGXkBDYkwJCWyxdWp5H60rhVAxpNvFh_l3JWZdY,1070
+bool_hybrid_array-9.11.16.dist-info/METADATA,sha256=BdR82YpDjCkqOHgY2TLF-pweTC1IzsbtNeEMh3u3OIs,27789
+bool_hybrid_array-9.11.16.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+bool_hybrid_array-9.11.16.dist-info/top_level.txt,sha256=vk-TD77wuVQsN1rJ6uVWZX4sC_wya_WplRDwQKJoBZM,18
+bool_hybrid_array-9.11.16.dist-info/RECORD,,

bool_hybrid_array-9.11.14.dist-info/RECORD

@@ -1,14 +0,0 @@
-bool_hybrid_array/__init__.py,sha256=UYkGgU0Ux77DN1qfEW37ba2mjDAhqCIrqCgxGpY3h_g,1086
-bool_hybrid_array/__main__.py,sha256=uFyebfsZl1tW54AVcc6IDhk36BglTGb_Vw3Djx8pq00,8987
-bool_hybrid_array/_cppiostream.py,sha256=1i973ag_8XgivQkeIbqzHivflcQkVFtX77R_UwChSAg,9205
-bool_hybrid_array/compile_core.cp314-win_amd64.pyd,sha256=3vFAZ6vSMqoP_fWRkXd_KVPVUw4oo2Nv7xi0sBQu2fQ,516096
-bool_hybrid_array/core.c,sha256=iG3px_6ZJzYhlSnZUpZxJP4CRYfMGk39dlQveU26ZFc,79
-bool_hybrid_array/core.py,sha256=6BLUmXX-5fBnjamspmfaZAuVetBvDH-eAn6_F5QPaxM,42607
-bool_hybrid_array/秘密.md,sha256=Ii2NvXmv-Ktu04zJsGLcQZvlzT4gOatByE4B2wTK1Ks,48
-bool_hybrid_array/int_array/__init__.py,sha256=CCKDUL5GBAXOprc9FhtLNL_rP4IDhvGVWJ-Dporp6YI,112
-bool_hybrid_array/int_array/core.py,sha256=DZ6mC-qLQahV25b_1RHGPK959XYtILYP_Pbwwg7nFLA,7936
-bool_hybrid_array-9.11.14.dist-info/licenses/LICENSE,sha256=Sg4rnGXkBDYkwJCWyxdWp5H60rhVAxpNvFh_l3JWZdY,1070
-bool_hybrid_array-9.11.14.dist-info/METADATA,sha256=mZs2z7RnExO3ywqfEdGXdfb1SRgWXsOx3oTewbn_moI,26618
-bool_hybrid_array-9.11.14.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-bool_hybrid_array-9.11.14.dist-info/top_level.txt,sha256=vk-TD77wuVQsN1rJ6uVWZX4sC_wya_WplRDwQKJoBZM,18
-bool_hybrid_array-9.11.14.dist-info/RECORD,,