精华内容
下载资源
问答
  • 126) * 0.1 = 2**(-127) 0 00000000 00000000000000000000001 = +1 * 2**(-126) * 0.00000000000000000000001 = 2**(-149) (Smallest positive value) 双精度 IEEE双精度浮点标准表示需要64位字,其可以从左到右表示...

    注意:

    Nintendo 64有一个64位处理器,但是:

    Many games took advantage of the chip’s 32-bit processing mode as the greater data precision available with 64-bit data types is not typically required by 3D games, as well as the fact that processing 64-bit data uses twice as much RAM, cache, and bandwidth, thereby reducing the overall system performance.

    The term double precision is something of a misnomer because the precision is not really double.

    The word double derives from the fact that a double-precision number uses twice as many bits as a regular floating-point number.

    For example, if a single-precision number requires 32 bits, its double-precision counterpart will be 64 bits long.

    The extra bits increase not only the precision but also the range of magnitudes that can be represented.

    The exact amount by which the precision and range of magnitudes are increased depends on what format the program is using to represent floating-point values.

    Most computers use a standard format known as the IEEE floating-point format.

    单精度

    IEEE单精度浮点标准表示需要一个32位字,从左到右可以表示为从0到31编号。

    >第一位是符号位,S,

    >接下来的8位是指数位,’E’和

    >最后23位是分数’F’:

    S EEEEEEEE FFFFFFFFFFFFFFFFFFFFFFF

    0 1 8 9 31

    由字表示的值V可以如下确定:

    >如果E = 255且F为非零,则V = NaN(“不是数字”)

    >如果E = 255且F为零,S为1,则V = -Infinity

    >如果E = 255且F为零,S为0,则V =无穷大

    >如果0

    意在表示通过用F加前缀而创建的二进制数

    隐式前导1和二进制点。

    >如果E = 0且F为非零,则V =( – 1)** S * 2 **(-126)*(0.F)。这些

    是“非规范化”值。

    >如果E = 0且F为零,S为1,则V = -0

    >如果E = 0并且F为零并且S为0,则V = 0

    尤其是,

    0 00000000 00000000000000000000000 = 0

    1 00000000 00000000000000000000000 = -0

    0 11111111 00000000000000000000000 = Infinity

    1 11111111 00000000000000000000000 = -Infinity

    0 11111111 00000100000000000000000 = NaN

    1 11111111 00100010001001010101010 = NaN

    0 10000000 00000000000000000000000 = +1 * 2**(128-127) * 1.0 = 2

    0 10000001 10100000000000000000000 = +1 * 2**(129-127) * 1.101 = 6.5

    1 10000001 10100000000000000000000 = -1 * 2**(129-127) * 1.101 = -6.5

    0 00000001 00000000000000000000000 = +1 * 2**(1-127) * 1.0 = 2**(-126)

    0 00000000 10000000000000000000000 = +1 * 2**(-126) * 0.1 = 2**(-127)

    0 00000000 00000000000000000000001 = +1 * 2**(-126) *

    0.00000000000000000000001 =

    2**(-149) (Smallest positive value)

    双精度

    IEEE双精度浮点标准表示需要64位字,其可以从左到右表示为从0到63编号。

    >第一位是符号位,S,

    >接下来的11位是指数位,’E’和

    >最后52位是分数’F’:

    S EEEEEEEEEEE FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

    0 1 11 12 63

    由字表示的值V可以如下确定:

    >如果E = 2047且F为非零,则V = NaN(“不是数字”)

    >如果E = 2047且F为零,S为1,则V = -Infinity

    >如果E = 2047,F为零,S为0,则V =无穷大

    >如果0

    意在表示通过用F加前缀而创建的二进制数

    隐式前导1和二进制点。

    >如果E = 0且F为非零,则V =( – 1)** S * 2 **(-1022)*(0.F)

    是“非规范化”值。

    >如果E = 0且F为零,S为1,则V = -0

    >如果E = 0并且F为零并且S为0,则V = 0

    参考:ANSI / IEEE标准754-1985,二进制浮点算术标准。

    展开全文
  • Python双精度浮点数运算并分行显示操作示例这篇文章主要介绍了Python双精度浮点数运算并分行显示操作,涉及Python数学运算及显示相关操作技巧,注释备有详尽的说明,需要的朋友可以参考下#coding=utf8def doubleType():...

    Python双精度浮点数运算并分行显示操作示例

    这篇文章主要介绍了Python双精度浮点数运算并分行显示操作,涉及Python数学运算及显示相关操作技巧,注释备有详尽的说明,需要的朋友可以参考下

    #coding=utf8

    def doubleType():

    '''''

    Python中的浮点数是双精度浮点数,可以用十进制或科学计数法表示。

    实际精度依赖于机器架构和创建Python解释器的编译器。

    浮点数值通常都有一个小数点和一个可选的后缀e(大写或小写,表示科学计数法)。

    在e和指数之间可以用正(+)或负(-)表示指数的正负(正数可以省略符号)

    '''

    (one,two,three,four,five)=(0.0, -777., 1.6, -5.555567119, 96e3*1.0)

    (on,tw,thr,fo,fi)=(4.3e25, 9.384e-23, -2.172818, float(12), 1.000000001)

    (n,w,hr,f,i)=(3.1416, 4.2E-10, -90., 6.022e23, -1.609E-19)

    #把所有的变量放在一个list中

    varlist=[one,two,three,four,five,on,tw,thr,fo,fi,n,w,hr,f,i]

    #输出所有变量值,每五个换一次行

    for index in range( len( varlist)):

    #在一行显示多个变量值

    print varlist[index],

    #如果index+1能被5整除,就换行

    if (index+1)%5==0:

    print

    if __name__=="__main__":

    doubleType()

    运行效果:

    完 谢谢观看

    展开全文
  • 实际上,任何精度浮点运算也可以像BigInteger那样计算,可以用多个浮点数据表示更高精度的浮点数据。而这就要求实现带余数的浮点四则运算。 带余数的浮点四则运算的定义: 加法和减法,余数和结果的和能精确表示...

    实际上,任何精度的浮点运算也可以像BigInteger那样计算,可以用多个浮点数据表示更高精度的浮点数据。而这就要求实现带余数的浮点四则运算

    带余数的浮点四则运算的定义:

    加法和减法,余数和结果的和能精确表示运算值。

    乘法和除法,余数和结果必须同号,对于乘法,余数和结果的和能精确表示运算值,而对于除法,余数就是原来的意思。

     

    不多解释,代码如下:(修复某些可能存在错误)

    #include <iostream>
    #include <xmmintrin.h>
    
    using namespace std;
    
    
    typedef struct {
        float hi;
        float lo;
    } doublf;
    
    /**
     * BigFloat的实际值为:
     * 使用这个数据类型的缺点是数据存储冗余,优点是便于计算。
    **/
    typedef struct {
        int32_t len;//data中有效数据的长度
        int32_t exp;//指数部分
        float data[0];//浮点数据,每个都是1.x的数据
    } BigFloat;
    
    inline int32_t ifabs(float a){
        int32_t p=*(int32_t*)&a;
        return p&0x7fffffff;
    }
    
    //o=5
    doublf addf(float a,float b){//带余数加法
        doublf ret;
        ret.hi=a+b;
        if(ifabs(a)>ifabs(b))ret.lo=b-(ret.hi-a);
        else ret.lo=a-(ret.hi-b);
        return ret;
    }
    
    //o=5
    doublf subf(float a,float b){//带余数减法
        doublf ret;
        ret.hi=a-b;
        if(ifabs(a)>ifabs(b))ret.lo=(a-ret.hi)-b;
        else ret.lo=a-(ret.hi+b);
        return ret;
    }
    
    //o=14
    doublf mule(float a,float b){
        doublf ret;
        float m,n;//结合整数运算优化
        int32_t ap,bp,am,bm;
        uint32_t mp;
        ap=*(int32_t*)&a;
        bp=*(int32_t*)&b;
        ret.hi=n=a*b;
        am=ap&0xff800000;
        bm=bp&0xff800000;
        am=am+bm-0x4b000000;
        m=*(float*)&am;
        ap|=0x800000;
        bp|=0x800000;
        mp=(uint32_t)ap*(uint32_t)bp;
        ap=(mp&0x7fffff)|am;
        ret.lo=*(float*)&ap;
        if(mp&0x800000){
            if(n+m!=n)ret.lo-=m;
        }
        else ret.lo-=m;
        return ret;
    }
    
    //o=14
    doublf mulf(float a,float b){//带余数乘法
        unsigned int csr=_mm_getcsr();
        _mm_setcsr((csr & ~_MM_ROUND_MASK) | _MM_ROUND_TOWARD_ZERO);
        doublf ret=mule(a,b);
        _mm_setcsr(csr);
        return ret;
    }
    
    //o=17
    doublf divf(float a,float b){//带余数除法
        unsigned int csr=_mm_getcsr();
        _mm_setcsr((csr & ~_MM_ROUND_MASK) | _MM_ROUND_TOWARD_ZERO);
        doublf ret,tmp;
        ret.hi=a/b;
        tmp=mule(ret.hi,b);
        ret.lo=(a-tmp.hi)-tmp.lo;
        _mm_setcsr(csr);
        return ret;
    }
    
    //检验正确
    //o=20,8
    doublf add(doublf a,doublf b){//最後一位会产生误差
        doublf ret,tmp;
        /* 计算 */
        if(ifabs(a.hi)<ifabs(b.hi)){
            tmp=a;
            a=b;
            b=tmp;
        }
        ret=addf(b.lo,a.lo);
        tmp=addf(ret.hi,b.hi);
        ret.hi=tmp.hi;
        ret.lo+=tmp.lo;
        tmp=addf(tmp.hi,a.hi);
        ret.hi=tmp.hi;
        ret.lo+=tmp.lo;//即使高低位重叠也不会有影响
        return ret;
    }
    
    //检验正确
    //o=22,9
    doublf sub(doublf a,doublf b){//最後一位会产生误差
        doublf tmp;
        /* 计算 */
        tmp.hi=-b.hi;
        tmp.lo=-b.lo;
        return add(a,tmp);
    }
    
    //检验正确
    doublf mul(doublf a,doublf b){
    #if 0//最後一位会产生误差
    //o=137,25
        unsigned int csr=_mm_getcsr();
        _mm_setcsr((csr & ~_MM_ROUND_MASK) | _MM_ROUND_TOWARD_ZERO);
        doublf ret,tmp,tmp2,tmp3,tmp4;
        /* 计算 */
        tmp=mule(a.lo,b.lo);
        tmp2=mule(a.lo,b.hi);
        tmp3=mule(a.hi,b.lo);
        tmp4=mule(a.hi,b.hi);
        _mm_setcsr(csr);
        ret=add(tmp,tmp2);//应允许误差存在
        ret=add(ret,tmp3);
        ret=add(ret,tmp4);
        return ret;
    #else//最後两位会产生误差
    //o=25,8
        doublf ret=mulf(a.hi,b.hi);
        ret.lo+=(a.lo*b.lo+a.lo*b.hi)+a.hi*b.lo;
        ret=addf(ret.hi,ret.lo);//克服高低位重叠造成的影响
        return ret;
    #endif
    }
    
    //检验正确
    doublf div(doublf a,doublf b){//最後两位会产生误差
    #if 1//o=27,10
        doublf ret,tmp;
        float d=b.hi+b.lo;
        ret.hi=a.hi/d;
        unsigned int csr=_mm_getcsr();
        _mm_setcsr((csr & ~_MM_ROUND_MASK) | _MM_ROUND_TOWARD_ZERO);
        /* 计算 */
        tmp=mule(b.hi,ret.hi);
        //tmp2=mule(b.lo,ret.hi);
        _mm_setcsr(csr);
        ret.lo=((((a.hi-tmp.hi)-tmp.lo)-ret.hi*b.lo)+a.lo)/d;//精度低但更快
        //a=sub(a,tmp);
        //a=sub(a,tmp2);
        //ret.lo=a.hi/d;
        ret=addf(ret.hi,ret.lo);//还是应该修正,以克服高低位重叠的影响
        return ret;
    #else//o=24,8
        doublf ret;
        float d=b.hi+b.lo;
        ret=divf(a.hi,d);
        ret.lo=(ret.lo-ret.hi*((d-b.hi)-b.lo)+a.lo)/d;
        return ret;
    #endif
    }
    
    inline double to_double(doublf a){
        return (double)a.hi+a.lo;
    }
    
    inline doublf to_doublf(double a){
        doublf ret;
        ret.hi=a;
        ret.lo=a-ret.hi;
        return ret;
    }
    
    /**
     * 这样就能有办法用单精度模拟双精度(可以有2^-46的精度),甚至模拟任何精度的浮点数据。
     * 关键是要支持带余数的浮点四则运算。
    **/
    
    int main()
    {
        int i;
        uint64_t tmp;
        doublf df,af,tf;
        double dd=45671.154545,ad=1.001245648454,td,tt;
        do{
            tf=df=to_doublf(dd);
            af=to_doublf(ad);
            cin>>i;
            while(i--){
                tt=to_double(df=add(df,af));
                tmp=*(uint64_t*)&tt;
                cout<<"add="<<hex<<tmp<<endl;
                td=dd+ad;
                tmp=*(uint64_t*)&td;
                cout<<"chk="<<hex<<tmp<<endl;
                dd=tt;
            };
            df=tf;
            dd=to_double(tf);
            cin>>i;
            while(i--){
                tt=to_double(df=sub(df,af));
                tmp=*(uint64_t*)&tt;
                cout<<"sub="<<hex<<tmp<<endl;
                td=dd-ad;
                tmp=*(uint64_t*)&td;
                cout<<"chk="<<hex<<tmp<<endl;
                dd=tt;
            };
            df=tf;
            dd=to_double(tf);
            cin>>i;
            while(i--){
                tt=to_double(df=mul(df,af));
                tmp=*(uint64_t*)&tt;
                cout<<"mul="<<hex<<tmp<<endl;
                td=dd*ad;
                tmp=*(uint64_t*)&td;
                cout<<"chk="<<hex<<tmp<<endl;
                dd=tt;
            };
            df=tf;
            dd=to_double(tf);
            cin>>i;
            while(i--){
                tt=to_double(df=div(df,af));
                tmp=*(uint64_t*)&tt;
                cout<<"div="<<hex<<tmp<<endl;
                td=dd/ad;
                tmp=*(uint64_t*)&td;
                cout<<"chk="<<hex<<tmp<<endl;
                dd=tt;
            };
            cin>>dd;
            cin>>ad;
        }while(ad!=0.0);
        return 0;
    }
    

     

    展开全文
  • 双精度浮点型数据运算精度丢失以及数据的格式化问题

    不多说,直接上测试代码:

    public class DemoBigDicimal {
        @Test
        public void test(){
            DecimalFormat df = new DecimalFormat("#,##0.00");
            DecimalFormat df2 = new DecimalFormat("#.00");//这种如果是0.xx的话,显示还是有问题.前面的0会消失
            DecimalFormat df3 = new DecimalFormat("0.00");//
            float a = 20000000f;
            float b = 12f;
            System.out.println(df.format(a/b));//1,666,666.62
            System.out.println(df2.format(a/b));//1666666.62
            System.out.println(a/b);//1666666.6
            double c = 1.0;
            double d = 3.0;
            System.out.println(df.format(c/d));//0.33
            System.out.println(df2.format(c/d));//.33
            System.out.println(df3.format(c/d));//0.33
            System.out.println(c/d);//0.3333333333333333
            System.out.println((float)1/3 + (float)2/3);//1.0
            System.out.println("----------------------------------------------------------------------");
            System.out.println(1.79 + 0.12);//1.9100000000000001
            System.out.println(add(1.79,0.12));//1.91
            System.out.println(2.01 - 0.12);//1.8899999999999997
            System.out.println(sub(2.01,0.12));//1.89
            System.out.println(1.01 * 1.3);//1.3130000000000002
            System.out.println(mul(1.01,1.3));//1.313
            System.out.println(0.69 / 10);//0.06899999999999999
            System.out.println(div(0.69,10));//0.069
        }
    
        public static double add(double num,double num2){
            BigDecimal n = new BigDecimal(Double.toString(num));
            BigDecimal n2 = new BigDecimal(Double.toString(num2));
            return n.add(n2).doubleValue();
        }
    
        public static double sub(double num,double num2){
            BigDecimal n = new BigDecimal(Double.toString(num));
            BigDecimal n2 = new BigDecimal(Double.toString(num2));
            return n.subtract(n2).doubleValue();
        }
    
        public static double mul(double num,double num2){
            BigDecimal n = new BigDecimal(Double.toString(num));
            BigDecimal n2 = new BigDecimal(Double.toString(num2));
            return n.multiply(n2).doubleValue();
        }
    
        public static double div(double num,double num2){
            BigDecimal n = new BigDecimal(Double.toString(num));
            BigDecimal n2 = new BigDecimal(Double.toString(num2));
            return n.divide(n2).doubleValue();
        }
    }
    展开全文
  • 3.浮点运算加法和乘法 3.1加法 3.2乘法 1.实数数的表示 参考深入理解C语言-03-有符号数,定点数,浮点数 1.1定点数 一般在没有FPU寄存器的嵌入式系统中使用比较多。比如常见的32位系统中,将高16位作为整数...
  • 当前NVIDA的GPU芯片仅支持单精度(float)浮点运算,对一些应用来说精度可能不够用,一些关键的步骤可能需要双精度运算,才能保证程序的正常执行。对此,本人尝试用两个单精度浮点数数来代表一个双精度浮点数://类型...
  • 浮点运算器 Verilog

    2018-04-22 11:18:22
    该工程代码实现了64位双精度浮点运算功能,所以的代码采用verilog 编写,附带测试脚本,以及进制转换工具。
  • 双精度浮点乘法部件是高性能CPU的核心运算部件之一。描述了使用Cadence Stratus HLS工具设计和实现双精度浮点乘法部件,探索新设计方法学在关键路径延时调整、数据路径优化以及低功耗优化等问题的解决方法,并探讨...
  • MCU: STM32F767,启动硬件双精度浮点运算协处理器 IDE: Keil RVMDK V5.21.1.0 测试方法 浮点数0.1分别以单精度与双精度累加1000000次,打印输出累加结果。 测试代码 double dVal = 0; float fVal = 0; for(int i ...
  • 单精度,双精度浮点存储表示 基础知识: 十进制转十六进制; 十六进制转二进制; 了解: 目前C/C++编译器标准都遵照IEEE制定的浮点数表示法来进行float,double运算。这种结构是一种科学计数法,用符号、指数和...
  • 单精度与双精度浮点

    千次阅读 2014-09-16 20:41:53
    目前C/C++ 编译器标准都遵照IEEE 制定的浮点数表示法来进行float,double 运算。这种结构是一种科学计数法,用符号、指数和尾数来表示,底数定为2—— 即把一个浮点数表示为尾数乘以2 的指数次方再添上符号。...
  • 目前C/C++ 编译器标准都遵照IEEE 制定的浮点数表示法来进行float,double 运算。这种结构是一种科学计数法,用符号、指数和尾数来表示,底数定为2—— 即把一个浮点数表示为尾数乘以2 的指数次方再添上符号。...
  • LPC3000系列ARM9微控制器具有片上的矢量浮点运算单元,使其在需要较多的算法处理特别是单精度及双精度浮点运算的应用中具有性能上的优势。以该产品在医疗电子领域的应用为例作了说明,并提供了基于恩智浦微控制器的...
  • 本文实例讲述了Python双精度浮点数运算并分行显示操作。分享给大家供大家参考,具体如下:#coding=utf8def doubleType():'''''Python中的浮点数是双精度浮点数,可以用十进制或科学计数法表示。实际精度依赖于机器...
  • 本文实例讲述了Python双精度浮点数运算并分行显示操作。分享给大家供大家参考,具体如下: #coding=utf8 def doubleType(): ''''' Python中的浮点数是双精度浮点数,可以用十进制或科学计数法表示。 实际精度...
  • 提出了一种基于 SR T 迭代算法的除法器的改进方法 ,采用 Re sto ri ng 和 SR T 算法来互补共同完成双精度浮 点除法器的设计 , 当被除数的位数很大时采用改进过的 Re sto ri ng 算法来完成除法运算 , 并通过倒数查找...
  • cpu中的运算单元包括:存储执行,整形执行,浮点执行三个单元,其中浮点运算国内以前做的特别少, 原因主要有2个,一是国内对... 首先国内外现在用的浮点的格式全部都是IEEE754标准,单精度32位,双精度64位,真...
  • SSE2与SSE1使用相同寄存器,指令描述约定: MM指64位MMX寄存器 XMM指128XMM寄存器 m32 指32位内存变量 m128指128位内存变量 ... 本小结主要描述双精度浮点运算指令 1. 数据搬移指令 movapd...
  • 文件名称: src下载 收藏√ [5 4 3 2 1]开发工具: Java文件大小: 20752 KB上传时间: 2016-07-12下载...双精度浮点型变量double可以处理16位有效数。在实际应用中,需要对更大或者更小的数进行运算和处理。-BigDecim...
  • 在实际开发中,难免会遇到数据值的计算,关于小数的两种浮点型(float,double),也就是单精度与双精度。 两种类型的区别: 1.在内存中占有的字节数:单精度是4字节,而双精度是8字节 2. 有效数字位数:单精度有效位...
  • arm浮点运算

    2018-07-02 17:44:00
    首先总结一下计算机中的浮点数的存储。 浮点数的标准是IEEE-754... 目前浮点的计算都是将浮点转换为定浮点来计算,由此衍生出,单精度浮点和双精度浮点。   浮点数的存储,前半部分表示exponent(可以是负数,使用...
  • float 和 double 互相运算的时候,建议将float转换为double后统一类型运算。float转换double时会造成精度丢失,我的一个解决办法是,将float转换为string,再转换为double如:floatf=3.141592Fdoubled=Convert.To...
  • 本文实例讲述了Python双精度浮点数运算并分行显示操作。分享给大家供大家参考,具体如下:#coding=utf8def doubleType():'''''Python中的浮点数是双精度浮点数,可以用十进制或科学计数法表示。实际精度依赖于机器...
  • STM32双精度运算

    千次阅读 2013-11-28 22:03:48
    调试程序的时候,用到两个双精度的运算,我写的公式比较长,这部分的计算竟然影响了中断部分的执行。具体点说,就是由于双精度运算,影响了进入和跳出中断...有些单片机有单独的浮点运算单元,估计那样会提高不少速度。
  • STM32硬件浮点运算测试

    千次阅读 2019-05-21 10:10:25
    使用浮点运算的小数点后面必须加(f),不然就默认成了双精度浮点类型,计算速度变得很慢。(和编译器无关,测试使用最新KEIL)。 2018 / 12 / 15 arm_matrix_instance_f32 pSrcA; //声明矩阵 arm_mat_init_f32(&...
  • 作者:风影残烛 ...在运算的时候。发现编译器对 // FpuTlxTest.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include <string.h> #include <math.h> #include &l...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 875
精华内容 350
关键字:

双精度浮点运算