精华内容
下载资源
问答
  • 浮点数运算
    2022-05-07 23:00:02

    处理浮点数运算不精确的问题

    BigDecimal对象(该类常用来解决浮点数运算不精确的问题)

    代码测试:

    package cn.tedu.api;
    
    import java.math.BigDecimal;
    import java.util.Scanner;
    public class TestBigDecimal {
        public static void main(String [] args){
            f1();//使用普通的四则运算
            f2();//使用BigDecimal解决浮点数不精确的问题
        }
        public static void f1(){
            System.out.println("请你输入两个小数:");
            double a=new Scanner(System.in).nextDouble();
            double b=new Scanner(System.in).nextDouble();
            System.out.println(a+b);
            System.out.println(a-b);
            System.out.println(a*b);
            System.out.println(a/b);
        }
        public static void f2(){
            System.out.println("请你输入两个小数:");
            double a=new Scanner(System.in).nextDouble();
            double b=new Scanner(System.in).nextDouble();
            System.out.println(new BigDecimal(a+"").add(new BigDecimal(b+"")));
            System.out.println(new BigDecimal(a+"").subtract(new BigDecimal(b+"")));
            System.out.println(new BigDecimal(a+"").multiply(new BigDecimal(b+"")));
            System.out.println(new BigDecimal(a+"").divide(new BigDecimal(b+""),3,BigDecimal.ROUND_HALF_UP));
        }
    }

    更多相关内容
  • 最近在做项目的时候,涉及到产品价格的计算,经常会出现JS浮点数精度问题,这个问题,对于财务管理系统的开发者来说,是个非常严重的问题(涉及到钱相关的问题都是严重的问题),这里把相关的原因和问题的解决方案...
  • 本文主要讲了关于三菱PLC浮点数运算指令的一些相关知识,希望对你的学习有所帮助。
  • 浮点数运算[定义].pdf

    2021-10-28 17:55:05
    浮点数运算[定义].pdf
  • 7算术运算包括字符串到浮点数浮点数到字符串的转换,加、减、乘、除四则运算等。要有说明文档,包括算法证明、程序框图、使用方法、特殊处理(溢出、数位扩展)、实例分析等等。字符串转换可能稍难。typedef ...
  • Python 浮点数运算

    2021-01-30 00:16:47
    浮点数用来存储计算机中的小数,与现实世界中的十进制小数不同的是,浮点数通过二进制的形式来表示一个小数。在深入了解浮点数的实现之前,先来看几个 Python 浮点数计算有意思的例子:0.1 == 0....

    浮点数用来存储计算机中的小数,与现实世界中的十进制小数不同的是,浮点数通过二进制的形式来表示一个小数。在深入了解浮点数的实现之前,先来看几个 Python 浮点数计算有意思的例子:

    0.1 == 0.10000000000000000000001

    True

    0.1+0.1+0.1 == 0.3

    False

    IEEE 浮点数表示法

    这些看起来违反常识的“错误”并非 Python 的错,而是由浮点数的规则所决定的,即使放到其它语言中结果也是这样的。要理解计算机中浮点数的表示规则,先来看现实世界中十进制小数是如何表示的:

    1.234 = 1 + 1/10 + 2/100 + 3/1000

    可以用下面的公式来表示:

    $$d = \sum_{i=-n}^m10^i*d_i$$

    其中 $d_i$ 是十进制中 0~9 的数字。而如果是一个二进制的小数:

    1.001 = 1 + 0/2 + 0/4 + 1/8

    可以用下面的公式来表示:

    $$d = \sum_{i=-n}^m2^i*d_i$$

    其中 $d_i$ 是二进制中的 0 或 1。Python 中的浮点数都是双精度的,也就说采用 64 位来表示一个小数,那这 64 位分别有多少用来表示整数部分和小数部分呢?根据 IEEE 标准,考虑到符号位,双精度表示法是这样分配的:

    $$d = s * \sum_{i=-52}^{11} 2^i*d_i$$

    也就是说用1位表示符号位,11位表示整数部分,52位表示小数部分。正如十进制中我们无法精确表示某些分数(如10/3),浮点数中通过 d1/2 + d2/4 + ... 的方式也会出现这种情况,比如上面的例子中,十进制中简单的 0.1 就无法在二进制中精确描述,而只能通过近似表示法表示出来:

    (0.1).as_integer_ratio()

    (3602879701896397, 36028797018963968)

    也就是说 0.1 是通过 3602879701896397/36028797018963968 来近似表示的,很明显这样近似的表示会导致许多差距很小的数字公用相同的近似表示数,例如:

    (0.10000000000000001).as_integer_ratio()

    (3602879701896397, 36028797018963968)

    在 Python 中所有这些可以用相同的近似数表示的数字统一采用最短有效数字来表示:

    print(0.10000000000000001)

    0.1

    浮点数运算

    既然有些浮点数是通过近似值表示的,那么在计算过程中就很容易出现误差,就像最开始的第二个例子一样:

    a = .1 + .1 + .1

    b = .3

    print(a.as_integer_ratio())

    print(b.as_integer_ratio())

    print(a == b)

    (1351079888211149, 4503599627370496)

    (5404319552844595, 18014398509481984)

    False

    为了解决运算中的问题,IEEE 标准还指定了一个舍入规则(round),即 Python 中内置的 round 方法,我们可以通过舍入的方式取得两个数的近似值,来判断其近似值是否相等:

    round(a, 10) == round(b, 10)

    True

    当然这种舍入的方式并不一定是可靠的,依赖于舍入的选择的位数,位数太大,就失去了 round 的作用,太小,就会引入别的错误:

    print(round(a, 17) == round(b, 17))

    print(round(0.1, 1) == round(0.111, 1))

    False

    True

    Python 中使用更精确的浮点数可以通过 decimal 和 fractions 两个模块,从名字上也能猜到,decimal 表示完整的小数,而 fractions 通过分数的形式表示小数:

    from decimal import Decimal

    a = Decimal(0.1)

    b = Decimal(0.1000000000000001)

    c = Decimal(0.10000000000000001)

    print(a)

    print(b)

    print(c)

    a == b == c

    0.1000000000000000055511151231257827021181583404541015625

    0.10000000000000010269562977782697998918592929840087890625

    0.1000000000000000055511151231257827021181583404541015625

    False

    from fractions import Fraction

    f1 = Fraction(1, 10) # 0.1

    print(float(f1))

    f3 = Fraction(3, 10) # 0.3

    print(float(f3))

    print(f1 + f1 + f1 == f3)

    0.1

    0.3

    True

    总结

    浮点数这些奇特的特性让我们不得不在使用的时候格外注意,尤其是当有一定的精度要求的情况下。如果真的是对精度要求较高且需要频繁使用浮点数,建议使用更专业的 SciPy 科学计算包。

    f500caf0a527bb29a97fcb3d8725d074.png

    展开全文
  • 可支持浮点数与负数的字符串运算代码,可做收藏、学习、研究。
  • 浮点数运算

    千次阅读 多人点赞 2020-04-09 00:53:43
    今天学习了浮点数运算(加减乘除)。浮点数运算主要包括两部分:指数运算和尾数运算。在IEEE754标准下,指数运算就是阶码的运算,类似于无符号数运算。尾数运算是原码运算。之前一直很疑惑为什么前面的教材在介绍...

          今天学习了浮点数运算(加减乘除)。浮点数运算主要包括两部分:指数运算和尾数运算。在IEEE754标准下,指数运算就是阶码的运算,类似于无符号数运算。尾数运算是原码运算。之前一直很疑惑为什么前面的教材在介绍原码运算(加减乘除)所举的例子都是小数运算。现在猜想那部分内容可能只是为了浮点数运算做铺垫,这里才是主要的内容。(当然知识是不分重点的,但考试分)。下面就来详细介绍下浮点数运算的过程吧!另外本文使用的浮点数标准均为IEEE754结构,即单精度数由1位符号位,8位指数位,23位尾数位共计32位组成。

    一、浮点数的加减运算:

           浮点数的加减运算分为5个步骤:对阶、尾数相加、尾数规格化、尾数舍入处理、溢出判断处理。下面详细介绍:

    1. 对阶:

          所谓对阶,就是让两个操作数阶数相同,以便进行加减。实现的方式是对较小数的尾数进行右移操作。对阶的原则是向高阶看齐。计算公式为:
    在这里插入图片描述
          当结果大于0说明被加数(被减数)阶数高,则对加数(减数)进行移位对阶。小于0则反之改变被加数(被减数)。

    2. 尾数加减:

          将两个操作数的尾数相加减。值得注意的是:在IEEE754标准中,对于规格化数来说在小数点前有一位隐藏位1,在加减过程中需要把它还原到尾数中。尾数加减的实质是原码的加减,对于原码加减的规则如下图所示:

    在这里插入图片描述

    3. 尾数规格化:

          加减完成的尾数形式未必满足IEEE754对于尾数的要求,即保留23位,小数点在第一个1之后。需要对尾数进行左规和右规,下面介绍一下左规和右规。

          左规:将尾数向左移,用于清除第一个1前面出现的0。左规伴随着阶码减少,在左规过程中要检测阶码是否发生下溢,即阶码达到最小值(0000 0000)。

          右规:将尾数向右移,用于两数相加后出现向高位进位的情况。因为两数相加最多进一位,所以右规最多一位。右规伴随着阶码的增加,在右规过程中要检测阶码是否发生上溢,即阶码达到最大值(1111 1111)。

    4. 尾数的舍入处理:

          在对阶和右规的时候,最右边的数字会被移出。为了保证最后计算的精度,把这些数字在过程中保存,等到最后进行舍入。也就是我上文提到的附加位。有两个问题值得注意:

          1) 保留多少附加位合适?

          2)最终对附加位怎么进行舍入?

          在IEEE754中保留了保护位,舍入位,粘位三位作为附加位。同时对于IEEE754来说最后附加位的舍入,有如下规则:
    在这里插入图片描述

    5. 溢出判断:

          在浮点数中是以阶码的溢出与否来作为评判标准的。单精度溢出分为上溢(指数大于等于127)和下溢(指数小于等于-126)。

          插一句:“之前一直以为下溢的指数是-149,这个数字来源于-126再把所有的尾数向右移,当到达-149时刚刚好所有尾数全部为零,即表示零。这个误区在于没有正确的区分规格化数和非规格化数。对于规格化数而言,下溢就是-126,所以规格化数表示的最小值为1.00…乘2的-126次方,而0~0.111…乘2的-126次方就是非规格化数表示的范围。-149正是非规格化数表示的最小范围。这里贴一张图,更加便于理解。

    在这里插入图片描述
          下面直接粘贴一个书上的实例,对以上过程进一步加深了解:
    在这里插入图片描述

    二、浮点数乘除运算:

          浮点数乘除和定点数乘除相同,在正式运算前会对操作数进行预处理。对于乘法如果有一个操作数为0则结果为0。对于浮点数除法,若被除数为0,则结果为0。除数为0分两种情况,第一种是被除数非零,第二种是被除数为0。下面着重介绍一下两种除数为0:
          除数为0,被除数不为0:
             结果为无穷大。在IEEE 754标准下就是阶码全为1,尾数全为0。C语言输出如下图:
    在这里插入图片描述
          除数为0,被除数为0:
             结果是NAN(not a number)。在IEEE 754标准下就是阶码全为1,尾数非0。在C语言中输出如下图:
    在这里插入图片描述
          注:在Windows系统下,-1.#IND00即代表nan,Linux系统下会输出nan。

          下面详细介绍无特殊情况浮点数的乘除运算:

          浮点数乘除运算公式如下图:
    在这里插入图片描述

       1.浮点数的乘法:

             点数的乘法运算主要分为四步:尾数相乘指数相加、尾数规格化、尾数舍入处理、溢出处理判断。

           1)尾数相乘,指数相加:

             尾数相乘即为原码相乘,这个具体的过程请参考另一篇文章:定点数运算(于文末给出网址)值得注意的是,对于规格化浮点数要记得恢复隐藏位。指数相加可以直接运用移码的计算方法:

          2)尾数规格化:

             对于两个操作数的尾数一定都是大于1的(隐藏位导致),所以最终得到的结果,小数点前会有两位共三种情况(01,11,10)。若为01则不需规格化,11和10则需右规一位。注意对于IEEE754标准浮点数乘法不需要左规。

          3)尾数舍入处理:

             两个小数相乘,尾数自然更多,但位置是有限的,需要对尾数进行舍入,具体的舍入规则参照浮点数加减的舍入规则即可。

          4)溢出处理判断:

             乘法的溢出有两种可能:阶码相加减时,以及尾数右规时。右规与上文相同,下面介绍一下阶码溢出的判断标准:
    在这里插入图片描述
          注:Eb是最终的结果,EX和EY是操作数的指数值。

       2.浮点数除法:

          浮点数除法大致分为4步:尾数相除阶相减、尾数规格化、尾数舍入、溢出判断处理。由于除法大部分与乘法相似,所以此处只列出不同部分。

         在尾数相除阶相减过程中,尾数除法也在上文引用那篇文章中有具体介绍。阶码相减的运算公式如下:
    在这里插入图片描述
          在尾数规格化步骤中:当除法运算完成后,若小数点前为0,则需进行左规以保证小数点前具有隐藏位1。

          对于除法阶码溢出判断的规则如下:
    在这里插入图片描述
          注:Eb为最终结果指数,EXEY为操作数指数。

    补充:在《程序是怎样跑起来的?》书中,对于阶码为什么使用0-127做了一个原因的解释:在计算机中,使用EXCESS系统的方法来同时存储正数和负数。这里面的0-127就是增加幻数之后的数字。幻数选择了127,可记为Excess_127。

    本篇文章对于浮点数运算进行了介绍,因为作者水平有限,可能某些地方理解错误,请高手不吝赐教,批评指正,谢谢!

    展开全文
  • 浮点数运算案例

    千次阅读 2020-03-31 17:35:24
    浮点数运算案例

    浮点数运算案例


    前面有写过一篇面试题博文 0.1+0.2 是否等于 0.3。里面也涉及到浮点数运算。本文来详细列举一个浮点数运算案例。

    浮点数运算五个步骤

    1. 对阶
    原则是小阶对大阶。
    如 0.000101 的科学记数法为 1.012^-4 。
    而 0.0101 的科学记数法为 1.01
    2^-2 。
    小阶就是 -4,大阶就是 -2。
    这里需要把 -4 调整成 -2。则 0.000101 的科学记数法为 0.0101 2^-2 。
    阶数相同了,就可以进行尾数运算。
    那么为什么不用大阶对小阶昵。如果把 0.0101 的科学记数法调整为 1.0
    2^-4。这样就是高位移出。损失的精度更高。

    2. 尾数运算
    对阶完之后,就可以将尾数进行运算了。

    3. 规格化
    规格化指的是对于 IEEE754 标准的浮点数来说,尾数必须是1.M的形式。
    规格化操作分为左规和右规两种情况。
    左规指的就是小数点往左移动,比如 0.000101 变成 1.012^-4。
    右规指的就是小数点往右移动,比如10.001 变成 1.001
    2^1。右规一般只移动一位,发生在进位的情况下。比如二进制 11+1 = 100。

    4. 舍入处理
    舍入其实就是四舍五入。溢出的数为 0 则直接舍去,为 1 则加1。
    比如二进制 011110011 只要保留 8 位。因为最后一位尾数是1,则 01111001+1= 01111010。而 二进制 011110010 如果保留 8 位。最后一位尾数是0,直接舍去。结果为 01111001。

    5. 溢出判断
    溢出判断指阶码值是否产生溢出。
    若阶码值超过了阶码所能表示的最大正数,则为上溢。若此时浮点数为正数,则为正上溢,记为+∞,若浮点数为负数,则为负上溢,记为-∞。
    比如用 8 位表示阶码值。则范围为 2^8-1=255。要考虑负数的情况下,范围为 -127-127,此时的阶码值如果是 128。就是上溢。

    若阶码值超过了阶码所能表示的最小负数,则为下溢,若此时浮点数为正数,则为正下溢,若浮点数为负数,则为负下溢。正下溢和负下溢都作为0处理。
    同样如果用 8 位表示阶码值。存在负数的情况下,范围为 -127-127。而此时的阶码值如果是-128。就是下溢。

    案例

    下面我们来计算一下 0.3+1.6 = 1.9000000000000001。

    将 0.3 转换二进制。浮点数转二进制是乘2取整数部分。

    0.3*2=0.6
    0.6*2=1.2
    0.2*2=0.4
    0.4*2=0.8
    0.8*2=1.6
    0.6*2=1.2(从这里开始循环1001)
    

    结果为 0.0100110011001100(1001)…(1001部分无限循环)
    规格化为:1.001100110011… * 2^-2

    将 1.6 转换二进制。浮点数转二进制是乘2取整数部分。

    0.6*2=1.2
    0.2*2=0.4
    0.4*2=0.8
    0.8*2=1.6
    0.6*2=1.2(从这里开始循环1001)
    

    结果为 1.1001100110011001(1)…(0011部分无限循环)
    规格化为:1.100110011001… * 2^0

    1. 对阶
    0.3 的阶数为 -2,1.1 的阶数为0。所以把 0.3 还原为 0.01001100 * 2^0。

    2. 尾数相加
    因为 64 位表示二进制需要四舍五入。
    所以 0.3 的二进制需要进一位。
    0. 0100 1100 1100 1100 1100 1100 1100 1100 1100 1100 1100 1100 1100(1)
    结果为
    0. 0100 1100 1100 1100 1100 1100 1100 1100 1100 1100 1100 1100 1101

    同理1.6 的二进制也需要进一位。
    1.1001 1001 1001 1001 1001 1001 1001 1001 1001 1001 1001 1001 1001(1)
    结果为
    1.1001 1001 1001 1001 1001 1001 1001 1001 1001 1001 1001 1001 1010

    相加:
    0. 0100 1100 1100 1100 1100 1100 1100 1100 1100 1100 1100 1100 1101
    +1.1001 1001 1001 1001 1001 1001 1001 1001 1001 1001 1001 1001 1010
    1.1110 0110 0110 0110 0110 0110 0110 0110 0110 0110 0110 0110 0111

    3. 格式化
    格式化指的就是1*M的形式,这里已经是格式化的数据了。

    4. 舍入处理
    由于 0.3 二进制小数点右移了2位。且第一位为1。所以需要进1。
    结果为
    1.1110 0110 0110 0110 0110 0110 0110 0110 0110 0110 0110 0110 1110

    5.溢出判断
    由于没有溢出,这里不需要做溢出判断。

    所以最后的结果用 64 位表示为:
    因为是正数,所以首位用 0 表示。
    整数部分为 2^(11-1)-1+(-2)=1021。用二进制表示为 01111111101
    小数部分为 1110 0110 0110 0110 0110 0110 0110 0110 0110 0110 0110 0110 1110
    所以(0.3)+(1.6)=
    0 01111111101 1110 0110 0110 0110 0110 0110 0110 0110 0110 0110 0110 0110 1110
    转换为10进制为:1.9000000000000001

    展开全文
  • 浮点数运算,三菱浮点数运算,C,C++源码
  • 不用浮点数指令,基于IEEE754数据格式,在MARS上运行了用mips语言实现的加减乘除。我测试的结果是正确的。
  • 浮点数运算.zip三菱PLC编程案例源码资料编程控制器应用通讯通信例子程序实例浮点数运算.zip三菱PLC编程案例源码资料编程控制器应用通讯通信例子程序实例浮点数运算.zip三菱PLC编程案例源码资料编程控制器应用通讯...
  • 计算机智能处理可数集合的运算,但是全体实数是不可数的,所以计算机只能用一些...下面这篇文章主要给大家介绍了关于python中实现精确浮点数运算的相关资料,需要的朋友可以参考借鉴,下面随着小编来一起学习学习吧。
  • 4.定点数模拟浮点数运算及常见的策略  相信大家到现在已经大致明白了浮点数转换成定点数运算的概貌。其实,原理讲起来很简单,真正应用到实际的项目中,可能会遇到各种各样的问题。具我的经验,常见的策略有如下几...
  • 最近在做一个项目,页面上会存在一些JS浮点数的运算,发现JS浮点数运算存在一些bug.譬如: 0.1+0.2 == 0.30000000000000004 0.1 + 0.7 == 0.7999999999999999 7*0.8 == 5.6000000000000005 5.6/7 == 0....
  • 然而要命的是,当浮点数做数学运算的时候,你经常会发现一些问题,举几个例子: // 加法 ===================== // 0.1 + 0.2 = 0.30000000000000004 // 0.7 + 0.1 = 0.7999999999999999 // 0.2 + 0.4 = 0.600
  • 本文实例讲述了Python双精度浮点数运算并分行显示操作。分享给大家供大家参考,具体如下: #coding=utf8 def doubleType(): ''''' Python中的浮点数是双精度浮点数,可以用十进制或科学计数法表示。 实际精度...
  • 本篇文章主要介绍了JS--浮点数运算处理,现在分享给大家,也给大家做个参考。感兴趣的小伙伴们可以参考一下。
  • 本文实例分析了php中让人头疼的浮点数运算。分享给大家供大家参考,具体如下: 在做电商的时候,计算价格是免不了的,然后发现了php的一个坑,口算应该正确的值,php运算出来会跟你不一样 请看下面的代码: $price=...
  • 对方给出的485通讯协议需要用到IEEE754标准的单精度浮点数运算,需要将十进制的数据转化为十六进制进行填充MODBUS RTU指令,对电源产品设置电压电流等数据,同时也需要实时请求,采集下位机的电压电流功率等数据进行...
  • 基于FPGA的浮点数运算

    千次阅读 2019-12-31 21:17:19
    在计算浮点数运算时候需要转换为定点数 3.14转换为二级制为:11.00100011 自己定义可以表示为:0_00000011_00100011 最高位为符号位 中间8位为整数部分 最后8位是小数部分 2、IEEE 754二进制浮点数算术标准 两种...
  • 计算机中单精度浮点数运算详解

    千次阅读 2021-07-24 00:49:43
    写在前面在PA_2019fall中有一项任务是完成CPU中的浮点数运算,这也是我第一次认真的思考了一下真实的计算机中CPU是如何进行的浮点数运算在写PA的过程中一头雾水,从迷茫,到困惑,到弄懂,到完成,中间经历了各种...
  • 主要介绍了Python如何执行精确的浮点数运算,文中讲解非常细致,代码帮助大家更好的理解和学习,感兴趣的朋友可以了解下
  • 必须阶码一致才可以进行浮点数运算
  • python浮点数运算问题

    千次阅读 2020-07-22 19:51:50
    在python中对于一些浮点数运算结果,往往出现一些意想不到的结果,该博客主要讲解导致这样的原因以及解决办法。
  • 浮点数运算——加减乘除都有哈

    千次阅读 2021-10-13 19:36:46
    浮点数运算异常 IEEE 754 标准规定的五种异常情况 浮点数除0的问题 浮点数加减运算 浮点数乘除运算 导读:浮点数运算是一个非常有技术含量的话题,不太容易掌握。许多程序员都不清楚使用==...
  • Java中如何正确进行浮点数运算

    千次阅读 2021-06-12 23:01:27
    1、浮点数不是精确存储 参考: 关于浮点数存储 System.out.println(0.1+0.2); System.out.println(1.0-0.8); System.out.println(4.015*100); System.out.println(123.3/100); double amount1 = 2.15; ...
  • 在javascript中进行运算的时候经常会出现浮点数的问题,导致运算结果不准确 比如:0.1 + 0.2 = 0.30000000000000004 完整demo及解决方案如下: demo .num-tags, .total-tag { text-align: center; } i { ...
  • 浮点数运算指令包括:浮点加/减/乘/除说明、平方根SQRT、正弦SIN、余弦COS、正切TAN、自然对数LN、自然指数EXP。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 174,466
精华内容 69,786
关键字:

浮点数运算