对数函数分段定点实现
目录
一、原理介绍
二、代码实现
三、结果显示
四、移植到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;
}