C++与Python同代码循环后浮点计算结果差异排查

核心问题 #

实现了逻辑和变量一致的C++与Python驾驶员模型，基于仿真输出的宽度、位置、速度等数据判断是否需要制动，但循环500次后结果出现分歧，最终制动响应完全不同。已知两种语言均遵循IEEE 754浮点标准，疑惑该问题是否源于浮点知识遗漏或代码错误，预期两个模型的制动响应完全一致。

代码差异与错误分析 #

1. 明显的代码逻辑不一致 #

（1）vTheta核心计算差异

• 原始代码中，C与Python的vTheta计算逻辑一致：
  C: vTheta = 2.0 * std::atan(targetWidth / (2.0 * prevDistEgoToTarget));
  Python: self.vTheta = 2.0*arctan(targetWidth/(2.0*self.prevDistEgoToTarget))
• 但最小可复现代码中出现严重不一致：
  C++: vTheta = 2.0* std::atan2(width,distEgoToTarget);（使用当前帧的distEgoToTarget）
  Python: self.vTheta = 2.0*arctan2(width,2.0*self.prevDistEgoToTarget)（使用上一帧prevDistEgoToTarget的2倍值）
  这直接导致vTheta的计算基础完全不同，是结果分歧的核心原因。

（2）变量计算顺序错误

Python代码中self.vEpsilon的计算早于self.vp的更新：

self.vTheta = 2.0*arctan2(width,2.0*self.prevDistEgoToTarget)
self.vEpsilon = self.vp -self.vpp  # 此时self.vp为上一帧的值
self.vThetaDot = (self.vTheta - prevVTheta)/self.timestep
self.vp = self.vThetaDot/self.vTheta  # 才更新当前帧的vp

而C++代码中vEpsilon的计算在vp更新之后：

vTheta = 2.0* std::atan2(width,distEgoToTarget);
vThetaDot = (vTheta-prevVTheta)/timestep;
vp = vThetaDot/vTheta;  # 先更新当前帧的vp
prevDistEgoToTarget = distEgoToTarget;
vEpsilon = vp -vpp;  # 再计算当前帧的vEpsilon

这导致Python的vEpsilon始终使用上一帧的vp，与C++逻辑完全不符。

（3）C++语法错误

原始C++代码中日志判断使用赋值语句而非比较：

if (log = true)  // 错误：将log赋值为true，而非判断log是否为true

正确写法应为：

if (log == true)

2. 浮点计算的潜在差异 #

即使遵循IEEE 754标准，仍可能存在以下细微差异：

• 数学库实现细节：不同语言的标准库对atan/atan2等函数的实现可能存在精度优化、舍入方式的细微差别，多次迭代后误差会被放大。
• 变量初始化：prevDistEgoToTarget初始值为NaN，第一次循环计算vTheta时会得到NaN，后续所有计算都会受影响，需为初始帧设置合理的初始距离值。

修复建议 #

1. 统一核心计算逻辑 #

确保vTheta的计算在两种语言中完全一致，以原始代码逻辑为准：

• C++：

  vTheta = 2.0 * std::atan(targetWidth / (2.0 * prevDistEgoToTarget));
  

• Python：

  self.vTheta = 2.0 * math.atan(targetWidth / (2.0 * self.prevDistEgoToTarget))
  

若改用atan2，需保证参数和公式一致（C++与Python的atan2参数均为(y, x)）：

vTheta = 2.0 * std::atan2(targetWidth / 2.0, prevDistEgoToTarget);

self.vTheta = 2.0 * math.atan2(targetWidth / 2.0, self.prevDistEgoToTarget)

2. 同步变量计算顺序 #

将Python中vEpsilon的计算移到vp更新之后：

# 先更新vp
self.vThetaDot = (self.vTheta - prevVTheta)/self.timestep
self.vp = self.vThetaDot/self.vTheta 
# 再计算vEpsilon
self.vEpsilon = self.vp - self.vpp

3. 修复语法错误与初始化问题 #

• 修正C++的日志判断语句为if (log == true)。
• 为prevDistEgoToTarget、vpp、accuK、accuM、accuC等变量设置合理的初始值，避免NaN影响计算。

完整修正后的最小可复现代码示例 #

Python修正版 #

from math import atan
from csv import DictReader


class DM():
    def __init__(self):
        self.vTheta: float = 0.0  # 设置合理初始值
        self.vThetaDot: float = 0.0
        self.prevDistEgoToTarget: float = 100.0  # 初始距离，根据仿真场景调整
        self.timestep: float = 0.01
        self.vpp: float = 0.0  # 设置合理初始值
        self.vp: float = 0.0
        self.accuK: float = 1.0  # 需与C++参数一致
        self.accuM: float = 0.1
        self.accuC: float = 0.05
        self.vActivation: float = 0.0

    def runAccumulator(self, data):
            prevVTheta = self.vTheta
            prevVActivation = self.vActivation
            
            length = 5.4
            width = 2.0

            # 计算位置数据
            targetPosRear = float(data["targetPosX"]) - length/2.0
            egoPosFront = float(data["egoPosX"]) + length/2.0
            distEgotoTarget = targetPosRear - egoPosFront

            # 计算光学尺寸与 looming
            self.vTheta = 2.0 * atan(width / (2.0 * self.prevDistEgoToTarget))
            self.vThetaDot = (self.vTheta - prevVTheta)/self.timestep
            self.vp = self.vThetaDot/self.vTheta 
            self.vEpsilon = self.vp - self.vpp
            self.prevDistEgoToTarget = distEgotoTarget
            
            activationChange = (self.accuK * self.vEpsilon - self.accuM - self.accuC * prevVActivation) * self.timestep
            self.vActivation = max(0.0, prevVActivation + activationChange)
            print(self.vp)


def main():
    with open("../log/sample.csv", 'r') as f:
        dictReader = DictReader(f)     
        listOfDict = list(dictReader)
    
    dm = DM()
    for i in range(min(700, len(listOfDict))):
        dm.runAccumulator(listOfDict[i])

if __name__ == "__main__":
    main()

C++修正版 #

#include <limits>
#include <cmath>
#include <fstream>
#include <sstream>
#include <iostream>
#include <vector>

class DM
{
private:
    double accuK = 1.0;  // 与Python一致的参数
    double accuM = 0.1;
    double accuC = 0.05;
    double vpp = 0.0;
    double vActivation = 0.0;
public:
    DM();
    ~DM();
    double vTheta = 0.0;  // 设置合理初始值
    double vThetaDot = 0.0;
    double prevDistEgoToTarget = 100.0;  // 初始距离，与Python一致
    double timestep = 0.01;
    double vp = 0.0;
    void runAccumulator(std::vector<std::string> data);

    std::ifstream sampleCSV;
    void readFileIntoString(const std::string& path);
};

DM::DM()
{
}

DM::~DM()
{
}

void DM::runAccumulator(std::vector<std::string> data)
{
    double prevVTheta = vTheta;
    double prevVActivation = vActivation;
    double length = 5.4;
    double width = 2.0;

    // 计算位置数据
    double targetPosX = stod(data[3]);
    double targetPosRear = targetPosX - length/2.0;
    double egoPosX = stod(data[2]);
    double egoPosFront = egoPosX + length/2.0;
    double distEgoToTarget = targetPosRear - egoPosFront;

    // 计算光学尺寸与 looming，与Python逻辑一致
    vTheta = 2.0 * std::atan(width / (2.0 * prevDistEgoToTarget));
    vThetaDot = (vTheta - prevVTheta)/timestep;
    vp = vThetaDot/vTheta;
    double vEpsilon = vp - vpp;
    prevDistEgoToTarget = distEgoToTarget;
    
    auto activationChange = (accuK * vEpsilon - accuM - accuC * prevVActivation) * timestep;
    vActivation = std::max(0.0, prevVActivation + activationChange);
    std::cout << vp << std::endl;
}

void DM::readFileIntoString(const std::string& path)
{
    sampleCSV.open(path);
    if (!sampleCSV.is_open()) {
        std::cerr << "Could not open the file - '" << path << "'" << std::endl;
        exit(EXIT_FAILURE);
    }
    std::string temp;
    getline(sampleCSV, temp);
}

std::vector<std::string> split (std::string s, std::string delimiter) {
    size_t pos_start = 0, pos_end, delim_len = delimiter.length();
    std::string token;
    std::vector<std::string> res;

    while ((pos_end = s.find(delimiter, pos_start)) != std::string::npos) {
        token = s.substr(pos_start, pos_end - pos_start);
        pos_start = pos_end + delim_len;
        res.push_back(token);
    }
    res.push_back(s.substr(pos_start));
    return res;
}

int main(int argc, char const *argv[])
{
    DM dm;
    dm.readFileIntoString("../log/sample.csv");
    std::string buffer;
    std::vector<std::string> linevec;
    
    for (size_t i = 0; i < 700; i++)
    {
        if (!getline(dm.sampleCSV, buffer)) break;
        linevec = split(buffer, ",");
        dm.runAccumulator(linevec);
    }
    return 0;
}

仿真数据CSV（sample.csv） #

timestamp,egoSpeed,egoPosX,targetPosX,targetSpeed
0.01,20.0,0.0,100.0,20.0
0.02,20.0,0.2,100.2,20.0
0.03,20.0,0.4,100.4,20.0
0.04,20.0,0.6,100.6,20.0
0.05,20.0,0.8,100.8,20.0
0.06,20.0,1.0,101.0,20.0
0.07,20.0,1.2,101.2,20.0
0.08,20.0,1.4,101.4,20.0
0.09,20.0,1.6,101.6,20.0
0.1,20.0,1.8,101.8,20.0
# 剩余数据可根据实际仿真场景补充

总结 #

结果分歧的主要原因是代码逻辑不一致（公式差异、计算顺序错误），而非IEEE 754标准的差异。修复上述问题后，两个模型的计算结果会趋于一致；若仍存在细微浮点误差，可通过设置合理的误差容忍阈值（如判断差值是否小于1e-6）来处理迭代过程中的累积误差。

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