如何高效计算CoolFlux BSP32累加器小数部分的高精度十进制值？

我正在编写基于CoolFlux BSP32的C程序，功能是接收累加器输入并输出其十进制值。例如，当累加器的十六进制值为FF C000 0000时，需输出-1.5。要求小数部分的计算误差小于10^(-9)，因此需使用累加器小数部分的30位。

我尝试通过逐位判断的方式计算小数部分：若1/2^current_index可在30位精度下对应到整数（即10^9/2^current_index为整数），则直接累加该值；若不可表示，则使用近似值((10^9/2^(current_index-1))-1)/2。当前实现可行但代码冗余、效率较低，请问更高效的实现方式是什么？

当前实现代码 #

#include"cf6_chess.h"
#include"CoolFlux_defs.h"
#include<stdio.h>

void printf_acc(acc x)
{
    fix h;
    h = extract_high(x << 1);
    int32 fractionalPart; // 存储小数部分对应的整数（代表10^9倍的小数）
    fractionalPart = 0;
    if(h < 0) // 检查最高位是否为1
    {
        fractionalPart = 500000000;
    }
    h <<= 1;
    if(h < 0)
    {
        fractionalPart += 250000000;
    }
    h <<= 1;
    if(h < 0)
    {
        fractionalPart += 125000000;
    }
    h <<= 1;
    if(h < 0)
    {
        fractionalPart += 62500000;
    }
    h <<= 1;
    if(h < 0)
    {
        fractionalPart += 31250000;
    }
    h <<= 1;
    if(h < 0)
    {
        fractionalPart += 15625000;
    }
    h <<= 1;
    if(h < 0)
    {
        fractionalPart += 7812500;
    }
    h <<= 1;
    if(h < 0)
    {
        fractionalPart += 3906250;
    }
    h <<= 1;
    if(h < 0)
    {
        fractionalPart += 1953125;
    }
    h <<= 1;
    if(h < 0)
    {
        fractionalPart += 976562;
    }
    h <<= 1;
    if(h < 0)
    {
        fractionalPart += 488281;
    }
    h <<= 1;
    if(h < 0)
    {
        fractionalPart += 244140;
    }
    h <<= 1;
    if(h < 0)
    {
        fractionalPart += 122070;
    }
    h <<= 1;
    if(h < 0)
    {
        fractionalPart += 61035;
    }
    h <<= 1;
    if(h < 0)
    {
        fractionalPart += 30517;
    }
    h <<= 1;
    if(h < 0)
    {
        fractionalPart += 15258;
    }
    fix low;
    low = extract_low(x << 1);
    if(low < 1)
    {
        fractionalPart += 7629;
    }
    low <<= 1;
    if(low < 1)
    {
        fractionalPart += 3814;
    }
    low <<= 1;
    if(low < 1)
    {
        fractionalPart += 1907;
    }
    low <<= 1;
    if(low < 1)
    {
        fractionalPart += 953;
    }
    low <<= 1;
    if(low < 1)
    {
        fractionalPart += 476;
    }
    low <<= 1;
    if(low < 1)
    {
        fractionalPart += 238;
    }
    low <<= 1;
    if(low < 1)
    {
        fractionalPart += 119;
    }
    low <<= 1;
    if(low < 1)
    {
        fractionalPart += 59;
    }
    low <<= 1;
    if(low < 1)
    {
        fractionalPart += 29;
    }
    low <<= 1;
    if(low < 1)
    {
        fractionalPart += 14;
    }
    low <<= 1;
    if(low < 1)
    {
        fractionalPart += 7;
    }
    low <<= 1;
    if(low < 1)
    {
        fractionalPart += 3;
    }
    low <<= 1;
    if(low < 1)
    {
        fractionalPart += 1;
    }
    int32 integerPart;
    integerPart = (extract_ovf(x) << 1) + (extract_ovf(x << 1) & 1);
    if(fractionalPart == 0)
    {
        printf("%i",integerPart);
        return;
    }
    else
    {
        if(integerPart < 0)
        {
            integerPart += 1;
            fractionalPart = 1000000000 - fractionalPart;
        }
    }
    // 未实现去除小数部分末尾零的逻辑
    printf("%i.%i\n",integerPart,fractionalPart);
}

void main()
{
    printf_acc(0.75);
}

更高效的实现方式 #

1. 预计算系数表+循环处理 #

将每个二进制位对应的10^9/2^n近似值（取整到最接近的整数，保证误差≤1e-9）预存到数组中，然后循环提取累加器的每一位，对应累加系数表中的值。这种方式大幅减少代码冗余，且循环比大量独立if语句更高效。

示例代码片段：

// 预计算30位对应的系数（1e9/2^1 到 1e9/2^30的近似整数值）
const int32_t frac_coeffs[30] = {
    500000000, 250000000, 125000000, 62500000, 31250000,
    15625000, 7812500, 3906250, 1953125, 976562,
    488281, 244140, 122070, 61035, 30517,
    15258, 7629, 3814, 1907, 953,
    476, 238, 119, 59, 29,
    14, 7, 3, 1, 0
};

void printf_acc(acc x) {
    int32_t fractionalPart = 0;
    fix h = extract_high(x << 1);
    // 处理高16位中的前16个小数位
    for(int i = 0; i < 16; i++) {
        if(h < 0) {
            fractionalPart += frac_coeffs[i];
        }
        h <<= 1;
    }
    // 处理低16位中的后14个小数位（总共30位）
    fix low = extract_low(x << 1);
    for(int i = 16; i < 30; i++) {
        if(low < 1) {
            fractionalPart += frac_coeffs[i];
        }
        low <<= 1;
    }
    // 整数部分处理和原逻辑一致，省略...
}

2. 整数乘法+移位（最高效方案） #

小数部分本质是一个30位的二进制分数，可将其转换为整数frac_int（即小数部分乘以2^30），然后通过fractionalPart = (frac_int * 1000000000LL) >> 30直接计算出1e9倍的小数部分。这种方式仅需一次64位乘法和移位，效率远高于逐位判断。

示例代码片段：

void printf_acc(acc x) {
    // 提取整数部分（保留原逻辑）
    int32_t integerPart = (extract_ovf(x) << 1) + (extract_ovf(x << 1) & 1);
    uint64_t frac_int = 0;

    // 提取30位小数部分：高16位 + 低14位
    fix h = extract_high(x << 1);
    frac_int |= ((uint32_t)(h & 0xFFFF)) << 14; // 高16位左移14位，占30位的前16位
    fix low = extract_low(x << 1);
    frac_int |= (uint32_t)(low >> 2); // 低16位右移2位，取后14位

    // 计算1e9倍的小数部分：(frac_int * 1e9) / 2^30
    uint64_t fractional_scaled = (frac_int * 1000000000LL) >> 30;
    int32_t fractionalPart = (int32_t)fractional_scaled;

    // 负数处理逻辑调整
    if(integerPart < 0) {
        fractionalPart = 1000000000 - fractionalPart;
        integerPart += 1;
    }

    // 输出逻辑
    if(fractionalPart == 0) {
        printf("%i", integerPart);
    } else {
        printf("%i.%09i\n", integerPart, fractionalPart); // 补前导零保证9位小数精度
    }
}

3. 利用CoolFlux硬件特性优化 #

CoolFlux BSP32支持特殊的累加器操作指令，可以直接提取小数部分的整数值，或进行64位乘法操作，进一步提升效率。比如使用SDK提供的extract_acc_frac类指令直接获取30位小数部分的整数表示，避免手动拼接高、低寄存器。

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