优化NumPy布尔数组到浮点数的快速映射

import numpy as np
import timeit

# 假设有一个包含0或1的NumPy数组
random_bit = np.random.randint(0, 2, size=(10000), dtype=np.uint64)

# 方法一：直接算术运算 (1.0 - 2.0 * random_bit)
def np_cast(random_bit_array):
    vectorized_result = 1.0 - 2.0 * np.float64(random_bit_array)
    return vectorized_result

# 方法二：简化算术运算，依赖NumPy的隐式类型提升
def product(random_bit_array):
    mapped_result = 1.0 - 2.0 * random_bit_array
    return mapped_result

# 方法三：使用数组作为查找表
np_one_minus_one = np.array([1.0, -1.0]).astype(np.float64)
def _array(random_bit_array):
    mapped_result = np_one_minus_one[random_bit_array]
    return mapped_result

# 方法四：先类型转换再算术运算
one = np.float64(1)
minus_two = np.float64(-2)
def astype_method(random_bit_array):
    mapped_result = one + minus_two * random_bit_array.astype(np.float64)
    return mapped_result

# 方法五：一种常见的优化尝试 (转换为int8再处理)
def mason_method(random_bit_array):
    return (1 - 2 * random_bit_array.astype(np.int8)).astype(float)

print("--- NumPy原生方法性能测试 ---")
# 使用timeit进行基准测试，这里使用更精确的%timeit风格的输出，模拟实际性能
# 注意：以下时间是基于特定测试环境和数组大小的示例，实际可能有所不同
# 假设random_bit数组大小适中，例如10000个元素
# 以下是模拟的%timeit输出结果，单位为微秒 (µs)
# %timeit np_cast(random_bit)
# 6.58 µs ± 218 ns per loop
# %timeit product(random_bit)
# 7.58 µs ± 251 ns per loop
# %timeit _array(random_bit)
# 11 µs ± 9.34 ns per loop
# %timeit astype_method(random_bit)
# 7.32 µs ± 674 ns per loop
# %timeit mason_method(random_bit)
# 6.86 µs ± 153 ns per loop

import numba as nb

@nb.vectorize
def numba_if(random_bit_val):
    """
    使用条件判断进行元素级映射：0 -> 1.0, 1 -> -1.0
    """
    return -1.0 if random_bit_val else 1.0

@nb.vectorize
def numba_product(random_bit_val):
    """
    使用算术运算进行元素级映射：1.0 - 2.0 * val
    """
    return 1.0 - 2.0 * random_bit_val

@nb.njit
def numba_if_loop(random_bit_array):
    """
    使用Numba编译的显式循环和条件判断进行映射。
    适用于一维数组。
    """
    assert random_bit_array.ndim == 1 # 确保是一维数组
    result = np.empty_like(random_bit_array, dtype=np.float64)
    for i in range(random_bit_array.size):
        result[i] = -1.0 if random_bit_array[i] else 1.0
    return result

@nb.njit
def numba_product_loop(random_bit_array):
    """
    使用Numba编译的显式循环和算术运算进行映射。
    适用于一维数组。
    """
    assert random_bit_array.ndim == 1 # 确保是一维数组
    result = np.empty_like(random_bit_array, dtype=np.float64)
    for i in range(random_bit_array.size):
        result[i] = 1.0 - 2.0 * random_bit_array[i]
    return result

# 确保所有方法结果一致性
assert np.array_equal(np_cast(random_bit), numba_if(random_bit))
assert np.array_equal(np_cast(random_bit), numba_product(random_bit))
assert np.array_equal(np_cast(random_bit), numba_if_loop(random_bit))
assert np.array_equal(np_cast(random_bit), numba_product_loop(random_bit))

print("\n--- Numba优化方法性能测试 ---")
# 以下是模拟的%timeit输出结果，单位为微秒 (µs)
# %timeit numba_if(random_bit)
# 1.89 µs ± 25.8 ns per loop
# %timeit numba_product(random_bit)
# 2.07 µs ± 13.1 ns per loop
# %timeit numba_if_loop(random_bit)
# 1.6 µs ± 14.7 ns per loop
# %timeit numba_product_loop(random_bit)
# 1.78 µs ± 5.31 ns per loop