0.1+0.2 为什么不等于0.3

程序里为什么0.1+0.2不等于0.3? 为什么0.1+0.2不等于0.30.1+0.2新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能,丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 0.1+0.2 程序里面0.1+0.2=0.30000000000000004 你好! 这是你第一次使用 Markdown编辑器 阅读详情

目录

一、0.1+0.2的计算过程

1.十进制转成二进制

2.转成浮点数

3.浮点数相加

4.浮点数转成十进制

二、答案

三、拓展


一、0.1+0.2的计算过程

1.十进制转成二进制

在JS内部所有的计算都是以二进制方式计算的。 所以运算 0.1+ 0.2 时要先把 0.1和 0.2 从十进制转成二进制。

  • 0.1转化成二进制的算法:
    0.1*2=0.2======取出整数部分0
    0.2*2=0.4======取出整数部分0
    0.4*2=0.8======取出整数部分0
    0.8*2=1.6======取出整数部分1
    0.6*2=1.2======取出整数部分1
    接下来会无限循环
    0.2*2=0.4======取出整数部分0
    0.4*2=0.8======取出整数部分0
    0.8*2=1.6======取出整数部分1
    0.6*2=1.2======取出整数部分1
    所以0.1转化成二进制是:0.0001 1001 1001 1001......
  • 0.2转化成二进制的算法:
    0.2*2=0.4======取出整数部分0
    0.4*2=0.8======取出整数部分0
    0.8*2=1.6======取出整数部分1
    0.6*2=1.2======取出整数部分1
    接下来会无限循环
    0.2*2=0.4======取出整数部分0
    0.4*2=0.8======取出整数部分0
    0.8*2=1.6======取出整数部分1
    0.6*2=1.2======取出整数部分1
    所以0.2转化成二进制是:0.0011 0011 0011 0011......

这里要注意 0.1 和 0.2 转成的二进制是无穷的。另外在现代浏览器中是用浮点数形式的二进制来存储二进制,所以还要把上面所转化的二进制转成浮点数形式的二进制。

2.转成浮点数

浮点数分为单精度对应32位操作系统和双精度对应64位操作系统。目前的操作系统大多是64位操作系统,故这里只解释一下二进制如何转成双精度浮点数的二进制。

双精度浮点数用1位表示符号位,11位表示指数位,52位表示小数位,如下图所示:

  • 符号位:正数为0,负数为1;
  • 指数位:阶数+偏移量,阶数是:

,e为阶码的位数。偏移量是把小数点移动到整数位只有1时移动的位数,正数表示向左移,负数表示向右移;

  • 小数位:即二进制小数点后面的数。

接下来把0.1转成的二进制0.0001100110011001 ......转成浮点数形式的二进制。

  • 先要把小数点移动到整数位只有1,要向右移动4位,故偏移量为−4,通过指位数的计算公式

,把1019转成二进制为1111111011,不够11位要补零,最终得出指位数为01111111011;

  • 小数位为100110011001...... ,因为小数位只能保留52位,第53位为1故进1。

转换结果如下图所示:

同理,再把 0.2 转成的二进制0.0011 0011 0011 0011...... 转成浮点数形式的二进制,转换结果如下图所示:

3.浮点数相加

浮点数相加时,需要先比较指位数是否一致,如果一致则小数位直接相加,如果不一致,要先把指位数调成一致的,指位数小的向大的调整。

为了行文方便,把0.1转成的浮点数称为为0.1,把0.2转成的浮点数称为0.2。

0.1的指数位是1019 ,0.2的指数位是1020 。故要把0.1的指数位加1,即把0.1的小数点向左移动1位,另外浮点数的整数位固定为1,过程如下所示

1.1001100110011001100110011001100110011001100110011010   原先
0.11001100110011001100110011001100110011001100110011010  移动后  
0.1100110011001100110011001100110011001100110011001101   将小数的第53位舍去,因为为0故不需进1

导致0.1的小数位变成如下所示:

现在0.1和0.2的指数位相同了,把小数位直接相加。

    1100110011001100110011001100110011001100110011001101 0.1的小数位
+   1001100110011001100110011001100110011001100110011010 0.2的小数位
=  10110011001100110011001100110011001100110011001100111

会发现现在的小数位多出了一位,超出了52位,故要把小数位最后一位截掉,小数位最后一位是1,故要进1,如下所示:

10110011001100110011001100110011001100110011001100111
1011001100110011001100110011001100110011001100110100

截掉小数位的最后一位相当把小数点向左移了一位,故指数位要加1,此时的指数是0.2的指数1021 ,加1后变成1021 ,转成二进制为01111111101 ,那么相加后的浮点数如下所示:

4.浮点数转成十进制

二进制浮点数计算结束后,把结果(二进制的浮点数)转成十进制,其转换公式为

,s是符号位为0或1,e为浮点数指数位转成十进制的值,i表示小数位从左到右的位数,第一位 i=1 ,

表示每一位的值为0或1。

那么按着公式把二进制的浮点数转成十进制:

结果如下所示:

0.3000000000000000444089209850062616169452667236328125

由于精度问题,只取到0.30000000000000004。

二、答案

0.1+0.2 不等于 0.3 ,因为在 0.1+0.2 的计算过程中发生了两次精度丢失。第一次是在 0.1 和 0.2 转成双精度二进制浮点数时,由于二进制浮点数的小数位只能存储52位,导致小数点后第53位的数要进行为1则进1为0则舍去的操作,从而造成一次精度丢失。第二次在 0.1 和 0.2 转成二进制浮点数后,二进制浮点数相加的过程中,小数位相加导致小数位多出了一位,又要让第53位的数进行为1则进1为0则舍去的操作,又造成一次精度丢失。最终导致 0.1+0.2 不等于0.3 。

三、拓展

0.1+0.2 不等于 0.3 会引起那些BUG ?

会引起统计页面展示错乱的BUG,还有 300.01 优惠300 元后,支付金额不足0.01 元等类似的BUG。

怎么解决 0.1+0.2 不等于 0.3 ?

可以用Math.js数学计算库来解决,或者用toFixed()给计算结果四舍五入,但是toFixed()在chrome或者火狐浏览器下四舍五入也有精度误差。可以用Math.round来解决精度误差,比如要把 2.55 四舍五入保留 1 位小数,先把 2.55∗10 得到 25.5 ,再用Math.round取整25.5 ,会得到25,再把 25÷10 得到 2.5 ,就这样间接实现了四舍五入。可以用Math.pow来做个简单的封装Math.round(Math.pow(10, m) * number) / Math.pow(10, m),其中number是要四舍五入的数,m是保留几位小数。

13-为什么在JavaScript中0.1 + 0.2不等于0.3? 理解这一点,并采用适当的方法来处理浮点数计算,可以帮助我们避免相关的精度问题。首先,我们需要了解计算机是如何表示小数的。而在二进制中,并不是所有的十进制小数都能精确地表示。将这些十进制小数转换为二进制浮点数时,它们只能近似表示。但是,在二进制系统中,0.1表示为一个无限循环的小数,类似于在十进制中1/3表示为0.3333…对于需要高精度计算的场景,可以使用BigDecimal库进行处理,这些库能够精确处理十进制数。这并不是精确的0.3,而是一个非常接近0.3的数值,但在计算机的精度限制下,它们并不相等。 阅读详情

相关推荐

JavaScript浮点数精度问题解析:0.1 + 0.2为什么不等于0.3

IEEE 754标准是由国际电气和电子工程师协会(IEEE)制定的一套关于浮点数运算的标准。该标准解决了不同计算机和处理器在进行浮点数计算时可能产生的不一致问题。由于早期计算机系统在浮点运算方面缺乏统一规范,导致同一个计算任务在不同的硬件或软件环境下得到的结果不尽相同,这对科学计算、工程、金融等领域造成了极大的困扰。IEEE 754标准的制定,使得浮点数的表示和运算在全世界范围内实现了标准化,极大地提高了计算结果的可移植性与可信度。Math对象包含了一系列用于执行基本数学运算和复杂数学计算的函数。

weixin_29363791的博客 631

为什么 0.1+0.2 不等于 0.3

位),而在这种格式下无法精确表示某些小数,因此在进行计算时会出现精度误差。中,这些小数会被转换成最接近它们的可表示值,然后再进行计算。被转换成的值可能会存在精度误差,导致它们的和不等于。都是无限循环小数,无法用二进制精确地表示。中采用的是双精度浮点数格式(

weixin_42560424的博客 3029

Comsol有限元网格剖分实战:从基础操作到高效仿真技巧

本文系统介绍了COMSOL有限元网格剖分的核心实战技巧。从基础的物理场控制与用户控制网格选择,到三角形、四边形、四面体等网格单元类型的适用场景,再到扫掠网格、边界层网格与复制网格等高效剖分方法,最后讲解了网格质量评估与几何预处理的关键步骤。旨在帮助用户掌握从自动到手动、从基础到高效的网格剖分艺术,实现仿真精度与计算效率的最佳平衡。

j7k8l的博客 375

0.1 + 0.2 为什么不等于 0.3之小数精度问题

浮点数计算类,取二者中小数位数最长者(记为 N),同时乘以 10 的 N 次幂,转换为整数进行计算,再除以 N 次幂转回小数需要用 toFixed 取近似值的地方,可以先加上 1e-14 或 umber.EPSILON,再取。判定两个数字相等,可以使用 Math.abs(left - right) < Number.EPSILON实在不会,就直接用别人写好的成熟库吧。

yyh1994的博客 2103

Docker一键部署Synopsys EDA全家桶(VCS/Verdi 2018版)保姆级教程

本文提供了一份详尽的Docker容器化部署Synopsys EDA工具链(VCS/Verdi 2018版)的保姆级教程。通过环境隔离与标准化,解决传统安装的依赖冲突问题,并重点攻克了容器内GUI图形界面显示的核心难题。教程涵盖从Docker基础安装、镜像获取、容器启动配置,到使用X11转发或VNC实现Verdi完美显示的完整实践,旨在帮助芯片设计工程师快速构建稳定、可移植的一键化EDA工作环境。

weixin_29281941的博客 198

深入分析RAG知识库多模态数据预处理

多模态企业数据预处理是构建高质量RAG知识库的关键环节。本文详解了处理流程:1)文档格式识别与路由;2)多模态内容提取(文本、图像、音视频);3)结构解析与语义重建;4)数据清洗与增强;5)智能分块(强调语义完整性);6)元数据注入。推荐使用开源工具如PaddleOCR、Whisper、BLIP-2等,或商业API处理复杂场景,最终生成带丰富元数据的结构化内容,为后续向量化检索奠定基础。

qq_35354529的博客 1379

17、为什么0.1 + 0.2 不等于 0.3

再用2去除商,又会得到一个商和余数,如此进行,直到商为小于1时为止,然后把先得到的余数作为二进制数的低位有效位,后得到的余数作为二进制数的高位有效位,依次排列起来。具体做法是:用2乘十进制小数,可以得到积,将积的整数部分取出,再用2乘余下的小数部分,又得到一个积,再将积的整数部分取出,如此进行,直到积中的小数部分为零,此时0或1为二进制的最后一位。浮点数相加时,需要先比较指位数是否一致,如果一致则小数位直接相加,如果不一致,要先把指位数调成一致的,指位数小的向大的调整。转成浮点数形式的二进制。

天界程序员的博客 2287

三维视觉智能焊接系统:免示教技术的工业应用实践

本文深入探讨了三维视觉智能焊接系统中免示教技术的工业应用实践。该系统通过三维视觉相机实时扫描工件,自动识别焊缝并生成轨迹,将产线换型时间从数小时缩短至几分钟,显著提升了生产柔性。文章详细解析了其核心硬件、算法及工厂部署流程,并展望了与数字孪生、工艺智能化融合的未来趋势。

weixin_29091105的博客 432

为什么 0.1 + 0.2 不等于0.3?如何解决这个问题?

一、开头 我们都知道0.1 + 0.2 !== 0.3,而是0.30000000000000004,那么是为什么?我们都知道计算机在内部实现中使用的是二进制,0.1也是不例外的,此时我们将0.1转换为二进制数据表示可以表示为:0.0001100110011001100...(1100无限循环),0.2转换为二进制数据可以表示为0.00110011001100...(1100循环),此时这两个数均为无限循环小数,那么该如何去存储呢? 二、如何存储二进制小数 不同的语言可能会有不同的存储标准,javascrip

weixin_47450807的博客 9108

ESP32-S3双屏AI吊坠:微型边缘智能终端设计实践

边缘智能终端是指在设备端完成数据感知、处理与响应的嵌入式系统,其核心在于低延迟、高隐私与弱网适应性。基于ESP32-S3等轻量级主控,通过语音唤醒、本地AI推理与双屏异步渲染等关键技术,可构建资源受限场景下的实用化人机交互节点。这类设计显著降低对云端依赖,提升实时性与数据安全性,广泛应用于智能穿戴、IoT交互面板及便携式语音设备。本文以‘璀璨·AI吊坠’为实例,深入解析双面圆形屏驱动、ES8311音频链路优化、VAD+Porcupine本地语音流水线,以及亚微安级低功耗状态机实现,为微型AI终端的软硬协同开

weixin_42348783的博客 633

Ubuntu终端接入Codex:一行脚本搞定AI编程助手安装与配置

在开发者日常工作中,命令行终端是最高频的操作环境,而AI编程助手的出现正在改变传统的编码方式。通过将大模型能力与终端工具链结合,开发者无需切换窗口即可完成命令查询、代码生成、项目理解和自动执行等任务。Ubuntu作为服务器和开发机的主流系统,搭配Node.js生态和API Key认证,即可在本地闭环运行AI助手。本文从环境准备、密钥配置、权限管理到自动化脚本封装,系统拆解在终端中接入Codex的完整流程,并分享高频用法与实测排障经验,帮助开发者安全、高效地让AI融入命令行工作流。

weixin_29061041的博客 322

0.1+0.2为什么不等于0.3

大家好,我是哪吒。最近碰到一个问题,很有趣,我就不贴代码了,要不你们会以为我在无中生有。我现在的心情很复杂,我想静静。我只知道浮点数相加是丢失精度的,但是为什么会丢精度,我就不知道了。浮点数在计算机内部是以二进制的形式存储的,而有些十进制的小数在二进制下无法精确表示,因此在进行浮点数运算时可能会存在精度误差。浮点数分为单精度对应32位操作系统和双精度对应64位操作系统。目前的操作系统大多是64位操作系统,故这里只解释一下二进制如何转成双精度浮点数的二进制。双精度浮点数用1位表示符号位,11位表示指数位,52

学Java,找哪吒 1569

DeepSeek在实时计算与流处理系统中的突破性实践

对于技术决策者而言,现在正是将DeepSeek实时计算技术纳入企业架构蓝图的关键时机,那些能够率先构建实时智能能力的企业,将在数据驱动的商业竞争中赢得决定性优势。DeepSeek通过创新的流处理架构,成功将复杂事件处理(CEP)的延迟降低到亚秒级,同时保证了计算结果的精确性。DeepSeek研发的神经架构搜索(NAS)与知识蒸馏联合优化框架,可在保持模型精度的前提下,将参数量压缩至原始模型的1/100,实现边缘设备的实时AI推理。随着5G和物联网技术的普及,对实时处理能力的需求将呈指数级增长。

Programming Talk 290

python0.1+0.2不等于0.3_为什么0.1+0.2不等于0.3

先看两个简单但诡异的代码:0.1 + 0.2 > 0.3 // true0.1 * 0.1 = 0.0100000000000000020.1加0.2为什么就不等于0.3昵?要回答这个问题,得先了解计算机内部是如何表示数的。计算机内部如何表示数我们都知道,计算机用位来储存及处理数据。每一个二进制数(二进制串)都一一对应一个十进制数。1. 计算机内部如何表示整数这里以十进制数13来展示“按位计...

weixin_33617691的博客 5141

ABAP 7.40 FOR 表达式与 REDUCE 构造运算符深度解析:从语法新特性到真实项目实践

ABAP 7.40引入了FOR和REDUCE表达式语法,使代码更简洁和函数式。FOR支持内表迭代和条件迭代,可配合VALUE构造新内表,替代传统LOOP。REDUCE用于归约运算,将多值折叠为单一结果,如求和、拼接等。这些新特性让ABAP更现代化,与SAP新架构协同更好,提升了开发效率和代码可读性。

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 316

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain&#39;s apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath(&#39;DeepLearnToolbox&#39;));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand(&#39;state&#39;,0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W&#39;); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand(&#39;state&#39;,0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = &#39;sigm&#39;;%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, &#39;Too big error&#39;);```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand(&#39;state&#39;,0)sae = saesetup([784 100]);sae.ae{1}.activation_function = &#39;sigm&#39;;sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)&#39;)% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = &#39;sigm&#39;;nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, &#39;Too big error&#39;);```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x&#39;,28,28,60000))/255;test_x = double(reshape(test_x&#39;,28,28,10000))/255;train_y = double(train_y&#39;);test_y = double(test_y&#39;);%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you&#39;ll get around 1.2% errorrand(&#39;state&#39;,0)cnn.layers = { struct(&#39;type&#39;, &#39;i&#39;) %input layer struct(&#39;type&#39;, &#39;c&#39;, &#39;outputmaps&#39;, 6, &#39;kernelsize&#39;, 5) %convolution layer struct(&#39;type&#39;, &#39;s&#39;, &#39;scale&#39;, 2) %sub sampling layer struct(&#39;type&#39;, &#39;c&#39;, &#39;outputmaps&#39;, 12, &#39;kernelsize&#39;, 5) %convolution layer struct(&#39;type&#39;, &#39;s&#39;, &#39;scale&#39;, 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, &#39;Too big error&#39;);```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand(&#39;state&#39;,0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, &#39;Too big error&#39;);%% ex2 neural net with L2 weight decayrand(&#39;state&#39;,0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, &#39;Too big error&#39;);%% ex3 neural net with dropoutrand(&#39;state&#39;,0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, &#39;Too big error&#39;);%% ex4 neural net with sigmoid activation functionrand(&#39;state&#39;,0)nn = nnsetup([784 100 10]);nn.activation_function = &#39;sigm&#39;; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, &#39;Too big error&#39;);%% ex5 plotting functionalityrand(&#39;state&#39;,0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = &#39;softmax&#39;; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, &#39;Too big error&#39;);%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand(&#39;state&#39;,0)nn = nnsetup([784 20 10]); nn.output = &#39;softmax&#39;; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, &#39;Too big error&#39;);```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

前端面试题——0.1+0.2为什么不等于0.3?

0.1+0.2=0.3在我们的日常生活中是简单到不用动脑子就能得出的等式。但是在计算机的世界中恐怕并非如此,你或许在编写代码时见过0.1+0.2=0.30000000000000004,是计算机算错了吗?让我们来探究其背后的原理。

omroji的博客 2039

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

python0.1+0.2不等于0.3_为什么0.1 + 0.2不等于0.3?

原标题:为什么0.1 + 0.2不等于0.3?0.1 + 0.2不等于0.3这是一个普遍的问题,例如在JS控制台输入将得到0.30000000000000004 在python的控制台也是输出这个数: 在C里面运行以下代码,指定输出小数位为57位:printf("%.57f", 0.1 + 0.2);将得到:0.3000000000000000444089209850062616169452667...

weixin_30800249的博客 1722

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

为什么0.1+0.2不等于0.3

首先来看一段诡异的代码: package org.sang.test; /** * @Author: chuxia0811 * @Date: 2021/2/9 22:55 * @Description : */ public class _01_02 { public static void main(String[] args) { float a = 0.1f; float b = 0.2f; System.out.println(a +

初夏0811的博客 2万+

0.1+0.2为什么不等于0.3,以及怎么等于0.3

在开发过程中遇到类似这样的问题: let n1 = 0.1, n2 = 0.2 console.log(n1 + n2) // 0.30000000000000004 这里得到的不是想要的结果,要想等于0.3,就要把它进行转化: (n1 + n2).toFixed(2) // 注意,toFixed为四舍五入 toFixed(num)方法可把 Number 四舍五入为指定小数位数的数字。那为什么会出现这样的结果呢?    计算机是通过二进制的方式存储数据的,所以计算机计算0.1+0.2的时候,实.

Front end development engineer 3万+

为什么 JavaScript 中 0.1 0.2 不等于 0.3 ?

本文首发于 vivo互联网技术 微信公众号 链接:https://mp.weixin.qq.com/s/2kea7-jACCJmSYBQAwXyIg 作者:刘洋 在 js 中进行数学的运算时,会出现0.1+0.2=0.300000000000000004的结果,一开始认为是浮点数的二进制存储导致的精度问题,但这似乎不能很好的解释为什么在同样的存储方式下0.3+0.4=0.7可以得到正确的结...

vivo互联网技术 817

python中0.1+0.2为啥不等于0.3_为什么0.1+0.2不等于0.3?原来编程语言是这么算的……...

打开你的 Python,输入「0.1+0.2=」,结果是多少?0.30000000000000004 对不对?为什么结果不是 0.3?本文作者给出了详细的解释。从小我们就知道 0.1 + 0.2=0.3。但是,在光怪陆离的计算世界中,运算方式却大相径庭。我最近开始用 JavaScript 进行编码,在阅读数据类型时,我注意到 0.1 + 0.2 不等于 0.3 的奇怪行为。我向 Stack Ove...

weixin_34170028的博客 3912

JS中为什么0.1+0.2 不等于0.3

科学计数法 假设有两个数字 220000000000 和 22000000000 一眼看过去好像很难比较出大小 但是使用科学计数法就非常容易进行比较 2.2∗10112.2∗1010 2.2*10^{11}\\ 2.2*10^{10} 2.2∗10112.2∗1010 IEEE 754浮点数表示 Javascript是使用双精度浮点数表示的。 sign:符号位 1表示数字为负数,0表示为正数 (1位) exponent:阶码 (11位) mantissa: 尾数 (52位) 总共64位 看不懂

ZHgogogoha的博客 806

在js里为什么0.1+0.2不等于0.3

在js里为什么0.1+0.2不等于0.31.产生原因2.内部原理扩展 1.产生原因 JS 采用的是双精度版本, 即IEEE 754 双精度版本(64位),这个版本就存在精度问题,就导致了上边这种情况。 在计算机中,数字无论是定点数还是浮点数都是以多位二进制的方式进行存储的。 2.内部原理 我们计算机的信息全部转化为二进制进行存储的,那么0.1的二进制表示的是一个无限循环小数,该版本的 JS 采用的是浮点数标准需要对这种无限循环的二进制进行截取,从而导致了精度丢失,造成了0.1不再是0.1,截取之后0.

cppp1111的博客 4034

70、在js中为什么0.1+0.2不等于0.3

并不是所有小数都可以用「完整」的二进制来表示的,比如十进制 0.1 在转换成二进制小数的时候,是一串无限循环的二进制数,计算机是无法表达无限循环的二进制数的,毕竟计算机的资源是有限。 因此,计算机只能用「近似值」来表示该二进制,那么意味着计算机存放的小数可能不是一个真实值,现在基本都是用 IEEE 754 规范的单精度浮点类型或双精度浮点类型来存储小数的,根据精度的不同,近似值也会不同。 ———————————————— 版权声明:本文为优快云博主「小林coding」的原创文章,遵循CC 4.0 BY-

sunnnnh的博客 1746

为什么 Python 中0.1 + 0.2 不等于 0.3?

print(is_close(0.1 + 0.2, 0.3)) # 输出:True。

pythondh1的博客 2489
上一篇: ABAP 表控制TAKE CONTROL设计
荒芜酥
博客等级 码龄9年 19粉丝 9原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值