目录

一、原理介绍        

二、代码实现

三、结果显示

四、移植到C语言中的应用

4.1. 定义定点数配置和参数

4.2. 实现分段查找函数

4.3. 实现 log10 近似计算函数

4.4. （可选）定点数转浮点数

---

一、原理介绍        

        之前的博文对数函数分段线性实现讲解了理论方法和误差分析。这篇博文讲解其定点实现方法。

二、代码实现

import math# 定点数配置
FRACTIONAL_BITS = 16  # 小数部分位数
INTEGER_BITS = 32 - FRACTIONAL_BITS  # 整数部分位数
SCALE_FACTOR = 1 << FRACTIONAL_BITS  # 2^16 = 65536def generate_segment_points():"""生成所有分段点"""points = [0, 1, 2, 3, 4, 5, 6, 7]# 后续以2的指数为点，直到不超过4095exp = 3  # 2^3 = 8，接续7之后while True:point = 2 ** expif point > 4095:breakpoints.append(point)exp += 1# 确保最后一个点是4095if points[-1] < 4095:points.append(4095)return pointsdef float_to_fixed(value):"""将浮点数转换为定点数表示"""# 计算最大值和最小值max_val = (1 << INTEGER_BITS) - (1.0 / SCALE_FACTOR)min_val = -(1 << INTEGER_BITS)# 截断到范围内if value > max_val:value = max_valelif value < min_val:value = min_val# 转换为定点数fixed_point = int(round(value * SCALE_FACTOR))# 确保在32位有符号整数范围内if fixed_point > 0x7FFFFFFF:fixed_point = 0x7FFFFFFFelif fixed_point < -0x80000000:fixed_point = -0x80000000return fixed_pointdef fixed_to_float(fixed_value):"""将定点数转换回浮点数"""return fixed_value / SCALE_FACTORdef calculate_segments(points):"""计算每段的斜率和截距（浮点和定点）"""segments = []for i in range(len(points) - 1):x1 = points[i]x2 = points[i + 1]# 处理x=0的特殊情况（log10(0)无定义，用log10(1)代替）if x1 == 0:y1 = math.log10(1)  # log10(1) = 0else:y1 = math.log10(x1)y2 = math.log10(x2)# 计算斜率和截距（浮点）if x2 == x1:k_float = 0.0else:k_float = (y2 - y1) / (x2 - x1)b_float = y1 - k_float * x1# 转换为定点数k_fixed = float_to_fixed(k_float)b_fixed = float_to_fixed(b_float)# 还原定点数为浮点数，用于对比k_fixed_float = fixed_to_float(k_fixed)b_fixed_float = fixed_to_float(b_fixed)segments.append({'segment_id': i,'start': x1,'end': x2,# 浮点参数'k_float': k_float,'b_float': b_float,# 定点参数（整数表示）'k_fixed': k_fixed,'b_fixed': b_fixed,# 定点参数还原为浮点（用于精度参考）'k_fixed_float': k_fixed_float,'b_fixed_float': b_fixed_float})return segmentsdef main():# 生成分段点points = generate_segment_points()print(f"分段点: {points}")print(f"共{len(points)-1}段直线\n")# 计算分段参数segments = calculate_segments(points)# 输出定点数配置print("定点数配置:")print(f"总位数: 32位")print(f"整数部分: {INTEGER_BITS}位")print(f"小数部分: {FRACTIONAL_BITS}位")print(f"缩放因子: 2^{FRACTIONAL_BITS} = {SCALE_FACTOR}\n")# 显示斜率对比print("斜率(k)参数对比:")print(f"{'分段ID':<8} {'x范围':<12} {'浮点值':<18} {'定点整数值':<18} {'定点还原浮点值':<18}")print("-" * 80)for seg in segments:x_range = f"[{seg['start']}, {seg['end']}]"print(f"{seg['segment_id']:<8} {x_range:<12} {seg['k_float']:<18.10f} "f"{seg['k_fixed']:<18} {seg['k_fixed_float']:<18.10f}")# 显示截距对比print("\n截距(b)参数对比:")print(f"{'分段ID':<8} {'x范围':<12} {'浮点值':<18} {'定点整数值':<18} {'定点还原浮点值':<18}")print("-" * 80)for seg in segments:x_range = f"[{seg['start']}, {seg['end']}]"print(f"{seg['segment_id']:<8} {x_range:<12} {seg['b_float']:<18.10f} "f"{seg['b_fixed']:<18} {seg['b_fixed_float']:<18.10f}")# 生成嵌入式可用的C语言数组定义print("\n嵌入式C语言参数数组:")print("/* 分段点定义 */")print(f"const uint16_t segment_points[] = {{ {', '.join(map(str, points))} }};")print(f"const uint8_t num_segments = {len(segments)};\n")print("/* 斜率(k)定点数值组 */")k_values = [str(seg['k_fixed']) for seg in segments]print(f"const int32_t k_fixed[] = {{ {', '.join(k_values)} }};\n")print("/* 截距(b)定点数值组 */")b_values = [str(seg['b_fixed']) for seg in segments]print(f"const int32_t b_fixed[] = {{ {', '.join(b_values)} }};")if __name__ == "__main__":main()

三、结果显示

段点: [0, 1, 2, 3, 4, 5, 6, 7, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4095]
共17段直线定点数配置:
总位数: 32位
整数部分: 16位
小数部分: 16位
缩放因子: 2^16 = 65536斜率(k)参数对比:
分段ID     x范围          浮点值                定点整数值              定点还原浮点值           
--------------------------------------------------------------------------------
0        [0, 1]       0.0000000000       0                  0.0000000000      
1        [1, 2]       0.3010299957       19728              0.3010253906      
2        [2, 3]       0.1760912591       11540              0.1760864258      
3        [3, 4]       0.1249387366       8188               0.1249389648      
4        [4, 5]       0.0969100130       6351               0.0969085693      
5        [5, 6]       0.0791812460       5189               0.0791778564      
6        [6, 7]       0.0669467896       4387               0.0669403076      
7        [7, 8]       0.0579919470       3801               0.0579986572      
8        [8, 16]      0.0376287495       2466               0.0376281738      
9        [16, 32]     0.0188143747       1233               0.0188140869      
10       [32, 64]     0.0094071874       617                0.0094146729      
11       [64, 128]    0.0047035937       308                0.0046997070      
12       [128, 256]   0.0023517968       154                0.0023498535      
13       [256, 512]   0.0011758984       77                 0.0011749268      
14       [512, 1024]  0.0005879492       39                 0.0005950928      
15       [1024, 2048] 0.0002939746       19                 0.0002899170      
16       [2048, 4095] 0.0001470073       10                 0.0001525879      截距(b)参数对比:
分段ID     x范围          浮点值                定点整数值              定点还原浮点值           
--------------------------------------------------------------------------------
0        [0, 1]       0.0000000000       0                  0.0000000000      
1        [1, 2]       -0.3010299957      -19728             -0.3010253906     
2        [2, 3]       -0.0511525224      -3352              -0.0511474609     
3        [3, 4]       0.1023050449       6705               0.1023101807      
4        [4, 5]       0.2144199393       14052              0.2144165039      
5        [5, 6]       0.3030637741       19862              0.3030700684      
6        [6, 7]       0.3764705126       24672              0.3764648438      
7        [7, 8]       0.4391544112       28780              0.4391479492      
8        [8, 16]      0.6020599913       39457              0.6020660400      
9        [16, 32]     0.9030899870       59185              0.9030914307      
10       [32, 64]     1.2041199827       78913              1.2041168213      
11       [64, 128]    1.5051499783       98642              1.5051574707      
12       [128, 256]   1.8061799740       118370             1.8061828613      
13       [256, 512]   2.1072099696       138098             2.1072082520      
14       [512, 1024]  2.4082399653       157826             2.4082336426      
15       [1024, 2048] 2.7092699610       177555             2.7092742920      
16       [2048, 4095] 3.0102589912       197280             3.0102539062      嵌入式C语言参数数组:
/* 分段点定义 */
const uint16_t segment_points[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4095 };
const uint8_t num_segments = 17;/* 斜率(k)定点数值组 */
const int32_t k_fixed[] = { 0, 19728, 11540, 8188, 6351, 5189, 4387, 3801, 2466, 1233, 617, 308, 154, 77, 39, 19, 10 };/* 截距(b)定点数值组 */
const int32_t b_fixed[] = { 0, -19728, -3352, 6705, 14052, 19862, 24672, 28780, 39457, 59185, 78913, 98642, 118370, 138098, 157826, 177555, 197280 };

四、移植到C语言中的应用

4.1. 定义定点数配置和参数

首先在 C 文件中定义定点数配置（需与 Python 中一致）和从 Python 复制的参数：

#include <stdint.h>  // 用于uint16_t、int32_t等类型// 定点数配置（必须与Python代码中的设置一致）
#define FRACTIONAL_BITS 16  // 小数部分位数（与Python的FRACTIONAL_BITS相同）
#define SCALE_FACTOR (1 << FRACTIONAL_BITS)  // 2^16 = 65536// 从Python输出复制的分段参数
const uint16_t segment_points[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4095};
const uint8_t num_segments = sizeof(segment_points) / sizeof(segment_points[0]) - 1;const int32_t k_fixed[] = {28961,   // 第0段斜率（示例值，需替换为Python输出）13230,   // 第1段斜率// ... 其他分段的k值146      // 最后一段斜率
};const int32_t b_fixed[] = {0,       // 第0段截距（示例值，需替换为Python输出）-15731,  // 第1段截距// ... 其他分段的b值196602   // 最后一段截距
};

4.2. 实现分段查找函数

根据输入 x（0~4095），找到对应的分段索引（即使用哪组 k 和 b）：

/*** 查找x所属的分段索引* 参数：x - 输入值（0~4095）* 返回：分段索引（0 ~ num_segments-1）*/
static uint8_t find_segment(uint16_t x) {// 遍历分段点，找到x所在的区间for (uint8_t i = 0; i < num_segments; i++) {if (x >= segment_points[i] && x <= segment_points[i + 1]) {return i;}}return num_segments - 1;  // 兜底（x=4095）
}

4.3. 实现 log10 近似计算函数

利用找到的分段参数（k 和 b），通过定点数运算计算 log10 (x) 的近似值：

/*** 计算log10(x)的近似值（定点数输出）* 参数：x - 输入值（0~4095，整数）* 返回：log10(x)的定点数表示（精度：FRACTIONAL_BITS位小数）*/
int32_t log10_approx(uint16_t x) {if (x == 0) {return 0;  // 特殊处理x=0（log10(0)无定义，返回0）}// 1. 查找x所属的分段uint8_t seg_idx = find_segment(x);  // 或使用find_segment_fast// 2. 取出该分段的k和b（定点数）int32_t k = k_fixed[seg_idx];int32_t b = b_fixed[seg_idx];// 3. 定点数运算：y = k * x + b（需处理小数位对齐）// x是整数，先转换为定点数（x << FRACTIONAL_BITS）int64_t x_fixed = (int64_t)x << FRACTIONAL_BITS;  // 扩展为64位避免乘法溢出// 计算k * x：结果小数位为FRACTIONAL_BITS*2，右移FRACTIONAL_BITS位对齐int64_t product = (k * x_fixed) >> FRACTIONAL_BITS;// 加上截距b（已为定点数，直接相加）int64_t y_fixed = product + b;// 4. 截断为32位（防止溢出）if (y_fixed > INT32_MAX) {return INT32_MAX;} else if (y_fixed < INT32_MIN) {return INT32_MIN;} else {return (int32_t)y_fixed;}
}

4.4. （可选）定点数转浮点数

若需要将结果转换为浮点数（如用于显示或上层计算）：

/*** 将定点数结果转换为浮点数* 参数：fixed_val - log10_approx返回的定点数* 返回：对应的浮点数*/
float fixed_to_float(int32_t fixed_val) {return (float)fixed_val / SCALE_FACTOR;
}