Python中如何实现固定位宽的二进制定点运算？

可行方案说明 #

1. 手动实现自定义定点运算类 #

核心思路是将定点数转换为整数存储（通过2^n缩放，n为小数位），所有运算基于整数执行，运算后强制保持固定的整数位m和小数位n，同时处理溢出。

示例实现（支持加法，可扩展其他运算）：

class FixedBinary:
    def __init__(self, value, m, n):
        self.m = m  # 固定整数位数
        self.n = n  # 固定小数位数
        self.scale = 1 << n  # 缩放因子：2^n
        # 转换为定点整数表示
        self.value = int(round(value * self.scale))
        # 计算位宽对应的取值范围（有符号）
        self.max_val = (1 << (m + n)) - 1
        self.min_val = - (1 << (m + n - 1))
        self._clamp()

    def _clamp(self):
        # 饱和处理溢出：超出范围则取边界值
        if self.value > self.max_val:
            self.value = self.max_val
        elif self.value < self.min_val:
            self.value = self.min_val

    def __add__(self, other):
        if self.m != other.m or self.n != other.n:
            raise ValueError("仅支持相同m、n参数的定点数运算")
        result = FixedBinary(0, self.m, self.n)
        result.value = self.value + other.value
        result._clamp()
        return result

    def __repr__(self):
        # 转换回浮点数格式展示
        return f"FixedBinary({self.value / self.scale}, m={self.m}, n={self.n})"

测试代码：

a = FixedBinary(1, m=2, n=1)
print(a.m)  # 输出：2
b = a + a + a
print(b.m)  # 输出：2（保持固定位宽）
print(b)    # 输出：FixedBinary(3.0, m=2, n=1)

优势：完全自定义位宽规则，溢出处理（饱和/截断）可按需调整，无需依赖第三方包的限制。
不足：需要自行实现所有运算逻辑（减法、乘法、除法、比较等），初期开发量较大。

2. 修改fixedpoint包的运算逻辑 #

如果希望基于现有fixedpoint包快速实现，可以修改其运算方法，强制结果的m和n与输入保持一致。

例如找到fixedpoint.py中的加法方法（__add__），原逻辑会自动计算新的m和n，将其改为使用self.m和self.n，并添加溢出处理逻辑即可。

优势：基于成熟包修改，减少重复开发。
不足：依赖包的版本兼容性，后续包升级可能需要重新修改。

3. 基于numpy实现批量定点运算 #

如果需要处理批量数据，可利用numpy的整数类型结合缩放因子实现，通过向量化运算提升效率。核心逻辑与手动实现类似，但借助numpy的广播和数组运算简化代码。

示例框架：

import numpy as np

class NumpyFixedBinary:
    def __init__(self, values, m, n):
        self.m = m
        self.n = n
        self.scale = 1 << n
        self.values = np.round(values * self.scale).astype(np.int16)  # 选择合适的整数类型
        self.max_val = (1 << (m + n)) - 1
        self.min_val = - (1 << (m + n - 1))
        self._clamp()

    def _clamp(self):
        self.values = np.clip(self.values, self.min_val, self.max_val)

    def __add__(self, other):
        if self.m != other.m or self.n != other.n:
            raise ValueError("仅支持相同m、n参数的定点数运算")
        result = NumpyFixedBinary(np.array([]), self.m, self.n)
        result.values = self.values + other.values
        result._clamp()
        return result

优势：适合大规模数据运算，效率高于纯Python实现。
不足：需要熟悉numpy操作，同样需要处理溢出和位宽限制。

内容的提问来源于stack exchange，提问作者flobue