基于位掩码的唯一排序算法原理
在某些特定场景下，当需要对非负整数数组进行去重并排序时，可以利用位掩码（bitmask）技术实现近似线性时间（o(n + m)，其中m为最大整数值）的算法。其基本思想是：创建一个足够大的整数（或位数组），将输入数组中的每个数字映射到该整数的对应位上。如果数字x存在，则将1
考虑以下Python实现示例：
import numpy as np
from time import perf_counter
from numba import njit
def count_unique_with_bitmask(ls):
ret = []
m = 0 # 初始化位掩码
# 第一阶段：构建位掩码
for x in ls:
# 将数字x对应的位设置为1
# 注意：这里假设x是非负整数且在合理范围内
m = m | (1 << int(x))
# 第二阶段：从位掩码中提取唯一且排序的数字
i = 0
while m > 0: # 当掩码m不为0时循环
if (m & 1): # 检查当前最低位是否为1
ret.append(i)
m = m >> 1 # 掩码右移一位，检查下一个位
i += 1 # 对应数字递增
return ret
# 示例测试
RNG = np.random.default_rng(0)
x = RNG.integers(2**16, size=2**17) # 生成大量非负整数
print(f"原始数组大小: {len(x)}")
start = perf_counter()
y1 = np.unique(x)
print(f"NumPy unique 耗时: {perf_counter() - start:.6f} 秒")
start = perf_counter()
y2 = count_unique_with_bitmask(x)
print(f"位掩码 unique 耗时 (Python): {perf_counter() - start:.6f} 秒")
print(f"结果是否一致: {(y1 == y2).all()}")在纯Python环境下，尽管count_unique_with_bitmask函数实现了预期的功能，但由于Python解释器的开销，其性能通常不如底层C语言实现的np.unique。为了提升性能，自然会想到使用Numba的即时编译（JIT）功能。
Numba加速下的异常行为
当尝试使用@njit装饰器对count_unique_with_bitmask函数进行Numba加速时，我们发现了一个意料之外的错误：函数不再返回正确的唯一排序列表，而是返回一个空列表。
# ... (import和RNG定义省略) ...
@njit # 添加Numba JIT装饰器
def count_unique_with_bitmask_numba(ls):
ret = []
m = 0
for x in ls:
m = m | (1 << int(x))
i = 0
while m > 0:
if (m & 1):
ret.append(i)
m = m >> 1
i += 1
return ret
# ... (测试代码省略) ...
# start = perf_counter()
# y3 = count_unique_with_bitmask_numba(x) # 调用Numba加速版本
# print(f"位掩码 unique 耗时 (Numba): {perf_counter() - start:.6f} 秒")
# print(f"结果是否一致 (Numba): {(y1 == y3).all()}") # 此时会报错或返回False调试发现，当@njit生效时，count_unique_with_bitmask_numba函数中的while m > 0:循环会立即终止，导致ret列表始终为空。
Numba中整数处理的机制与陷阱
问题的根源在于Python和Numba对整数的处理方式存在根本差异：
- Python的任意精度整数： Python中的整数是任意精度的，这意味着它们可以表示任意大小的整数，不受底层硬件字长的限制。例如，1
- Numba的固定宽度整数： 为了实现高性能，Numba在JIT编译时会将Python的动态类型转换为C语言风格的固定宽度类型。对于整数，这通常意味着使用64位有符号整数（int64）。
这种差异在进行位移操作时尤为关键。在一个64位有符号整数中，最高的位（第63位）被用作符号位。
- 当执行1
- 如果amount小于63，结果是一个正数。
- 如果amount等于63，结果是1
- 如果amount大于63，结果的行为取决于具体实现，但通常也会导致溢出或非预期的负数。
在上述count_unique_with_bitmask_numba函数中，当输入数组ls包含大于或等于63的数字时，例如x = 63，m = m | (1 0:的条件判断m > 0立即为假，循环体不会执行，从而导致函数返回一个空列表。
验证位移操作的行为
我们可以通过一个简单的Numba函数来验证1
from numba import njit
@njit
def shift_test(amount):
return 1 << amount
print("Numba中1 << amount的十六进制表示：")
for i in range(66):
# 注意：这里直接打印十六进制有助于观察符号位
print(f"amount = {i}, 结果 (十进制): {shift_test(i)}, 结果 (十六进制): {hex(shift_test(i))}")
运行上述代码，你会观察到：
- 当i小于63时，结果是预期的正数。
- 当i = 63时，结果会是一个很大的负数（例如-9223372036854775808），其十六进制表示为0x8000000000000000。最高位为1，表示负数。
- 当i大于63时，结果会进一步溢出，产生其他非预期的负数或零。
注意事项与替代方案
- 位掩码的局限性： 这种基于单个整数位掩码的方法，其能处理的最大数字范围受限于整数的位数。对于64位整数，最多只能处理0到63的数字。如果输入数据范围超过这个限制，无论是否使用Numba，这种方法都需要修改为使用位数组（如np.array的bool类型或uint8类型）来扩展掩码的范围。
-
Numba类型推断与显式类型： 在使用Numba时，了解其类型推断机制至关重要。如果需要处理大整数或进行可能导致溢出的位操作，应考虑显式指定Numba的无符号整数类型（如uint64）来避免符号位问题，但这仍然无法解决超过64位的问题。
- 例如，将m初始化为numba.uint64(0)可能有助于推断为无符号类型。
-
替代的唯一排序方法：
- NumPy的np.unique： 对于大多数情况，np.unique是首选。它在底层用C语言实现，效率极高，并且能处理任意范围和类型的数据。
- Python set： 如果对性能要求不高，或者数据量不大，Python内置的set数据结构可以非常方便地实现去重。
- 布尔数组： 对于已知最大值M的非负整数，可以创建一个大小为M+1的布尔数组。遍历输入数组，将对应索引的布尔值设为True。最后遍历布尔数组，收集所有True的索引。这种方法在Numba中可以高效实现，并且能够处理远超64的数字范围。
@njit
def count_unique_with_bool_array_numba(ls, max_val):
# 创建一个布尔数组作为位掩码的替代
present = np.zeros(max_val + 1, dtype=np.bool_)
for x in ls:
if x <= max_val: # 确保不越界
present[x] = True
ret = []
for i in range(max_val + 1):
if present[i]:
ret.append(i)
return ret
# 示例使用
# max_val = x.max() # 获取输入数组的最大值
# start = perf_counter()
# y4 = count_unique_with_bool_array_numba(x, max_val)
# print(f"布尔数组 unique 耗时 (Numba): {perf_counter() - start:.6f} 秒")
# print(f"结果是否一致 (布尔数组 Numba): {(y1 == y4).all()}")总结
Numba通过将Python的动态类型映射到固定宽度类型来提高性能，但这也引入了C语言风格的整数溢出行为。在进行位操作时，尤其需要警惕1
