为什么0.1 + 0.2 ≠ 0.3?图解浮点数精度陷阱与实战避坑指南

从JavaScript的0.1+0.2≠0.3说起:手把手图解IEEE754舍入模式与精度陷阱 本文深入解析JavaScript中0.1+0.2≠0.3的现象,揭示IEEE754浮点数标准的舍入模式与精度陷阱。通过二进制视角和可视化工具,详细讲解四种舍入模式及其应用场景,并提供前端开发中的实用解决方案,如整数放大法和专业库decimal.js的使用。 阅读详情

为什么0.1 + 0.2 ≠ 0.3?图解浮点数精度陷阱与实战避坑指南

那天下午,团队里负责支付结算模块的小王急匆匆地跑过来,指着屏幕上的一行代码问我:“老大,你看这个,用户充值了30块钱,系统显示账户余额是29.999999999999996,客户投诉了,这到底是怎么回事?” 我凑过去一看,果然,一个简单的 0.1 + 0.2 的加法运算,在JavaScript的控制台里输出了那个令人哭笑不得的结果。这绝不是代码逻辑错误,而是几乎每一位开发者,无论是前端、后端还是算法工程师,在职业生涯中迟早都会迎面撞上的“幽灵”——浮点数精度问题。它悄无声息地潜伏在金融交易、游戏物理引擎、科学计算乃至任何涉及小数的场景中,轻则导致界面显示异常,重则引发资金结算错误、物理模拟失真等严重事故。理解它,不仅是解决一个技术谜题,更是构建健壮、可靠软件系统的必修课。本文将从最底层的二进制存储原理出发,结合大量图示和实战案例,为你彻底拆解浮点数精度的来龙去脉,并提供一套从理论到实践的完整避坑方案。

1. 二进制视角:当“完美”的十进制遭遇“有限”的二进制

我们人类习惯的十进制系统,是一种基于10的幂次方的计数法。任何一个十进制小数,理论上都可以表示为一系列以10为底的分数的和。例如,0.75 可以表示为 7/10 + 5/100。然而,计算机的硬件基础是晶体管,其天然状态是“开”或“关”,这直接决定了计算机内部使用二进制(基数为2)来表示一切数据。

1.1 小数在二进制中的“尴尬”处境

当我们尝试将一个简单的十进制小数,比如0.1,转换为二进制时,麻烦就开始了。这个过程类似于十进制转二进制整数,但方向是向右的小数部分。

转换规则是不断乘以2,取整数部分作为二进制位,然后用小数部分继续:

  1. 0.1 * 2 = 0.2 → 整数部分 0
  2. 0.2 * 2 = 0.4 → 整数部分 0
  3. 0.4 * 2 = 0.8 → 整数部分 0
  4. 0.8 * 2 = 1.6 → 整数部分 1, 小数部分变为 0.6
  5. 0.6 * 2 = 1.2 → 整数部分 1, 小数部分变为 0.2
  6. 0.2 * 2 = 0.4 → 整数部分 0
  7. ...

你会发现,从小数点后第2位开始,计算进入了“0011”的无限循环:0.0001100110011...。0.1在二进制中是一个无限循环小数。同理,0.2的二进制表示是0.001100110011...,也是一个无限循环小数。

提示:你可以把这个过程想象成试图用1/2、1/4、1/8、1/16……这些分数来拼凑出0.1这个值。无论你怎么组合,都无法得到精确的0.1,总会有一点点误差。

1.2 IEEE 754:为“无限”戴上“有限”的枷锁

计算机的内存是有限的,不可能存储一个无限长的二进制序列。为了解决这个问题,IEEE 754标准应运而生。它就像一份全球通用的“协议”,规定了如何在有限的存储空间(通常是32位或64位)内,近似地表示实数。

浮点数的核心思想是“科学计数法”。在十进制中,123.456可以写成1.23456 × 10²。IEEE 754采用了类似的二进制科学计数法:(-1)^符号位 × 有效数字 × 2^指数。

以最常见的单精度(32位,float)和双精度(64位,double)为例,它们的存储结构如下:

组成部分单精度 (float)双精度 (double)说明
符号位 (Sign)1 位1 位0表示正数,1表示负数
指数位 (Exponent)8 位11 位存储的是经过“偏移”后的指数值
尾数位/有效数字 (Mantissa/Significand)23 位52 位存储科学计数法中“1.xxx”的小数部分(xxx)

这个设计非常巧妙:

  • 符号位独立处理正负。
  • 指数位使用“偏移表示法”(例如float的偏移量是127)。这避免了用补码表示有符号指数带来的比较复杂度,使得浮点数可以直接按位比较大小(在符号相同的情况下)。
  • 尾数位存储的是规格化后“1.xxx”中的“xxx”部分。因为规格化后,整数部分总是1(除了非规格化数),所以这个“隐藏的1”可以省下来一位,用于提高精度。

现在,让我们把0.1这个无限循环的二进制小数0.0001100110011...,塞进这个有限的“盒子”里。过程是:

  1. 规格化:将其写成 1.1001100110011... × 2^(-4)。
  2. 指数部分:-4 + 127(偏移量)= 123,转换为8位二进制 01111011。
  3. 尾数部分:取1.后面的23位 10011001100110011001101(注意,第24位是1,需要向第23位进位,这就是舍入操作)。

最终,0.1在计算机中存储的float值,已经是原始无限循环二进制数的一个舍入近似值。0.2也经历了同样的“舍入之痛”。当计算机把它们从内存中取出做加法时,它操作的是这两个已经存在误差的近似值。结果自然也是一个近似值,而这个近似值在转回十进制显示时,就变成了我们看到的 0.30000000000000004(对于双精度)或 0.30000001192092896(对于单精度)。

# 一个简单的Python演示,展示0.1的二进制近似本质
import struct

def float_to_bin(f):
    """将float转换为32位二进制表示"""
    packed = struct.pack('!f', f)  # 使用网络字节序打包
    integers = [c for c in packed]
    binary = ''.join(f'{i:08b}' for i in integers)
    # 按符号(1位)、指数(8位)、尾数(23位)分隔显示
    return f"{binary[0]} {binary[1:9]} {binary[9:]}"

print("0.1在内存中的实际存储(IEEE 754 float):")
print(float_to_bin(0.1))
print("\n尝试用这个存储值反向计算:")
# 手动解析:符号位0,指数位01111011(123),尾数位10011001100110011001101
# 实际值 = (-1)^0 * (1 + 尾数十进制值) * 2^(指数-127)
# 你会发现,它不等于精确的0.1

2. 精度陷阱的“案发现场”:从电商到游戏的实战翻车录

理解了原理,我们再来看看这些微小的误差是如何在真实项目中“搞出大事情”的。误差本身很小,但在特定场景下经过累积、比较或条件判断,就会被急剧放大。

2.1 金融与电商:一分钱难倒英雄汉

这是最经典也最危险的场景。任何涉及货币计算的地方,精度误差都是不可接受的。

  • 场景一:订单金额计算 假设一个商品单价0.1元,用户购买3个。理想计算是0.3元。

    // JavaScript (使用默认的Number类型,即双精度浮点数)
    let unitPrice = 0.1;
    let quantity = 3;
    let total = unitPrice * quantity; // 结果是 0.30000000000000004
    console.log(total === 0.3); // false
    

    如果后端用浮点数做同样的计算,并在数据库里存储这个0.30000000000000004,而在显示时四舍五入到两位小数,可能暂时看不出问题。但一旦涉及等值比较(如判断用户支付金额是否等于订单金额),或者作为条件判断(如if (change > 0)找零),bug就会爆发。

  • 场景二:费率累计与分账 在涉及多级分润、手续费累加的场景中,每个环节微小的舍入误差会像滚雪球一样累积。

    # 假设一个简单的分账模型:平台收1%手续费
    amount = 100.0  # 交易金额100元
    fee_rate = 0.01
    # 理论上手续费是1元,卖家得99元
    calculated_fee = amount * fee_rate  # 可能是 1.0000000000000007
    seller_get = amount - calculated_fee # 可能是 98.99999999999993
    # 如果系统以“分”为单位入账,四舍五入后可能导致平台多收1分,卖家少得1分。
    

    日积月累,账目必然对不上,审计时就是一场灾难。

2.2 游戏与图形:失之毫厘,谬以千里

在需要高精度模拟物理世界的游戏中,浮点数误差会导致诡异的现象。

  • 场景一:角色移动与碰撞检测

    // Unity C# 示例(虽然Unity的Vector3等封装了部分比较,但底层仍是float)
    float playerSpeed = 5.0f;
    float deltaTime = 0.016f; // 约60FPS
    Vector3 playerPosition = transform.position;
    
    // 每帧移动
    playerPosition.x += playerSpeed * deltaTime; // 理论上移动0.08单位
    
    // 判断是否到达某个边界,比如 x >= 10.0
    if (playerPosition.x >= 10.0f) {
        StopMoving();
    }
    

    由于误差累积,playerPosition.x可能永远无法精确等于或大于10.0,而是在9.999999附近徘徊,导致角色卡在边界前。更常见的是在判断两个浮点数是否相等时:

    if (playerPosition.y == 0.0f) { // 几乎永远不会为真!
        PlayLandingSound();
    }
    
  • 场景二:物理引擎稳定性 物理引擎进行数值积分计算时,大量浮点运算的误差累积可能导致能量不守恒(物体无故加速)、约束求解失败(关节抖动、穿透)等。早期一些游戏里物体“鬼畜”抖动或飞出天际,部分原因就源于此。

2.3 算法与科学计算:结果可信吗?

在机器学习、数值分析、仿真等领域,浮点数误差可能直接导致算法失效或结论错误。

  • 矩阵求逆与病态问题:当矩阵条件数很大时,微小的输入误差或舍入误差会被放大,导致求逆结果完全失真。
  • 迭代算法收敛:很多优化算法(如梯度下降)依靠数值梯度或函数值变化来判断收敛。如果因为精度问题导致判断失误,可能过早停止迭代或无法收敛。
  • 几何计算:计算两条线是否平行、三个点是否共线时,直接使用==比较浮点结果必然失败。

3. 见招拆招:浮点数比较与运算的“安全守则”

既然无法消除误差,我们就必须学会与它安全共处。核心原则就一条:永远不要直接使用 == 或 != 来比较两个浮点数是否相等。

3.1 绝对误差与相对误差:如何定义“足够接近”

我们需要一个“容忍度”,来判断两个浮点数是否“在误差范围内相等”。常用两种方法:

  1. 绝对误差 (Absolute Epsilon) 适用于已知数值范围的比较,尤其是数值接近0的情况。

    def is_equal_abs(a, b, epsilon=1e-12):
        return abs(a - b) < epsilon
    
    # 示例:比较两个接近0的值
    a = 1e-30
    b = 2e-30
    print(is_equal_abs(a, b, 1e-29)) # True,因为绝对差1e-30 < 1e-29
    

    缺点:对于很大数值不适用。比如比较1e10和1e10+1,绝对差是1,如果epsilon=1e-12会认为不相等,但相对误差极小。

  2. 相对误差 (Relative Epsilon) 考虑了数值本身的尺度,更通用。

    def is_equal_rel(a, b, epsilon=1e-9):
        if a == b: # 快速路径,包括处理inf和NaN
            return True
        # 避免除以零,取绝对值较大的作为分母
        denominator = max(abs(a), abs(b))
        # 如果两个数都非常接近0,则回退到绝对误差检查
        if denominator < epsilon:
            return abs(a - b) < epsilon
        return abs(a - b) / denominator < epsilon
    
    # 示例:能很好地处理不同数量级的数
    print(is_equal_rel(1000.0, 1000.000000001)) # True
    print(is_equal_rel(1e-10, 2e-10)) # False (相对误差很大)
    

在实际开发中,许多语言的标准库或数学库都提供了类似的函数。例如,在C++中可以使用 std::fabs(a - b) < std::numeric_limits<double>::epsilon()(注意,这里的epsilon是机器精度,通常需要放大使用)。在Python中,math.isclose()函数是首选。

import math
# Python 的 math.isclose 综合了绝对容差和相对容差
print(math.isclose(0.1 + 0.2, 0.3)) # True
print(math.isclose(1000.0, 1000.000000001)) # True
# 你可以自定义容差
print(math.isclose(0.1 + 0.2, 0.3, rel_tol=1e-9, abs_tol=0.0))

3.2 运算优化:减少误差累积的战术

除了比较,在运算过程中也可以采取策略来抑制误差增长:

  • 避免大数吃小数:当两个数量级相差巨大的浮点数相加时,较小的数可能会在对其指数时,其有效数字被“舍入”掉。
    # 不好的做法
    s = 1e10
    for i in range(1000000):
        s += 1e-6  # 1e-6相对于1e10太小,很多次加法可能无效
    print(s - 1e10) # 理想是1.0,实际可能远小于1.0
    
    # 更好的做法:先累加小量,再与大数相加
    small_sum = 0.0
    for i in range(1000000):
        small_sum += 1e-6
    s = 1e10 + small_sum
    
  • 选择稳定的数值算法:在数值计算领域,不同的数学公式在浮点运算下可能有完全不同的稳定性。例如,计算样本方差时,使用“两遍算法”不如“在线算法”或“Welford方法”稳定。
  • 谨慎使用迭代和递归:误差会在迭代中累积。对于迭代算法,设置合理的收敛容差和最大迭代次数至关重要。

4. 终极武器:当浮点数力不从心时

对于某些特定领域,尤其是金融、货币计算以及任何要求“十进制精确”的场景,浮点数从根本上就不适用。这时,我们需要请出专门的解决方案。

4.1 定点数:把小数点“钉”住

定点数的思想很简单:我们不用2的幂次,而是用10的幂次作为基数。例如,我们用整数来表示“分”,那么1元就存储为100。所有运算都在整数上进行,最后显示时除以100。

优点:

  • 绝对精确,无舍入误差。
  • 运算速度快(整数运算)。
  • 实现简单。

缺点:

  • 范围和小数点位置固定。例如用int表示分,最大只能处理约21亿元的金额(假设32位有符号int)。
  • 不同精度的定点数(如元和分)运算时需要小心转换。

很多编程语言为金融计算提供了原生的定点数支持,或者有成熟的库。例如,Java的BigDecimal,C#的decimal,以及数据库中的DECIMAL/NUMERIC类型。

4.2 十进制浮点数:硬件级的精确

一些CPU架构(如IBM Power)和编程语言直接支持基于十进制的浮点数标准(如IEEE 754-2008中的decimal32/64/128)。例如,在C#中,decimal关键字就是128位的十进制浮点数类型。

// C# 示例
decimal a = 0.1m; // 注意'm'后缀,表示decimal类型字面量
decimal b = 0.2m;
decimal c = a + b;
Console.WriteLine(c == 0.3m); // 输出 True
Console.WriteLine(c); // 输出 0.3

优点:

  • 对于十进制小数(如0.1)是精确表示的。
  • 范围通常比定点数大。

缺点:

  • 运算速度通常比二进制浮点数慢。
  • 仍然存在舍入误差,只是发生在十进制下(例如,1/3无法精确表示)。
  • 不是所有平台和语言都原生支持。

4.3 有理数:用分数表示一切

对于一些场景,数值本身就是分数(如概率、比例),使用有理数(分子/分母)表示可以完全避免舍入误差。例如,Python的fractions.Fraction模块。

from fractions import Fraction
a = Fraction(1, 10) # 1/10
b = Fraction(2, 10) # 2/10
c = a + b # 结果为 Fraction(3, 10)
print(float(c) == 0.3) # True,转换为浮点数比较
print(c == Fraction(3, 10)) # True,精确相等

优点:对于分数运算绝对精确。 缺点:运算过程中分子分母可能急剧增大(需要约分),且对于无理数(如π、√2)或任意十进制小数(需转换为分数)不友好。

4.4 实战选型指南

面对具体问题,如何选择?这里有一个简单的决策流:

  1. 问题:是否涉及货币、会计、法律规定的精确计算?
    • 是 → 使用定点数(如BigDecimal, decimal)或数据库的DECIMAL类型。这是硬性要求。
  2. 问题:是否涉及物理模拟、图形渲染、科学计算,且对性能要求高?
    • 是 → 使用二进制浮点数(float/double),但必须严格遵守比较和运算规范(使用容差、稳定算法)。
  3. 问题:计算对象本质是分数(如游戏中的概率、资源配比)?
    • 是 → 考虑使用有理数库。
  4. 问题:需要处理用户输入的十进制小数,且希望“所见即所得”,性能要求不是极致?
    • 是 → 可以考虑十进制浮点数(如C#的decimal)。

对于绝大多数全栈应用,我的经验是:后端涉及金额一律用BigDecimal(Java)或decimal(C#/Python decimal库)处理并存储;前端显示时格式化到指定位数;其他科学计算或图形处理,则对float/double保持警惕,用好math.isclose之类的函数。 在数据库设计时,金额字段毫不犹豫地选择DECIMAL(p, s)类型,其中p(精度)和s(小数位数)根据业务需求设定。

最后,记住浮点数不是bug,而是一种权衡。它用极小的误差换来了表示范围的广阔和运算速度的高效。作为开发者,我们的任务不是消灭它,而是理解它的脾气,摸清它的边界,在它可能“捣乱”的地方,提前筑好防护的篱笆。下次再看到0.30000000000000004时,你大可以会心一笑,然后从容地选择正确的工具和方法来应对它。

从π存不进电脑说起:手把手图解IEEE754浮点数编码与舍入的那些坑 本文深入解析了IEEE754浮点数标准在计算机中的编码与舍入机制,揭示了为何π等无限小数无法精确存储。通过图解和实例,详细介绍了浮点数的三部分结构、特殊值表示、四种舍入模式及其误差累积效应,并提供了避免常见问题的实用解决方案。 阅读详情

相关推荐

单精度浮点数对矩阵运算的影响:图解说明

在GPU加速和深度学习训练中,单精度浮点数虽提升计算速度与内存效率,却可能引入累积舍入误差,导致矩阵乘法、求逆等关键运算结果偏差。图解直观呈现单精度与双精度在条件数较高矩阵上的误差扩散过程,揭示单精度浮点数在数值稳定性方面的实际边界。

weixin_35750953的博客 102

为什么0.1+0.2≠0.3?图解浮点数规格化与精度陷阱

本文深入解析了计算机中0.1+0.2≠0.3的浮点数精度问题,详细介绍了IEEE 754标准的规格化表示方法及其导致的精度陷阱。通过二进制转换、运算误差分析和跨语言对比,揭示了浮点数运算的本质,并提供了金融计算中的精确处理方案和性能优化建议。

weixin_29091445的博客 293

单精度浮点数图解说明:存储格式与数值范围展示

通过直观图解深入解析单精度浮点数的二进制存储结构,详细展示其符号位、指数位与尾数位的分布规律,并探讨其可表示的数值范围与精度特性,帮助理解单精度浮点数在计算机中的实际表现。

weixin_31749299的博客 430

【图解+代码】深入剖析浮点数精度陷阱与实战避坑指南

本文深入剖析了浮点数精度问题的根源,通过图解和代码示例解释了为什么0.1+0.2不等于0.3。文章详细解读了IEEE 754标准的内存布局,并提供了绝对误差、相对误差及ULP比较等多种实战方法,帮助开发者有效规避浮点数精度陷阱,提升数值计算的稳定性和准确性。

weixin_29199873的博客 397

【信号与系统】离散卷积:从图解到不进位乘法的实战解析

本文深入解析离散卷积在信号处理中的核心原理与应用,通过图解法和不进位乘法两种方法,帮助读者掌握这一关键数学工具。从基础定义到实战案例,涵盖噪声消除、图像处理等场景,并分享工程实践中的优化技巧与避坑指南。

weixin_30667649的博客 341

单精度浮点数内存字节序问题图解说明

通过直观图示解析单精度浮点数在不同字节序下的内存布局,帮助理解数据在内存中的实际排列方式,掌握单精度浮点数与字节序之间的关系。

weixin_36282234的博客 806

为什么0.1+0.2≠0.3?图解浮点数乘法的精度陷阱与应对方案

本文深入解析了计算机浮点数运算中经典的精度问题,以0.1+0.2≠0.3为例,图解了浮点数乘法的底层原理与精度损失机制。文章结合电商、游戏开发等真实场景,分析了误差产生与累积的原因,并提供了整数化、误差容忍比较、使用高精度库等多维度实战解决方案,帮助开发者从根本上理解和规避浮点数精度陷阱。

mac99的博客 947

【maxENT】从数据到地图:R语言实现最大熵物种分布建模全流程解析

本文详细解析了如何使用R语言实现最大熵模型(MaxEnt)进行物种分布建模的全流程。从数据准备、环境变量处理到模型训练与参数调优,再到模型评估与结果可视化,提供了实用的代码示例和避坑指南。特别适合生态学研究者利用最大熵模型处理物种分布数据,提升研究效率。

weixin_27244795的博客 216

为什么0.1 + 0.2 ≠ 0.3?图解浮点数精度陷阱与避坑指南

本文深入解析了计算机中浮点数精度问题的根源,即十进制小数(如0.1)在二进制下无法精确表示。通过图解IEEE 754标准,揭示了为何0.1 + 0.2不等于0.3,并提供了电商、游戏开发等场景中的实战避坑指南,包括正确的比较方法、使用整数或定点数等解决方案。

prometheus5watch的博客 759

数据字典实战:如何用Excel快速搭建你的第一个数据字典(附模板下载)

本文针对中小团队在软件开发中面临的术语不一致问题,提供了一套使用Excel快速搭建数据字典的实战指南。文章详细讲解了核心字段设计、填充示例、高阶技巧及团队协作维护流程,旨在通过这一轻量级工具统一团队共识、提升开发效率,并附有实用模板下载。

weixin_29303701的博客 384

手把手教你配置SAP PP供应区域(Supply Area):实现线边仓精准发料与物料流优化

本文详细解析了SAP PP供应区域(Supply Area)的配置方法,帮助企业实现线边仓精准发料与物料流优化。通过三级优先级逻辑和四步配置法,系统可自动识别最优组件来源位置,显著提升生产订单处理效率和库存准确率。文章还提供了典型问题解决方案和性能优化技巧,适用于离散制造和重复制造场景。

weixin_29275257的博客 435

为什么0.1+0.2≠0.3?图解浮点数乘法的精度陷阱与应对策略

本文深入解析了计算机系统中浮点数乘法的精度问题,解释了为什么0.1+0.2≠0.3的现象。通过图解IEEE 754标准的存储原理和Chrome开发者工具的实战演示,揭示了二进制浮点数表示的局限性,并提供了数值缩放法、toFixed控制、专用数学库等多种应对策略,帮助开发者有效规避精度陷阱。

mqtt6iot的博客 625

Win10下AutoDock Vina批量对接:从零搭建自动化流程与实战解析

本文详细解析了在Windows 10系统下,如何从零开始搭建AutoDock Vina分子对接的批量自动化流程。通过创建结构化工作目录、准备PDBQT格式文件、编写批处理脚本,实现一键式虚拟筛选,大幅提升科研效率并避免人为错误。文章还涵盖了结果自动提取、可视化分析及流程进阶优化等实战技巧。

grass的博客 467

【图解+代码】深入浅出浮点数精度陷阱

本文深入浅出地解析了计算机中浮点数的精度陷阱,以经典的“0.1+0.2≠0.3”为例,揭示了其根源在于十进制小数转换为二进制时的无限循环与存储截断。文章通过图解详细阐述了浮点数的二进制存储原理(符号位、指数位、尾数位),并分析了由此引发的比较与运算误差。最后,提供了使用误差容限比较、选择合适数据类型等实战策略,帮助开发者编写更健壮的数值计算代码。

gpt4scribbler的博客 715

Miniconda入门:在CentOS上的安装、基本操作、目录结构、卸载

Miniconda是一个 免费的 轻量级的 conda安装程序 它只包含conda、Python、pip、zlib等基础的文件和依赖包 使用conda install命令可从Anaconda存储库中安装额外的conda包 简介 下载 安装 基本操作 虚拟环境的操作 包的操作 目录结构 卸载

ArYe 1万+

深度伪造检测实战:轻量级频域特征 pipeline 部署指南

深度伪造检测(deepfake detection)是多媒体内容安全的核心技术,其本质是通过建模生成式篡改在像素与频域留下的微弱异常痕迹。传统端到端大模型虽在标准数据集上表现优异,却因训练域与真实场景失配、计算开销高、缺乏可解释性而难以落地。本文聚焦于工程可复现的实践路径,提出‘人脸定位→频域伪造特征提取(Xception-FCN + Frequency-Aware Masking)→轻量分类决策’三段式解耦架构,兼顾精度、延迟与可解释性。该方案已在边缘设备(Jetson Orin NX)实现单帧<48ms

weixin_33437929的博客 311

为什么0.1+0.2≠0.3?图解浮点数精度丢失的底层原理(附C++测试代码)

本文深入解析了浮点数精度丢失的底层原理,通过图解和C++测试代码展示了为什么0.1+0.2≠0.3。详细介绍了IEEE 754浮点数标准的存储结构、二进制转换困境及常见精度陷阱,并提供了高精度计算的实践方案和可视化工具。

weixin_26875109的博客 145

眼动数据分析基础_AOI分析动态刺激物

如果您正在研究人们对如视频、动画等动态刺激物的视觉行为,动态AOI工具可为您提供类似静态AOI工具对于图片及其他静止刺激物分析的同样功能。创建和编辑动态AOI的过程和静态AOI相似。 关于动态AOI工具的使用,有几点非常重要: 多个看到相同线性动态刺激物的用户的眼动数据叠加是有价值的; 动态AOI不能用于非线性动态记录的分析; 动态AOI不能用于静态刺激物,如图片的分析; 动态AOI可以被开启、关闭、移动、调整大小及跟踪相关分析对象 首先,我们来定义两种不同的动态刺激物:线性动态刺激物(LDS),是指固

Kobe123brant的博客 3504

JavaScript 中的精度丢失与分摊不平问题及解决方案

JavaScript 浮点数精度丢失导致的分摊不平。本文将深入剖析问题根源,并提供经过生产验证的可靠解决方案。方案是否推荐适用场景, 仅简单场景无严格对账要求整数分摊(分)+Math.floor+ 兜底,强烈推荐电商、金融、ERP 系统记住:在金钱计算中,永远不要信任浮点数。用“分”做整数运算是行业标准实践。通过上述方法,你可以彻底告别“分摊不平”问题,确保系统在任何金额组合下都保持数据一致性。

csdn_silent的博客 3708

抖音小程序:解决获取手机号报错 getPhoneNumber:fail auth deny,登录注册时需要获取用户手机号,getPhoneNumber一直提示错误(Uniapp抖音小程序报错也能解决)

抖音字节小程序获取手机号报错getPhoneNumber:fail auth deny,抖音 小程序 获取手机号 报错 getPhoneNumber:fail auth ,抖音小程序获取手机号始终返回拒绝,抖音小程序获取手机号,已经过了试运营期但依旧报错如何解决,调用 tt.getPhoneNumber 接口报错,登录注册时需要获取用户手机号,getPhoneNumber一直提示getPhoneNumber:fail auth deny,此能力仅支持小程序通过试运营期后可用,默认获取权限,无需申请;unia

✅ 精选推荐文章 4307

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

小白也能懂:图解Java小数精度陷阱

对于需要持续运行的教学演示(比如这个可视化工具),平台的一键部署功能让分享变得特别简单——不需要配置服务器环境,生成链接就能让其他人互动体验。每人分到1/3块,但实际切割时总会剩下一小块碎屑。实践时,最让我惊喜的是可以直接修改代码参数实时观察不同小数计算效果。比如把除数从3改成4,立刻能看到精确结果0.25的二进制存储形式完全不同。今天想和大家聊聊编程中一个看似简单却容易踩坑的问题——小数精度。我们习惯的十进制中,1/3是无限循环小数。这样的计算搞得一头雾水,直到用可视化的方式才真正理解背后的原理。

GoldenleafRaven13的博客 265

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

从16777217的消失说起:图解Float类型的内存布局与精度陷阱

本文深入解析了单精度浮点数(Float)的内存布局与精度陷阱,以16777217消失现象为例,揭示了IEEE 754标准的存储机制。通过二进制示意图和数学原理,详细解释了24位有效位数的精度限制,并为游戏引擎和嵌入式开发提供了实用的类型选择策略与优化技巧。

sky77的博客 179

贝叶斯统计 [韦来生编]

贝叶斯(Bayes)统计是近几十年来迅速发展起来的数理统计的一个重要分支。贝叶斯方法与经典统计方法的主要不同之处是进行统计推断时除了利用样本信息外,还要利用参数的先验信息,因此可以提高统计推断或统计决策的效果。它在经济、金融、生物、医学、自然科学和社会科学等许多领域具有广泛的应用。贝叶斯方法的研究已渗透到了统计学的几乎所有领域。作者在给中国科学技术大学概率论与数理统计专业本科生开设的“数理统计”课程中有一章专门讲授“贝叶斯方法和统计决策理论”,近十年来也给中国科学技术大学概率统计专业研究生开设过几次“贝叶斯分析”课。本书是在对过去讲稿的内容作了适当的增减和调整的基础上完成的。  本书共分六章。第1章是绪论,介绍了贝叶斯统计的若干基本概念,同时对必要的数理统计的基础知识有重点地作了回顾。第二章介绍了确定先验分布的若干可供选择的方法。第三章介绍了几类常见统计模型参数的后验分布的主要结果和计算方法。第四章和第五章分别介绍了“贝叶斯统计推断”和“贝叶斯统计决策”的内容。第六章介绍了贝叶斯统计计算的若干方法,包括蒙特卡洛方法和马尔可夫链蒙特卡洛(MCMC)方法以及相关统计软件的简介。本书的每一章附右大量的例题和习题,书末附有常用的几个表格和部分习题解答供读者查用。  大约可在54学时内讲授本书的第1章至第六章的主要内容,教师可根据学时需要选讲本书第1章至第六章的部分内容。书中标“*”号的章节可略去不讲,留给读者作为阅读材料。第六章例题中的R代码和部分例题的数据文件等可从作者个人主页下载。  作者在编写本书的过程中参考了J.O.Berger教授的《统计决策论及贝叶斯分析》和茆诗松教授编写的《贝叶斯统计》等书中的一些内容,以及《贝叶斯分析》一书中由张伟平博士编写的有关贝叶斯统计计算的一些内容。在此表示衷心感谢。  本书编写准备过程中,中国科学技术大学统计与金融系的几个研究生帮助完成了本书部分中文的录入和排版,作者对他们的辛勤工作表示真诚的感谢。高等教育出版社为本书的出版给予了大力支持。在此一并致谢。

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

C语言数据类型全解析:最新特性与实战案例(附代码+图解)

本文全面解析C语言数据类型(整型、浮点型、指针、结构体等),结合2025年新特性(复数运算、布尔类型),通过电商秒杀系统案例,深入探讨企业级开发痛点:技术债务、高并发性能瓶颈、监控盲区。提供云原生架构(Kubernetes+Docker)、全链路监控(Prometheus+ELK)、安全防护(OWASP+JWT)等解决方案,并附实战代码、部署方案及学习路径,助开发者从基础到高阶掌握C语言核心技能,实现生产级系统落地。

全栈 560

Python学习笔记(3)|数据类型、变量与运算符:夯实基础,从入门到避坑(附图解+代码)

在《第2章 Python编程基础》中,我们搭建了IPO模型,认识了print和input。但真正存储数据、处理数据的主角,是变量和数据类型。它们就像盖房子用的砖块和水泥,决定了代码的稳固与功能。今天,我们就彻底吃透《第3章 数据类型和运算符》!

love_summerbest的博客 876

Python enumerate底层原理与生产级避坑指南

enumerate是Python迭代协议中实现位置感知的核心工具,其本质并非for循环语法糖,而是基于迭代器协议、通过元组解包动态注入索引信息的惰性中间件。它支持生成器、零内存预加载、强类型索引控制,并在日志序号对齐、分页偏移、滑动窗口等场景提供不可替代的技术价值。相比zip(range(), ...),enumerate具备更低内存占用、更高CPU缓存命中率和更安全的状态隔离能力;而起始索引start参数的整数约束、负数行为及C层校验时机,直接关系到异步任务、微服务和大数据处理的稳定性。本文深入CPyth

weixin_33805992的博客 344
上一篇: 避开Tecplot数据导入的5个坑:四边形网格文件编写避坑指南
下一篇: 陀螺仪漂移克星:用卡尔曼滤波实现精准姿态解算(附完整代码)
sql99
博客等级 码龄19年 168粉丝 1905原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值