精华内容
下载资源
问答
  • JavaScript封装double双精度计算

    千次阅读 2018-08-31 16:49:36
    //动态控制精度长度 n=(r1>=r2)?r1:r2; return ((arg1*m-arg2*m)/m); //.toFixed(n) } /** * 乘 * @param {Object} arg1 * @param {Object} arg2 */ NumberUtil.fn.mul = function(arg1,arg2)...
    function NumberUtil(obj) {
        return this;
    };
    NumberUtil.fn = NumberUtil.prototype;
    
    /**
     * 提供实例对外
     */
    var NumUtil = new NumberUtil();
    window.NumUtil = NumUtil;
    
    /**
     * 加
     * @param {Object} arg1
     * @param {Object} arg2
     */
    NumberUtil.fn.add = function(arg1,arg2){    
         var r1,r2,m;    
         try{r1=arg1.toString().split(".")[1].length}catch(e){r1=0}    
         try{r2=arg2.toString().split(".")[1].length}catch(e){r2=0}    
         m=Math.pow(10,Math.max(r1,r2));    
         return (arg1*m+arg2*m)/m;    
    }    
    
    /**
     * 减
     * @param {Object} arg1
     * @param {Object} arg2
     */
    NumberUtil.fn.sub = function(arg1,arg2){    
        var r1,r2,m,n;    
        try{r1=arg1.toString().split(".")[1].length}catch(e){r1=0}    
        try{r2=arg2.toString().split(".")[1].length}catch(e){r2=0}    
        m=Math.pow(10,Math.max(r1,r2));    
        //动态控制精度长度    
        n=(r1>=r2)?r1:r2;    
        return ((arg1*m-arg2*m)/m);  //.toFixed(n)  
    }    
    
    /**
     * 乘
     * @param {Object} arg1
     * @param {Object} arg2
     */
    NumberUtil.fn.mul = function(arg1,arg2)   {     
        var m=0,s1=arg1.toString(),s2=arg2.toString();     
        try{m+=s1.split(".")[1].length}catch(e){}     
        try{m+=s2.split(".")[1].length}catch(e){}     
        return Number(s1.replace(".",""))*Number(s2.replace(".",""))/Math.pow(10,m);     
    }     
    /**
     * 除
     * @param {Object} arg1
     * @param {Object} arg2
     */
    NumberUtil.fn.div = function(arg1,arg2){     
          var t1=0,t2=0,r1,r2;     
          try{t1=arg1.toString().split(".")[1].length}catch(e){}     
          try{t2=arg2.toString().split(".")[1].length}catch(e){}
          r1=Number(arg1.toString().replace(".",""));  
          r2=Number(arg2.toString().replace(".",""));     
          return (r1/r2)*Math.pow(10,t2-t1);
    }  
    /**
     * 四舍五入,保留指定位数
     * @param {Object} num
     * @param {Object} n
     */
    NumberUtil.fn.round = function(num,n){
        n=n||2;
        if(isNaN(num)||num=="") return 0;
        return Math.round(num*Math.pow(10,n))/Math.pow(10,n);
    };
    
    展开全文
  • Apex 一键混合双精度计算

    千次阅读 2019-10-10 14:29:46
    针对单一Optimizer使能AMP 对于单一Optimizer,使能AMP只需要以下修改两部分即可: 1. 代码中Optimizer之后添加: optimizer = # ... some optimizer from apex import amp ...amp_handle = amp.init() ...# ......

    针对单一Optimizer使能AMP

    对于单一Optimizer,使能AMP只需要以下修改两部分即可:

    1. 代码中Optimizer之后添加:

    optimizer = # ... some optimizer

    from apex import amp

    amp_handle = amp.init()

    2. 修改代码中反向迭代部分:

    # ... do a bunch of stuff to compute a loss

    loss.backward()

    optimizer.step()

    # ...finish the iteration

    修改为

    # ... same as before

    with amp_handle.scale_loss(loss, optimizer) as scaled_loss:

    scaled_loss.backward()

    optimizer.step()

    # ... same as before

    针对多Optimizer使能AMP

    多Optimizer使能AMP相较单一Optimizer复杂,需要显性的warp多个Optimizer,并处理多个Loss的反向迭代,例如:

    amp_handle = amp.init()

    optimizer = amp_handle.wrap_optimizer(optimizer, num_loss=2)

    # ...

    optimizer.zero_grad()

    loss1 = ComputeLoss1(model)

    with optimizer.scale_loss(loss1) as scaled_loss:

    scaled_loss.backward()

    # ...

    loss2 = ComputeLoss2(model)

    with optimizer.scale_loss(loss2) as scaled_loss:

    scaled_loss.backward()

    # ...

    optimizer.step()

    AMP添加自定义函数

    在AMP添加自定义函数的支持有两种方法,分别使用Function annotation或者函数显性注册如下所示:

    对于自定义函数Fru

    from backend import FRUBackend

    def fru(input, hidden, weight, bias):

    # call to CUDA code

    FRUBackend(input, hidden, weight, bias)

    使用Function Annotation

    @amp.half_function

    def fru(input, hidden, weight, bias):

    #...

    使用显性注册

    import backend

    amp.register_half_function(backend, 'FRUBackend')

    amp.init()

    此处的Function Annotation有三种类型分别是:

    类似显性注册也有对应三种方式,分别是:

    amp.register_half_function(module, function_name)

    amp.register_float_function(module, function_name)

    amp.register_promote_function(module, function_name)

    这里需要注意的是,采用显性注册需要在amp.init()之前。

    至此,关于AMP的介绍和使用指南已经完全阐明,关于前文留的小问题,还欢迎小伙伴们留言回答哟~~~

    展开全文
  • 下面就来讲讲关于浮点数中,单精度、双精度、多精度和混合精度计算的区别。 嵌入式专栏 1 关于圆周率 π 我们提到圆周率 π 的时候,它有很多种表达方式,既可以用数学常数3.14159表示,也可以用一长串1和0的二进制...

    关注+星标公众,不错过精彩内容

    编排 | strongerHuang

    微信公众号 | 嵌入式专栏

    我们学过数学,都知道有理数和无理数,然后在有理数中有一类叫浮点数的数字,不知道大家对这些还有没有印象?

    在软件编程的时候,我们也会用到浮点数,一种既包含小数又包含整数的数据类型。

    下面就来讲讲关于浮点数中,单精度、双精度、多精度和混合精度计算的区别

    嵌入式专栏

    1

    关于圆周率 π

    我们提到圆周率 π 的时候,它有很多种表达方式,既可以用数学常数3.14159表示,也可以用一长串1和0的二进制长串表示。

    圆周率 π 是个无理数,既小数位无限且不循环。因此,在使用圆周率进行计算时,人和计算机都必须根据精度需要将小数点后的数字四舍五入。

    在小学的时候,小学生们可能只会用手算的方式计算数学题目,圆周率的数值也只能计算到小数点后两位——3.14;而高中生使用图形计算器可能会使圆周率数值排到小数点后10位,更加精确地表示圆周率。在计算机科学中,这被称为精度,它通常以二进制数字来衡量,而非小数。

    对于复杂的科学模拟,开发人员长期以来一直都依靠高精度数学来研究诸如宇宙大爆炸,或是预测数百万个原子之间的相互作用。

    数字位数越高,或是小数点后位数越多,意味着科学家可以在更大范围内的数值内体现两个数值的变化。借此,科学家可以对最大的星系,或是最小的粒子进行精确计算。

    但是,计算精度越高,意味着所需的计算资源、数据传输和内存存储就越多。其成本也会更大,同时也会消耗更多的功率。

    由于并非每个工作负载都需要高精度,因此 AI 和 HPC 研究人员可以通过混合或匹配不同级别的精度的方式进行运算,从而使效益最大化。NVIDIA Tensor Core GPU 支持多精度和混合精度技术,能够让开发者优化计算资源并加快 AI 应用程序及其推理功能的训练。

    嵌入式专栏

    2

    单精度、双精度和半精度浮点格式之间的区别

    IEEE 浮点算术标准是用来衡量计算机上以二进制所表示数字精度的通用约定。在双精度格式中,每个数字占用64位,单精度格式占用32位,而半精度仅16位。

    要了解其中工作原理,我们可以拿圆周率举例。在传统科学记数法中,圆周率表示为3.14 x100。但是计算机将这些信息以二进制形式存储为浮点,即一系列的1和0,它们代表一个数字及其对应的指数,在这种情况下圆周率则表示为1.1001001 x 21。

    在单精度32位格式中,1位用于指示数字为正数还是负数。指数保留了8位,这是因为它为二进制,将2进到高位。其余23位用于表示组成该数字的数字,称为有效数字。

    而在双精度下,指数保留11位,有效位数为52位,从而极大地扩展了它可以表示的数字范围和大小。半精度则是表示范围更小,其指数只有5位,有效位数只有10位。

    圆周率在每个精度级别表现如下:

    嵌入式专栏

    3

    多精度和混合精度计算的差异

    多精度计算意味着使用能够以不同精度进行计算的处理器,在需要使用高精度进行计算的部分使用双精度,并在应用程序的其他部分使用半精度或单精度算法。

    混合精度(也称为超精度)计算则是在单个操作中使用不同的精度级别,从而在不牺牲精度的情况下实现计算效率。

    在混合精度中,计算从半精度值开始,以进行快速矩阵数学运算。但是随着数字的计算,机器会以更高的精度存储结果。例如,如果将两个16位矩阵相乘,则结果为32位大小。

    使用这种方法,在应用程序结束计算时,其累积得到结果,在准确度上可与使用双精度算法运算得到的结果相媲美。

    这项技术可以将传统的双精度应用程序加速多达25倍,同时减少了运行所需的内存、时间和功耗。它可用于 AI 和模拟 HPC 工作负载。

    随着混合精度算法在现代超级计算应用程序中的普及,HPC 专家 Jack Dongarra 提出了一个新的基准,即 HPL-AI,以评估超级计算机在混合精度计算上的性能。

    混合精度计算主要用于现在很火人工智能领域,感兴趣的读者可以上网搜索更多关于混合精度计算的内容。

    ------------ END ------------

    推荐阅读:

    C语言预处理命令分类和工作原理

    浅谈Makefile、Kconfig和.config文件

    FreeRTOS中相对延时和绝对延时的区别

    关注微信公众号『嵌入式专栏』,底部菜单查看更多内容,回复“加群”按规则加入技术交流群。

    点击“阅读原文”查看更多分享,欢迎点分享、收藏、点赞、在看。

    展开全文
  • 计算机中float, double类型数据分别占据4,8个字节,其中float类型和double可以表示的小数位数不同,导致了精度不同。double的精度更高。 计算机中数据的表示由:符号位, 指数位,尾数位组成。比如一个float类型...

    计算机中float, double类型数据分别占据4,8个字节,其中float类型和double可以表示的小数位数不同,导致了精度不同。double的精度更高。

    计算机中数据的表示由:符号位, 指数位,尾数位组成。比如一个float类型数字的二进制由左到右依次是符号位,指数位,尾数位。

    类型符号位指数位尾数位总位数(bit)
    float182332
    double1115264

    数字1.4在计算机中的存储转换如下:

    先将整数和小数都变二进制表示:1.0110 0110 0110 0110 0110 011,然后整数部分不需要右移,所以float的指数位=2*7-1+0=127;double的指数位=2*10-1+0=1023。各个部分的二进制表示如下。

     

    1.4的不同存储符号位指数位尾数位16进制表示
    float0011111110110 0110 0110 0110 0110 0113FB33333
    double0011111111110110 0110 0110 0110 0110 0110 0110 0110 0110 0110 0110 0110 01103FF6666666666666


     

    在c++单精度和双精度的运算结合如下两个test示例理解如下:

    #include <iostream>
    
    float f1 =1.4;
    float f2 = 5.0;
    float f3 = 7.0;
    int i = 7;
    using namespace std;
    
    void test1()
    {
    	printf("test %f %f %f\n", f1 * f2, f1 * 5.0, f3 / f1);
        cout << (f1 * f2 == i) << '\t' << (f1 * f2 == f3) << endl;
        cout << (f1 * 5.0f == f3) << '\t' << (f1 * f2 == f1 * 5.0f) << endl;
        cout << (f3 / f1 == 5.0) << '\t' << (f3 / f1 == f2);
    }
    
    void test2()
    {
    	printf("test %f %f %f\n", f1 * f2, f1 * 5.0, f3 / f1);
        cout << (f1 * f2 == i) << '\t' << (f1 * f2 == f3) << endl;
        cout << (f1 * 5.0 == f3) << '\t' << (f1 * f2 == f1 * 5.0) << endl;
        cout << (f3 / f1 == 5.0) << '\t' << (f3 / f1 == f2);
    }
    int main(void)
    {
    	cout<<"test1"<<endl;
    	test1();
    	cout<<endl<<"test2"<<endl;
    	test2();
    	
    	cout<<endl<<endl<<"验证输出"<<endl;
    	double f11=1.4;
    	cout<<"sizeof(5.0)="<<sizeof(5.0)<<", sizeof(f1*f2)=" <<sizeof(f1*f2)<<", sizeof(f3/f1)=" <<sizeof(f3/f1)<<endl;
    	cout.precision(20);
    	cout<<"1.4的单精度 f1="<<f1<<endl<<"1.4的双精度 f11="<<f11<<endl;
    	cout<<"双精度转单精度 double2float: "<<float(f11)<<endl;
    	cout<<"单精度转双精度 float2double: "<<double(f1)<<endl;
    
        cout<<"单精度*单精度 f1*5.0f="<<f1*5.0f<<", 单精度*双精度 f1*5.0="<<f1*5.0<<", 双精度*双精度 f11*5.0="<<f11*5.0<<endl;
        cout<<"当单精度*单精度结果有小数时候:"<<endl; 
        cout<<"单精度*单精度 f1*6.0f="<<f1*6.0f<<", 单精度*双精度 f1*6.0="<<f1*6.0<<", 双精度*双精度 f11*6.0="<<f11*6.0<<endl;
        
        cout<<endl<<"i.和j. 的验证:"<<endl;
        cout<<"f3/f2==1.4 =>"<< (f3/f2==1.4)<<",  f3/f2==f1 =>"<<(f3/f2==f1)<<endl;
        
        cout<<endl<<"d.的假设验证:"<<endl;
        cout<<"float(f1*5.0)==i =>"<<(float(f1*5.0)==i)<<endl;
        f1=0.125;
        cout<<"f1 * 56.0 == i =>"<< (f1 * 56.0 == i)<<endl;
    	return 0;
    
    
    }

    test1和test2的两段代码涉及的是float类型和double类型数据在计算机中的存储问题。

    用到的基础知识:

    1, C++中默认5.0是一个double类型,5.0f表示指定这是一个float类型的数字。

    2, 精度(float*double)=> double*double=精度(double), 精度(float*float)=精度(float), 精度(double*double)=精度(double)

    3,  float类型用4个字节表示,double类型用8个字节表示,double可以用更多的位表示小数点部分(这部分知识可以参考数字在计算机中的表示,https://blog.csdn.net/ultrakang/article/details/39322275),所以有小数的情况下,double比float精度更高。而float转double精度不变,double转float精度降低。

    4,float和double转换中精度降低的情况只作用在存在小数位情况。且只存在于小数位的非0尾数大于23bit情况下(因为float尾数是23个bit, double尾数是52个bit)。

     

    再来看本例中给定的数据 f1=1.4; f2=5.0; f3=7.0; i=7。共进行了如下的运算结果比对,跟着对应的结果分析。

    a.  f1 * f2 == i       =》1,左边 f1*f2 等效于 float*float,结果仍然是float,恰好是整数,所以f1 * f2 == i 成立。

    b.  f1 * f2 == f3     =》1,左边 同 a. ,右边f3是float类型,不涉及数据类型转换,精度不变,所以f1 * f2 == f3 成立。

    c.  f1 * 5.0f == i    =》1,左边 f1*5.0f 等效于float*float,其它同a. ,所以f1 * 5.0f == i  成立 。

    d.  f1 * 5.0 == i    =》0,左边 f1*5.0等效于double*double, f1=1.4,1.4作为float和double两种类型在计算机存储的精度是不同的,并且结果也是double类型,精度更高,所以f1 * 5.0 == i 不成立,如果将f1*5.0转换成float类型则成立,即:float(f1*5.0)==i 成立。或者将本例中f1=1.4换成f1=0.125(即一个小数点位数可在23bit之内表示的数 , 则f1 * 56.0 == i 成立,因为0.125值的float和double类型在计算机存储中是一样的。

    e.  f1 * f2 == f1 * 5.0f   =》1,右边f1 * 5.0f是float*float,不涉及类型转换问题,同b. 所以f1 * f2 == f1 * 5.0f 成立。

    f.   f1 * f2 == f1 * 5.0   =》0,右边同d. 1.4在计算机中作为float和double表示的精度不同,f1*5.0是double*double=double,比f1*f2的float*float=float精度更高,所以f1 * f2 == f1 * 5.0不成立。

    g.  f3 / f1 == 5.0     =》1,  左边float/foat=float,结果用float类型表示,小数位尾数为0,右边double类型的5.0的小数位尾数也都是0,所以f3 / f1 == 5.0 成立。可以结合下面的 i. 来理解。

    h.  f3 / f1 == f2      =》1, 左边和右边都是float类型,精度不变,所以 f3 / f1 == f2成立。可以结合下面的j. 来理解。

    补充:

    i.  f3 / f2 == 1.4   =》0, 左边结果float类型,右边1.4是double类型,精度不同,所以f3 / f2 == 1.4不成立。

    j. f3 / f2 == f1   =》1,右边类型是float,1.4用float表示,不涉及精度降低问题,所以f3 / f2 == f1 成立。

    cout默认打印出7位有效数字,所以第一行打印的结果都一样。

    上面的验证结果如图:

    展开全文
  • java-双精度数据计算和展示

    千次阅读 2019-01-17 20:49:39
    精度计算,一般使用double或者bigdecimal; 使用双精度Double方式如下:  // 第一步 将数字转化为Double格式  Double a = Double.valueOf(("0000001110000.01")); //高并发下,计算对象使用内存堆,...
  • 大致原因是M40是单精度的浮点数的运算,P4是双精度,在双精度上的计算结果用在单精度上运行,运算精度不一样,所以计算偏差比较大,导致的结果不一致。特别是乘除法的矩阵运算,结果运算偏差会很大。 解决方式是模型...
  •      C语言和C#语言中,对于浮点类型的数据采用单精度类型(float)和双精度类型(double)来存储,float数据占用32bit,double数据占用64bit。单精度类型和双精度类型在计算机存储格式如下所示: 图1 浮点类型的...
  • IEEE754字节转单精度/双精度浮点数
  • 浮点数是计算机上最常用的数据类型之...半精度是英伟达在2002年搞出来的,双精度和单精度是为了计算,而半精度更多是为了降低数据传输和存储成本。 很多场景对于精度要求也没那么高,例如分布式深度学习里面,如果...
  • MCU: STM32F767,启动硬件双精度浮点运算协处理器 IDE: Keil RVMDK V5.21.1.0 测试方法 浮点数0.1分别以单精度与双精度累加1000000次,打印输出累加结果。 测试代码 double dVal = 0; float fVal = 0; for(int i ...
  • JS中使用IEEE-754规定的双精度浮点数,所有的算法也都符合IEEE-754规定的双精度浮点数运算。 双精度浮点数是一种64位(64 bit)的二进制数字格式。包括3个组成部分: 符号位 1位 阶码(指数部分) 11位 尾数(有效数...
  • IEEE二进制浮点数算术标准(IEEE 754)是1980年代以来最广泛使用的浮点数运算标准,为许多CPU与浮点运算器所采用。这个标准定义了表示浮点数的格式(包括负零-0)与反常值...本程序就是IEEE-754双精度转换程序
  • 该工具为单精度与双精度的浮点转换成十进制,或者十进制转换为单精度或双精度的工具,可以验证你的计算方法是否错误。
  • 单精度和双精度的区别

    万次阅读 多人点赞 2019-02-26 16:56:24
    1、单精度和双精度的字节数不同。前者占4个字节;后者占8个字节。 2、单精度和双精度有效数字位数不同。前者为8位;后者为16位。 3、单精度和双精度表示的数的范围不同。前者的数值范围在-3.40E+38 到 +3.40E+...
  • 在C/C++中float是32位的,double是64位的,两者在内存中的存储方式和能够表示的精度均不同,目前C/C++编译器标准都遵照IEEE制定的浮点数表示法来进行float,double运算。 无论是float还是double,在内存中的存储...
  • 主要介绍了Python双精度浮点数运算并分行显示操作,涉及Python数学运算及显示相关操作技巧,注释备有详尽的说明,需要的朋友可以参考下
  • java代码-实训2.编程实现给出5个双精度浮点数,求和,再求平均数。
  • 汇编语言,双精度加法运算

    千次阅读 2019-12-11 08:57:58
    要求计算X+Y=Z,将结果Z输出到屏幕上,其中X=001565A0H,Y=0021B79EH。实验利用累加器AX,先求低十六位和,并存入地址存储单元,后求高16位和,再存入高址存储单元。由于地位可能向高位有进位...二进制双精度加法运算...
  • 单精度float与双精度double

    千次阅读 2020-01-31 17:07:01
    单精度 双精度: 单精度,也即float,一般在计算机中存储占用4字节,也32位,有效位数为7位;双精度(double)在计算机中存储占用8字节,64位,有效位数为16位。 IEEE754规范: 单精度格式:1位符号,8位指数,23...
  • 针对嵌入式处理器对面积要求极为苛刻的特点,提出了一种改进的基于Goldschmidt算法的双精度浮点除法器。 改进的除法算法的计算过程分为两个阶段,第一阶段采用线性minimax多项式逼近算法得到一个具有15-bit精度的...
  • % TOSINGLE - toSingle(doublesOnly) % % 转换调用中的所有数值变量% 工作空间到单精度% % 如果 doublesOnly 非零,那么它只转换% 调用工作区中的双打到单打%
  • 单精度和双精度问题

    千次阅读 2020-08-24 10:46:54
    一,什么是单精度和双精度 单精度数(float)是指计算机表达实数近似值的一种方式。VB中Single(单精度浮点型)变量存储为 IEEE 32 位(4 个字节)浮点数值的形式,它的范围在负数的时候是从 -3.402823E38 到 -1....
  • GROMACS windows双精度5.11版 在cmd下使用,非常方便,适合做能量优化和其他一些小计算量工作 MD最好还是在服务器上运行
  • 二进制双精度加法运算

    千次阅读 2020-10-15 23:45:17
    本实验要求计算 X+Y=Z,将结果 Z 输出到屏幕,其中 X=001565A0H,Y=0021B79EH。     实验利用累加器 AX,先求低十六位和,并存入低址存储单元,后求高 16位和,再存入高址存储单元。由于低位和可能向高位有进位...
  • C语言 单精度和双精度实数输出

    千次阅读 2019-02-04 10:50:26
    C语言 单精度和双精度实数输出 有意义数字和无意义数字的演示
  • 处理器的计算能力如何计算

    万次阅读 2019-08-03 17:50:00
    我们常用双精度浮点运算能力衡量一个处理器的科学计算的能力,就是处理64bit小数点浮动数据的能力 支持AVX2的处理器的单指令的长度是256bit,每个intel核心假设包含2个FMA,一个FMA一个时钟周期可以进行2次乘...
  • 双精度,单精度和半精度

    万次阅读 多人点赞 2017-11-17 09:56:29
    浮点数是计算机上最常用的数据类型之一,有些语言甚至...半精度是英伟达在2002年搞出来的,双精度和单精度是为了计算,而半精度更多是为了降低数据传输和存储成本。 很多场景对于精度要求也没那么高,例如分布式深
  • 单精度浮点数与双精度浮点数区别

    千次阅读 2020-04-06 15:14:35
    单精度浮点数与双精度浮点数区别 1、所占的内存不同 单精度浮点数占用4个字节(32位)存储空间来存储一个浮点数,包括符号位1位,阶码8位,尾数23位。 而双精度浮点数使用 8个字节(64位)存储空间来存储一个浮点数...
  • 从CSV文件中读取双精度数据,对数据进行处理,然后求取改组数据的均值、极值、二阶差分后,最后再存入SCV文件

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 111,092
精华内容 44,436
关键字:

双精度计算