什么网站做电子元器件最好看免费视频

什么网站做电子元器件,最好看免费视频,雄安投资建设集团有限公司网站,电子科技网站模板浮点数的本质#xff1a;为什么计算机无法精确表示0.1 当你在 C 中写下 float x 0.1; 时#xff0c;你以为计算机存储的就是精确的 0.1。但事实是#xff0c;计算机存储的是一个非常接近 0.1 的近似值。这不是编译器的缺陷#xff0c;也不是硬件的问题#xff0c;而是浮点…浮点数的本质为什么计算机无法精确表示0.1当你在 C 中写下float x 0.1;时你以为计算机存储的就是精确的 0.1。但事实是计算机存储的是一个非常接近 0.1 的近似值。这不是编译器的缺陷也不是硬件的问题而是浮点数表示机制的必然结果。理解这个机制是理解所有数值计算问题的起点。问题的起源有限的 bit 如何表示无限的实数计算机只能处理 0 和 1。整数容易表示因为它们本身就可以精确地转换为二进制。但实数是连续的它们在数轴上密密麻麻地分布着而我们只有有限个 bit 可以使用。这就像用有限个标记点去标识一条无限延伸的直线必然会有大量的数值无法被精确标记。更具体地说当我们用 32 个 bit 来表示浮点数时我们只能表示 2^32 约等于 42 亿个不同的数值。而实数有无穷多个即使只考虑 0 到 1 之间的实数也有无穷多个。这意味着绝大多数实数根本无法被精确表示计算机只能选择最接近的那个可表示的值。这就是浮点数表示的根本困境用有限的编码空间去逼近无限的数值空间。IEEE 754 标准定义的浮点数格式就是在这个约束下做出的最优工程设计。浮点数的表示二进制科学计数法计算机采用的解决方案是二进制科学计数法。在十进制中我们写 1.23 × 10^4 来表示 12300这样可以用较少的位数表示较大范围的数值。浮点数也采用了同样的思路只不过基数是 2 而不是 10。以 C 中的float类型为例它占用 32 个 bit被划分为三个部分。第一个 bit 是符号位决定这个数是正是负。接下来的 8 个 bit 是指数位决定这个数的量级大小。最后的 23 个 bit 是尾数位决定这个数的精确度。这个设计的数学形式是(-1)^s × 2^(e-127) × (1.f)其中 s 是符号位e 是指数位的值f 是尾数位表示的小数部分。这里有两个关键细节。第一指数位存储的是 e但实际使用时要减去 127这个 127 叫做偏置值。第二尾数部分的整数位永远是 1所以不需要存储只存储小数部分这叫做隐式前导位。让我们看一个具体例子。数值 2.5 在二进制中是 10.1写成规格化的科学计数法是 1.01 × 2^1。符号位是 0 表示正数指数是 1 但存储时要加上偏置 127 得到 128尾数是 01 后面补 21 个零。这样2.5 就被精确地编码进了 32 个 bit 中。我们可以用代码验证这一点/* by 01022.hk - online tools website : 01022.hk/zh/json2excel.html */ #include iostream #include cstring #include bitset int main() { float x 2.5f; // 将 float 的内存表示解释为整数 uint32_t bits; std::memcpy(bits, x, sizeof(float)); // 输出二进制表示 std::cout 2.5 的二进制表示: std::bitset32(bits) std::endl; // 输出: 01000000001000000000000000000000 // ^符号 ^指数(128) ^尾数(01后面全是0) std::cout 实际存储的值: x std::endl; // 输出: 2.5 (精确) return 0; }在这个例子中2.5 被完美地表示出来因为它在二进制中恰好是有限小数。第一个困难二进制无法精确表示的十进制小数现在我们遇到了第一个问题。2.5 可以被精确表示因为它在二进制中是有限小数 10.1。但 0.1 就不行了。当你尝试把十进制的 0.1 转换成二进制时你会得到一个无限循环的二进制小数0.0001100110011...这个 0011 的循环永远不会停止。这和十进制中 1/3 0.333... 无法精确表示是同样的道理只不过在二进制中更多看起来简单的十进制小数都变成了无限循环小数。0.1、0.2、0.3 这些我们日常使用的数值在二进制中都无法精确表示。当你写float x 0.1;时计算机会找到最接近 0.1 的那个可表示的浮点数。这个数非常接近 0.1但不是精确的 0.1。这就是为什么你会在数值计算中看到 0.1 0.2 不等于 0.3 的现象因为这三个数在存储时都已经是近似值了。让我们用代码直观地看到这个问题/* by 01022.hk - online tools website : 01022.hk/zh/json2excel.html */ #include iostream #include iomanip int main() { float a 0.1f; float b 0.2f; float c 0.3f; // 设置高精度输出 std::cout std::setprecision(20); std::cout a a std::endl; // 输出: 0.10000000149011611938 std::cout b b std::endl; // 输出: 0.20000000298023223877 std::cout c c std::endl; // 输出: 0.30000001192092895508 std::cout a b (a b) std::endl; // 输出: 0.30000000447034835815 std::cout a b c: (a b c ? true : false) std::endl; // 输出: false return 0; }这段代码清楚地展示了问题的本质。0.1 在计算机中实际存储的是 0.100000001...0.2 存储的是 0.200000002...它们的和自然不会等于存储的 0.3。这不是 bug而是二进制表示的必然结果。正确的比较方法应该是判断差值是否足够小#include iostream #include cmath int main() { float a 0.1f; float b 0.2f; float c 0.3f; const float epsilon 1e-6f; // 容差阈值 if (std::abs((a b) - c) epsilon) { std::cout 在容差范围内相等 std::endl; } else { std::cout 不相等 std::endl; } return 0; }第二个困难尾数位数限制带来的精度损失即使一个数在二进制中可以表示为有限小数如果它需要的有效数字超过了 23 位尾数所能容纳的范围也会发生精度损失。考虑一个很大的整数比如 16777217。这个数在二进制中是 1 后面跟 24 个 bit。要用科学计数法表示它我们需要 24 位有效数字但float的尾数只有 23 位。计算机必须舍弃最后一位存储的实际上是 16777216。这意味着float类型最多只能精确表示大约 7 位十进制有效数字。超过这个精度的数值无论你写得多么精确存储时都会被四舍五入到最近的可表示值。这就是为什么在金融计算或科学计算中我们经常需要使用double类型它有 53 位尾数可以提供大约 15 位十进制有效数字的精度。让我们用代码展示精度损失的问题#include iostream #include iomanip int main() { // float 的精度极限 float f1 16777216.0f; // 2^24刚好可以精确表示 float f2 16777217.0f; // 2^24 1超出精度 std::cout std::setprecision(10); std::cout f1 f1 std::endl; // 输出: 16777216 std::cout f2 f2 std::endl; // 输出: 16777216 (注意不是 16777217) std::cout f1 f2: (f1 f2 ? true : false) std::endl; // 输出: true (两个不同的数变成了同一个值) // 大数加小数的精度丢失 float big 1e8f; float small 1.0f; float result big small; std::cout \n大数加小数: std::endl; std::cout big big std::endl; std::cout result result std::endl; std::cout big result: (big result ? true : false) std::endl; // 输出: true (小数完全被淹没) // 对比 double 的表现 double d1 16777216.0; double d2 16777217.0; std::cout \ndouble 的表现: std::endl; std::cout d1 d1 std::endl; std::cout d2 d2 std::endl; std::cout d1 d2: (d1 d2 ? true : false) std::endl; // 输出: false (double 可以区分这两个数) return 0; }这段代码清楚地展示了float的精度限制。当数值超过一定范围时连相邻的整数都无法区分。而在大数加小数的场景中小数会被完全忽略这在累加计算中是非常危险的。范围的极限从最大数到无穷浮点数不仅有精度限制还有范围限制。指数位决定了数值的量级范围。对于float8 位指数理论上可以表示 0 到 255但 IEEE 754 标准保留了两个特殊值全零和全一。当指数位是全零时表示的是非常接近零的非规格化数。当指数位是全一时表示的是特殊值。因此正常的指数范围是 1 到 254减去偏置 127 后真实指数范围是 -126 到 127。最大的正常浮点数出现在指数是 127 且尾数全为 1 的情况。此时尾数部分 1.f 接近但小于 2所以最大的float大约是 2 × 2^127约等于 3.4 × 10^38。这是一个非常大的数但它仍然是有限的。当计算结果超过这个最大值时会发生什么答案是溢出。IEEE 754 标准规定上溢的结果不是报错而是返回一个特殊值正无穷或负无穷。让我们用代码观察溢出的发生#include iostream #include limits #include cmath int main() { // 查看 float 的最大值 float max_float std::numeric_limitsfloat::max(); std::cout float 的最大值: max_float std::endl; // 输出: 3.40282e38 // 制造溢出 float x max_float; float y x * 2.0f; std::cout max_float * 2 y std::endl; // 输出: inf std::cout 是否为无穷: (std::isinf(y) ? true : false) std::endl; // 输出: true // 另一种触发方式 float a 1e38f; float b a * 10.0f; std::cout 1e38 * 10 b std::endl; // 输出: inf // 正无穷和负无穷 float pos_inf std::numeric_limitsfloat::infinity(); float neg_inf -std::numeric_limitsfloat::infinity(); std::cout \n正无穷: pos_inf std::endl; std::cout 负无穷: neg_inf std::endl; // 无穷的运算特性 std::cout \ninf 1 (pos_inf 1.0f) std::endl; // 输出: inf std::cout inf * 2 (pos_inf * 2.0f) std::endl; // 输出: inf std::cout inf 任何有限数: (pos_inf max_float ? true : false) std::endl; // 输出: true return 0; }这段代码展示了无穷的产生和性质。需要强调的是这里的 inf 不是数学意义上的无穷大而是一个编码约定表示数值超出了浮点数的表示范围。它的指数位是全一尾数位是全零。不确定性的表达NaN 的存在除了无穷还有一类更特殊的值NaN意思是 Not a Number。当一个运算在数学上没有定义时结果就是 NaN。最典型的例子是零除以零。但触发 NaN 的情况远不止这一种。负数的平方根、无穷减去无穷、无穷除以无穷这些在数学上没有确定结果的运算都会产生 NaN。NaN 的编码方式是指数位全为一但尾数位不为零。这和 inf 形成了对比同样是指数全一但通过尾数是否为零来区分方向明确的发散和完全无定义的状态。NaN 有一个非常反直觉的性质它不等于任何值包括它自己。在 C 中x x的结果可以是 false当且仅当 x 是 NaN 时。这不是语言设计的失误而是 IEEE 754 标准的明确规定因为 NaN 代表的不是一个数值点而是一个未定义的状态。让我们用代码观察 NaN 的行为#include iostream #include cmath #include limits int main() { // 产生 NaN 的几种方式 float nan1 0.0f / 0.0f; float nan2 std::sqrt(-1.0f); float nan3 std::numeric_limitsfloat::infinity() - std::numeric_limitsfloat::infinity(); float nan4 std::numeric_limitsfloat::infinity() / std::numeric_limitsfloat::infinity(); std::cout 0.0 / 0.0 nan1 std::endl; std::cout sqrt(-1) nan2 std::endl; std::cout inf - inf nan3 std::endl; std::cout inf / inf nan4 std::endl; // 输出都是: nan // NaN 的反直觉特性 float x std::nanf(); std::cout \nNaN 的比较特性: std::endl; std::cout NaN NaN: (x x ? true : false) std::endl; // 输出: false (唯一一个不等于自己的值) std::cout NaN ! NaN: (x ! x ? true : false) std::endl; // 输出: true std::cout NaN 0: (x 0.0f ? true : false) std::endl; // 输出: false std::cout NaN 0: (x 0.0f ? true : false) std::endl; // 输出: false std::cout NaN 0: (x 0.0f ? true : false) std::endl; // 输出: false // 检测 NaN 的正确方法 std::cout \n检测 NaN: std::endl; std::cout 使用 std::isnan: (std::isnan(x) ? true : false) std::endl; // 输出: true // NaN 的传播性 float result 1.0f x; std::cout \n1.0 NaN result std::endl; // 输出: nan std::cout 是否为 NaN: (std::isnan(result) ? true : false) std::endl; // 输出: true (NaN 会传播到所有涉及它的运算) return 0; }这段代码充分展示了 NaN 的特殊性质。特别要注意的是NaN 不参与正常的数值比较任何涉及 NaN 的比较都返回 false。这就是为什么我们不能用x x来判断一个数是否正常而应该使用std::isnan(x)函数。实践中的启示理解了浮点数的底层表示机制后我们可以得出几个重要的实践原则。第一永远不要用等号比较两个浮点数。由于表示误差和计算误差的累积两个理论上应该相等的浮点数在计算机中可能略有差异。正确的做法是判断它们的差的绝对值是否小于一个很小的阈值。第二在进行大量浮点运算时要注意误差累积。每次运算都可能引入微小的误差这些误差会累积。特别是在求和时如果数值的量级相差很大小数值可能会被完全淹没。让我们用一个实际例子说明误差累积的危险#include iostream #include iomanip int main() { std::cout std::setprecision(10); // 错误的累加方式直接累加小数 float sum1 0.0f; for (int i 0; i 10000000; i) { sum1 0.1f; } std::cout 直接累加 0.1 一千万次: sum1 std::endl; std::cout 理论值应该是: 1000000.0f std::endl; std::cout 误差: (1000000.0f - sum1) std::endl; // 误差可能达到几百甚至上千 // 大数加小数的问题 float big 1e8f; float small_sum 0.0f; for (int i 0; i 1000; i) { small_sum 1.0f; } float result big small_sum; std::cout \n1e8 (1000个1的和) result std::endl; std::cout 是否等于 1e8: (result big ? true : false) std::endl; // 可能输出 true小数完全丢失 return 0; }第三在需要高精度的场景中要选择合适的数据类型。如果float的 7 位有效数字不够就使用double的 15 位。如果连double都不够可能需要考虑使用高精度数值库。第四在写浮点字面量时建议明确标记类型。10f明确表示这是一个float而10.0默认是double。这不仅避免了不必要的类型转换也让代码的意图更加清晰。#include iostream int main() { // 推荐的写法明确类型 float x 10.0f; // float 字面量 double y 10.0; // double 字面量 // 不推荐的写法隐式转换 float z 10.0; // double 转 float可能有警告 // 科学计数法的写法 float a 1.5e-3f; // 0.0015 double b 1.5e-3; // 0.0015 return 0; }总结浮点数不能精确表示所有实数这不是缺陷而是在有限资源下必然的权衡。计算机用 32 个或 64 个 bit在精度、范围和计算效率之间找到了一个平衡点。理解这个平衡点就会理解为什么 0.1 0.2 不等于 0.3为什么大数加小数会丢失精度为什么会出现 inf 和 NaN。