float 订阅
浮点型数据类型,FLOAT 数据类型用于存储单精度浮点数或双精度浮点数。浮点数使用 IEEE(电气和电子工程师协会)格式。浮点类型的单精度值具有 4 个字节,包括一个符号位、一个 8 位 二进制指数和一个 23 位尾数。由于尾数的高顺序位始终为 1,因此它不是以数字形式存储的。此表示形式为 float 类型提供了一个大约在 -3.4E+38 ~ 3.4E+38 之间的范围。 [1] 展开全文
浮点型数据类型,FLOAT 数据类型用于存储单精度浮点数或双精度浮点数。浮点数使用 IEEE(电气和电子工程师协会)格式。浮点类型的单精度值具有 4 个字节,包括一个符号位、一个 8 位 二进制指数和一个 23 位尾数。由于尾数的高顺序位始终为 1,因此它不是以数字形式存储的。此表示形式为 float 类型提供了一个大约在 -3.4E+38 ~ 3.4E+38 之间的范围。 [1]
信息
使用格式
IEEE格式
类    型
单精度浮点型
占用空间
32位、4个字节
中文名
浮点型
范    围
-3.4E+38 ~ 3.4E+38
外文名
float
FLOAT基本介绍
浮点数在机内用指数型式表示,分解为:数符,尾数,指数符,指数四部分。数符占 1 位二进制,表示数的正负。指数符占 1 位二进制,表示指数的正负。尾数表示浮点数有效数字,0.xxxxxxx, 但不存开头的 0 和点。指数存指数的有效数字。指数占多少位,尾数占多少位,由计算机系统决定。 [2]  可根据应用程序的需求将变量声明为 float 或 double。这两种类型之间的主要差异在于它们可表示的基数、它们需要的存储以及它们的范围。 [3]  取值范围浮点变量由尾数(包含数字的值)和指数(包含数字的数量级)表示。下表显示了分配给每个浮点类型的尾数和指数的位数。任何 float 或 double 的最高有效位始终是符号位。如果符号位为 1,则将数字视为负数;否则,将数字视为正数。指数和尾数由于指数是以无符号形式存储的,因此指数的偏差为其可能值的一半。对于 float 类型,偏差为 127;对于 double 类型,偏差为 1023。您可以通过将指数值减去偏差值来计算实际指数值。存储为二进制分数的尾数大于或等于 1 且小于 2。对于 float 和 double 类型,最高有效位位置的尾数中有一个隐含的前导 1,这样,尾数实际上分别为 24 和 53 位长,即使最高有效位从未存储在内存中也是如此。浮点包可以将二进制浮点数存储为非标准化数,而不使用刚刚介绍的存储方法。“非标准化数”是带有保留指数值的非零浮点数,其中尾数的最高有效位为 0。通过使用非标准化格式,浮点数的范围可以扩展,但会失去精度。您无法控制浮点数以标准化形式还是非标准化形式表示;浮点包决定了表示形式。浮点包从不使用非标准化形式,除非指数变为小于可以标准化形式表示的最小值。下表显示了可在每种浮点类型的变量中存储的最小值和最大值。此表中所列的值仅适用于标准化浮点数;非标准化浮点数的最小值更小。请注意,在 80x87 寄存器中保留的数字始终以 80 位标准化形式表示;数字存储在 32 位或 64 位浮点变量(float 类型和 long 类型的变量)中时只能以非标准化形式表示。 [1] 
收起全文
精华内容
参与话题
问答
  • 简化 java.lang.Float 类的源码

    万次阅读 2020-09-25 22:57:20
    public final class Float extends Number implements Comparable<Float>, Constable, ConstantDesc { @java.io.Serial private static final long serialVersionUID = -2671257302660747028L; // 序列化...
    public final class Float extends Number implements Comparable<Float>, Constable, ConstantDesc {
    
        @java.io.Serial
        private static final long serialVersionUID = -2671257302660747028L; // 序列化版本号
        private final float value;                                  // 存储浮点数的值
        public static final float POSITIVE_INFINITY = 1.0f / 0.0f;  // 正无穷大常量
        public static final float NEGATIVE_INFINITY = -1.0f / 0.0f; // 负无穷大常量
        public static final float NaN = 0.0f / 0.0f;                // NaN常量
        public static final float MAX_VALUE = 0x1.fffffeP+127f;     // 最大值的常量
        public static final float MIN_VALUE = 0x0.000002P-126f;     // 最小值的常量
        public static final float MIN_NORMAL = 0x1.0p-126f;         // 最小的正常常量
        public static final int MAX_EXPONENT = 127;
        public static final int MIN_EXPONENT = -126;
        public static final int SIZE = 32;                          // 用bit表示的长度,4字节=32位
        public static final int BYTES = SIZE / Byte.SIZE;           // 用字节表示float
        public static final Class<Float> TYPE = (Class<Float>) Class.getPrimitiveClass("float");
    
    
        public int compareTo(Float anotherFloat) {}     // 当前浮点数和anotherFloat比较大小
    
        /**
         * 构造方法
         */
        @Deprecated(since="9")
        public Float(float value) {}
        @Deprecated(since="9")
        public Float(double value) {}
        @Deprecated(since="9")
        public Float(String s) throws NumberFormatException {}
    
        /**
         *
         */
        public boolean isNaN() {}       // 判断当前浮点数是否为 NaN
        public boolean isInfinite() {}  // 当前数是正无穷或负无穷则返回true,否则返回false
        public String toString() {}     // 浮点数转换成字符串
        public byte byteValue() {}      // 浮点数转换为byte
        public short shortValue() {}    // 浮点数转换short
        public int intValue() {}        // 浮点数转换为int
        public long longValue() {}      // 浮点数转换成long
        @HotSpotIntrinsicCandidate
        public float floatValue() {}    // 得到当前浮点数
        public double doubleValue() {}  // 浮点数转换成double
        @Override
        public int hashCode() {}        // 浮点数的hash值
        public boolean equals(Object obj) {}  // 当前浮点数是否于obj相等
        /**
         * 静态方法
         * 和上面非静态方法差不多意思,只不过上面的参数来自本身的value
         * 而下面是的方法是通过类名当做工具类使用的
         */
        public static int hashCode(float value) {}      //浮点数的hash值
        public static int compare(float f1, float f2){} // 比较两浮点数大小
        public static float sum(float a, float b) {}    // 两个浮点数求和
        public static float max(float a, float b) {}    // 两个浮点数最大的一个浮点数
        public static float min(float a, float b) {}    // 两个浮点数最小的一个浮点数
        public static String toString(float f) {}       // 浮点数转换成字符串
        public static String toHexString(float f) {}    // 浮点数转换成16进制字符串
        public static Float valueOf(String s) {}        // 字符串转浮点数对象
        @HotSpotIntrinsicCandidate
        public static Float valueOf(float f) throws NumberFormatException {}     // 将浮点数封装成Float对象
        public static float parseFloat(String s) throws NumberFormatException {} // 解析字符串为浮点数
        public static boolean isNaN(float v) {}         // 判断 v 是否为NaN类型,是则true,否则为false
        public static boolean isInfinite(float v) {}    // 判断 v 是否是正无穷或负无穷则返回true,否则返回false
        public static boolean isFinite(float f) {}      // f 有浮点值返回true,没有则返回false
    
        @HotSpotIntrinsicCandidate
        public static int floatToIntBits(float value) {} // 浮点数转换成2进制01表示的值
        @HotSpotIntrinsicCandidate
        public static native int floatToRawIntBits(float value);//
        @HotSpotIntrinsicCandidate
        public static native float intBitsToFloat(int bits); // 将int01表示的数据转换成float
    
    
        // 将Float封装在Optional容器内(允许null)
        @Override
        public Optional<Float> describeConstable() {
            return Optional.of(this);
        }
        @Override
        public Float resolveConstantDesc(MethodHandles.Lookup lookup) {
            return this;
        }
    }
    
    
    展开全文
  • month_diff = int(float(date_consumed[-6:-4])) - int(float(date_received[-6:-4])),这一句包含在函数get_time_diff中 我的目的是提取两个时间字符串里面的月份,然后计算月份差 出错的原因...

    错误:

    ValueError: could not convert string to float

    出错的地方为:

    month_diff = int(float(date_consumed[-6:-4])) - int(float(date_received[-6:-4])),这一句包含在函数get_time_diff中

    我的目的是提取两个时间字符串里面的月份,然后计算月份差

    出错的原因:

    date_consumed或者date_received中含有空的字符串,

    改正方式:

    我在这里本意是将date_consumed和date_received中空的字符串去除,但是后来将这两个打印出来发现它们为空时用'nan'来表示了

    frame = pd.Series(list(map(lambda x, y, z: 1. if x != 'null' and y != 'null' and z != 'null'and get_time_diff(z, y) <= 15 else 0., df[coupon_label], df[date_consumed_label], df[date_received_label])))

    最终我将上面这句改成下面这句:

    frame = pd.Series(list(map(lambda x, y, z: 1. if x != 'nan' and y != 'nan' and z != 'nan'and get_time_diff(z, y) <= 15 else 0., df[coupon_label], df[date_consumed_label], df[date_received_label])))

    程序正常运行了!

    展开全文
  • float强转int

    万次阅读 2018-06-24 10:24:23
    本文只讨论float转int的原理,如有不当之处,欢迎留言指出。交流学习。 推荐阅读关于float转int的函数实现(非结构体实现版)类型强转丢失精度的根源 目录 一、思路 1.1 十进制 1.2 二进制 1.3 处理棘手的...

    本文只讨论float转int的原理,如有不当之处,欢迎留言指出。交流学习。 

    推荐阅读关于float转int的函数实现(非结构体实现版) 类型强转丢失精度的根源

    目录

    一、思路

    1.1 十进制

    1.2 二进制

    1.3 处理棘手的符号位

    1.4 小端模式

    二、C语言实现

    2.1 思路

    2.2 利用结构体实现

    2.3 利用内存拷贝函数memcpy实现


    一、思路

    1.1 十进制

    大体和科学计数法(小数点前面只有1位,和用什么进制实现没有关系)别无二致。如果十进制:

    图1 十进制下的科学计数法

    从图1 我们可以看到, 对于科学计数法而言,小数点前面只有1位、小数点后面是有效位、以10为底数的幂有正有负有0。那么为了记录一个十进制数,我们需要记录四个要素:符号、小数点前的一位、有效位、指数。

    1.2 二进制

    类比到二进制,小数点前面一位一定是1,正如十进制小数点前面一位一定是1-9一样;那么我们只需记录符号有效位以及指数。下面我们先举一个例子:-12,25展成float。注意:此处不要去想表示整型的原码反码补码那一套了。正如稍前讨论的那般,指数是有正负的,那如果不加某种手段,如何表示指数的正负呢?

    1.3 处理棘手的符号位

    IEEE二进制浮点数算术标准(ANSI/IEEE Std 754-1985)告诉我们一个很棒的解决办法:是这样做的,选取8bite用于表示指数部分(底数是2),有256种变化,既可以理解为0-255也可以理解为-128-127,取决于设计者是如何去解释的。而后者是非常好的,正指数和负指数都是127一人一半。所以不管实际指数是多少,一律加上127类似于加密过程;等到想把真实值取出来的时候,一律减去127类似于解密过程。

    现在来演算一下-12.25如何展成float吧:

    图2 -12.25展成float

    最后我们才能大体看懂这张示意图:

    图3 float类型结构示意图

    1.4 小端模式

    大端模式和小端模式的由来

    二、C语言实现

    2.1 思路

    难点在于如何用一个变量去读出内存中存放的float类型的变量。最直接的办法就是按照float类型的结构去设计一个完全一致的结构体,更为巧妙的办法是将float类型的变量通过调用内存拷贝函数memcpy复制到unsigned long类型的变量中。这两种办法都能将float类型的变量取出,然后分别读取符号位、指数位、尾数有效位。

    学无止境,下面分别讨论这两种思路的实现:

    2.2 利用结构体实现

    用到了位域的知识点:

    图4 单词mantissa

    结构体设计以及函数声明。

    #include<stdio.h> //printf()
    #include<stdlib.h> //atof()
    
    typedef struct FloatNode
    {
        unsigned int mantissa : 23; //尾数部分
        unsigned int exponent : 8; //指数部分
        unsigned int sign : 1;  //符号位
    }FloatNode;
    
    int GetSign(const FloatNode *fn); //获取符号位
    int GetExp(const FloatNode *fn); //获取指数部分
    int Float_To_Int(float num); //类型强制转换

    其他函数的实现

    int GetSign(const FloatNode *fn) //获得符号位
    {
        return fn->sign == 1 ? -1 : 1;
    }
    
    int GetExp(const FloatNode *fn) //获得指数位
    {
        return (fn->exponent - 127); //根据IEEE754,减去127才是真正的指数位
    }
    
    int Float_To_Int(float num) //将float强转成int
    {
        FloatNode *fn = (FloatNode*)&num;
        int exp = GetExp(fn);
    
        if(exp >= 0)
        {
            int mov = 23 - exp;
            int res = (fn->mantissa | 1<<23) >> mov;
            return res*GetSign(fn);
        }
        else
        {
            return 0;
        }
    }

    main主函数

    int main(int argc, char* argv[])
    {
        if(argc <= 1)
        {
            printf("%s\n", "Argument isn't enough.");
            return 0;
        }
        char *p = argv[1];
        float num = atof(p);
        int res = Float_To_Int(num);
        printf("转换之后的结果是:%d\n", res);
        return 0;
    }
    图5 linux下运行结果

    2.3 利用内存拷贝函数memcpy实现

    重要的话,浮点型没有移位运算,或者说,即使强行进行移位运算也是被当成整型对待而得到错误的结果。如果不用一个和float类型完全一致的结构体去读取,那么只能将float类型的数据放到unsigned类型中再进行操作。

    实际上就是对float型的结构进行解析,尤要注意的是运算符的优先级,告诫本篇博客的博友们:不要止步于看懂,自己也要写一写。

    库文件的引入及函数的声明:

    #include<stdio.h> //printf()
    #include<string.h> //memcpy()
    #include<stdlib.h> //atof()
    
    int getSign(unsigned num);      //获得符号位
    int getExp(unsigned num);       //获得指数部分
    int float2int(float ft);    //float强转为int

    其他函数的实现

    int getSign(unsigned num)       //获得符号位
    {
        int sign = num & (1<<31);
        return sign == 0 ? 1 : -1; 
    }
    
    int getExp(unsigned num)        //获得指数部分
    {
        int exp = 0;
        for(int i = 23; i < 31; ++i)
            exp |= (num & (1<<i));
        exp = (exp>>23) - 127;
        return exp;
    }
    
    int float2int(float ft) //float强转为int
    {
        unsigned num;
        memcpy(&num, &ft, sizeof(float)); //将float数据完整地拷贝到unsigned中
    
        int exp = getExp(num); //获得float存储结构的指数部分
        if(exp < 0) //如果指数小于0的话,实际值肯定是0.***,故而强转之后就为0
        {
            return 0;
        }
        else
        {
            int res = num & ((1<<23)-1);  //保留mantissa 注意运算符的优先级
            res |= 1<<23;   //将小数点前的1补上
            res >>= (23-exp); //整数部分右移到合适位置
            return res*getSign(num);
        }
    }

    main主函数

    int main(int argc, char * argv[])
    {
        if(argc <= 1)
        {
            printf("augument is not enough.\n");
            return 0;
        }
    
        float ft = atof(argv[1]); //将字符串转化为同值的float
        int res = float2int(ft);
        printf("转换之后的结果是:%d\n", res);
        return 0;
    }

    运行结果:

    图6 linux下运行结果
    展开全文
  • float的精度和取值范围

    万次阅读 多人点赞 2019-06-16 12:11:00
    关于float的精度和取值范围这个问题,我查询了很多次,每次都是用完就忘了,等到再使用的时候还需要再次查询,关键是这个问题大家给出的结果并不都是一致的,我得从众多的资料当中选择出正确的观点,这还要额外花...

    前言

    关于float的精度和取值范围这个问题,我查询了很多次,每次都是用完就忘了,等到再使用的时候还需要再次查询,关键是这个问题大家给出的结果并不都是一致的,我得从众多的资料当中选择出正确的观点,这还要额外花一些时间,所以我决定也总结一次,方便我以后拿来直接用了,如果能给大家带来帮助那就更好了。下面提到一些说法很多都是我个人的理解,如果大家有疑义,欢迎讨论。

    精度限制

    首先考虑下为什么会产生精度问题,是因为存储数据的空间有限,以一个四字节整数int n;为例,一共有32位,取值范围是 [-2147483648‬, 2147483647] ,一共是4,294,967,296种可能,它的精度可以说是小数点后一位都不保留,也就是只有整数,换句话说变量n可以表示实数范围内的4,294,967,296个数值。

    如果换成float类型呢?一个变量float f所能表示多少个数呢?实际上由于存储空间未发生变化,同样是4字节32位,那么float类型也只能表示,或者说精确表示4,294,967,296个数值(真实情况由于一些特殊的规则,最终所表示的数字个数还要少),说到这里很多人可能会疑惑,因为他知道float可以表示比4,294,967,296大的数,同时也能表示小数,如果只有4,294,967,296种可能,那究竟是怎么做到的呢?

    这里也就开始提到精度了,整数很好理解,每个数字的间隔都是1,int类型所表示的4,294,967,296个数字都是等间距的,步长为1。而float也只能表示4,294,967,296个数字,同时要表示比int还大的范围,一个很直观的想法就是把间距拉大,这样范围就大了,但是float还要表示小数,像0.2、0.4这样的数字间距明显要小于1啊,想要存储小数貌似要把间距缩小,这就和前面矛盾了啊。

    实际上float类型存储数据的间隔不是等间距的,而是在0的附近间距小,在远离0的位置间距大,为什么会这样,一会我们看一下float类型数据的存储规则就明白了,这里先来看一下int类型和float类型所表示数字的范围对比,这只是一个示意图。

    //int
               [ *         *         *         0         *         *         * ]
    //float
    [ *          *    *    *   *  *  * * * * * 0 * * * * *  *  *   *    *    *          * ]
    

    上面的示意图就是两者表示数字范围的差异,每个星号*就表示一个数字,float通过这种不等间距的分布,既扩大了范围也表示了小数,那么有没有问题呢?

    当然有问题,饭就这么多,人多了自然不够吃了,因为远离0的位置间距越来越大,当要表示间距中间的一个数字时,只能找它附近离它最近的一个可以表示的数字来代替,这就导致了精度问题,比如我给一个float类型变量分别赋值为 4294967244 和 4294967295 ,再次输出时都变成了 4294967296,因为超过了精度,所以只能找最接近的数字代替。

    float存储方式

    这部分内容基本上各篇文章说的都一致,我也简单描述下,后面根据这部分的定义来推算一下float的精度和取值范围。

    首先我们知道常用科学计数法是将所有的数字转换成(±)a.b x 10c10^c 的形式,其中a的范围是1到9共9个整数,b是小数点后的所有数字,c是10的指数。而计算机中存储的都是二进制数据,所以float存储的数字都要先转化成(±)a.b x 2c2^c,由于二进制中最大的数字就是1,所以表示法可以写成(±)1.b x 2c2^c的形式,float要想存储小数就只需要存储(±),b和c就可以了。

    float的存储正是将4字节32位划分为了3部分来分别存储正负号,小数部分和指数部分的:

    1. Sign(1位):用来表示浮点数是正数还是负数,0表示正数,1表示负数。
    2. Exponent(8位):指数部分。即上文提到数字c,但是这里不是直接存储c,为了同时表示正负指数以及他们的大小顺序,这里实际存储的是c+127。
    3. Mantissa(23位):尾数部分。也就是上文中提到的数字b。

    三部分在内存中的分布如下,用首字母代替类型

    S E E E E E E E E M M M M M M M M M M M M M M M M M M M M M M
    0 1 0 0 0 0 0 0 1 1 0 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1

    float存储示例

    以数字6.5为例,看一下这个数字是怎么存储在float变量中的:

    1. 先来看整数部分,模2求余可以得到二进制表示为110。

    2. 再来看小数部分,乘2取整可以得到二进制表示为.1(如果你不知道怎样求小数的二进制,请主动搜索一下)。

    3. 拼接在一起得到110.1然后写成类似于科学计数法的样子,得到1.101 x 222^2

    4. 从上面的公式中可以知道符号为正,尾数是101,指数是2。

    5. 符号为正,那么第一位填0,指数是2,加上偏移量127等于129,二进制表示为10000001,填到2-9位,剩下的尾数101填到尾数位上即可

    S E E E E E E E E M M M M M M M M M M M M M M M M M M M M M M
    0 1 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
    1. 内存中二进制数01000000 11010000 00000000 00000000表示的就是浮点数6.5

    float范围

    明白了上面的原理就可求float类型的范围了,找到所能表示的最大值,然后将符号为置为1变成负数就是最小值,要想表示的值最大肯定是尾数最大并且指数最大,
    那么可以得到尾数为 0.1111111 11111111 11111111,指数为 11111111,但是指数全为1时有其特殊用途,所以指数最大为 11111110,指数减去127得到127,所以最大的数字就是1.1111111 1111111 11111111 x 21272^{127},这个值为 340282346638528859811704183484516925440,通常表示成 3.4028235E38,那么float的范围就出来了:

    [-3.4028235E38, 3.4028235E38]

    float精度

    float 类型的数据精度取决于尾数,相信大家都知道这一点,但是精度怎么算我也是迷糊了好久,最近在不断尝试的过程中渐渐的明白了,首先是在不考虑指数的情况下23位尾数能表示的范围是[0, 22312^{23}-1],实际上尾数位前面还隐含了一个"1",所以应该是一共24位数字,所能表示的范围是[0, 22412^{24}-1](因为隐含位默认是"1",所以表示的数最小是1不是0,但是先不考虑0,后面会特殊介绍,这里只按一般值计算),看到这里我们知道这24位能表示的最大数字为2242^{24}-1,换算成10进制就是16777215,那么[0, 16777215]都是能精确表示的,因为他们都能写成1.b x 2c2^c的形式,只要配合调整指数c就可以了。

    16777215 这个数字可以写成1.1111111 11111111 1111111 * 2232^{23},所以这个数可以精确表示,然后考虑更大的数16777216,因为正好是2的整数次幂,可以表示1.0000000 00000000 00000000 * 2242^{24},所以这个数也可以精确表示,在考虑更大的数字16777217,这个数字如果写成上面的表示方法应该是 1.0000000 00000000 00000000 1 * 2242^{24},但是这时你会发现,小数点后尾数位已经是24位了,23位的存储空间已经无法精确存储,这时浮点数的精度问题也就是出现了。

    看到这里发现 16777216 貌似是一个边界,超过这个数的数字开始不能精确表示了,那是不是所有大于16777216的数字都不能精确表示了呢?其实不是的,比如数字 33554432 就可以就可以精确表示成1.0000000 00000000 00000000 * 2252^{25},说道这里结合上面提到的float的内存表示方式,我们可以得出大于 16777216 的数字(不超上限),只要可以表示成小于24个2的n次幂相加,并且每个n之间的差值小于24就能够精确表示。换句话来说所有大于 16777216 的合理数字,都是[0, 16777215]范围内的精确数字通过乘以2n2^n得到的,同理所有小于1的正数,也都是 [0, 16777215] 范围内的精确数字通过乘以2n2^n得到的,只不过n取负数就可以了。

    16777216 已经被证实是一个边界,小于这个数的整数都可以精确表示,表示成科学技术法就是1.6777216 * 10710^{7},从这里可以看出一共8位有效数字,由于最高位最大为1不能保证所有情况,所以最少能保证7位有效数字是准确的,这也就是常说float类型数据的精度。

    float小数

    从上面的分析我们已经知道,float可表示超过16777216范围的数字是跳跃的,同时float所能表示的小数也都是跳跃的,这些小数也必须能写成2的n次幂相加才可以,比如0.5、0.25、0.125…以及这些数字的和,像5.2这样的数字使用float类型是没办法精确存储的,5.2的二进制表示为101.0011001100110011001100110011……最后的0011无限循环下去,但是float最多能存储23位尾数,那么计算机存储的5.2应该是101.001100110011001100110,也就是数字 5.19999980926513671875,计算机使用这个最接近5.2的数来表示5.2。关于小数的精度与刚才的分析是一致的,当第8位有效数字发生变化时,float可能已经无法察觉到这种变化了。

    float特殊值

    我们知道float存储浮点数的形式是(±)1.b x 2c2^c,因为尾数位前面一直是个1,所以无论b和c取什么样的值,都无法得到0,所以在float的表示方法中有一些特殊的约定,用来表示0已经其他的情况。

    float的内存表示指数位数有8位,范围是[0, 255],考虑偏移量实际的指数范围是[-127,128],但实际情况下指数位表示一般数字时不允许同时取0或者同时取1,也就是指数位的实际范围是[-126,127],而指数取-127和128时有其特殊含义,具体看下面表格:

    符号位 指数位 尾数位 数值 含义
    0 全为0 全为0 +0 正数0
    1 全为0 全为0 -0 负数0
    0 全为0 任意取值f 0.f21260.f * 2^{-126} 非标准值,尾数前改为0,提高了精度
    1 全为0 任意取值f 0.f2126-0.f * 2^{-126} 非标准值,尾数前改为0,提高了精度
    0 全为1 全为0 +Infinity 正无穷大
    1 全为1 全为0 -Infinity 负无穷大
    0/1 全为1 不全为0 NaN 非数字,用来表示一些特殊情况

    总结

    1. float的精度是保证至少7位有效数字是准确的
    2. float的取值范围[-3.4028235E38, 3.4028235E38],精确范围是[-340282346638528859811704183484516925440, 340282346638528859811704183484516925440]
    3. 一个简单的测试float精度方法,C++代码中将数字赋值给float变量,如果给出警告warning C4305: “=”: 从“int”到“float”截断,则超出了float的精度范围,在我的测试中赋值为16777216及以下整数没有警告,赋值为16777217时给出了警告。
    展开全文
  • float32和float64的本质区别

    万次阅读 多人点赞 2019-05-08 22:03:18
    首先我们需要知道何为bits和bytes...那么float32和float64有什么区别呢? 数位的区别 一个在内存中占分别32和64个bits,也就是4bytes或8bytes 数位越高浮点数的精度越高 它会影响深度学习计算效率? float64占用的...
  • float赋值

    千次阅读 2018-12-17 19:07:35
    float赋值 1.如果赋值一个浮点数则必须在后面加f 例如:float a=52.12f; 2.如果不加的话就需要使用强制转换符 例如:float a=(float)52.12; 3.如果赋值一个整数。可以不加f.java会自动转换int型到float型 例如:...
  • Python数据类型转换——float64-float32

    万次阅读 2018-10-13 11:28:35
    import tensorflow as tf ...a = np.array([1,2,3,4,5,6,7,8,9],dtype='float32'); a = a.reshape(3,3); c = a + [22,33,44];#c.dtype='float64' c = c.astype(np.float32) #c.dtype = 'float32' p...
  • float占4字节的存储空间。即char和float是1:4的大小关系。 #include <iostream> using namespace std; void floatToBytesLittle(float value, unsigned char*cSendBuff, int pos) { unsigned short i = 0...
  • mysql进阶(十)不靠谱的FLOAT数据类型

    万次阅读 2015-07-27 20:30:09
    今天在设计数据表时,突然发现原来FLOAT原来是很不靠谱的,所以在这里建议大家换成DOUBLE类型, 原因是: 在mysql手册中讲到,在MySQL中的所有计算都是使用双精度完成的,使用float(单精度)会有误差,出现意想不到的...
  • numpy.float64 转换 python float

    千次阅读 2019-11-16 11:50:21
    比如【pandas.mean()求平均值后是一个<class 'numpy.float64'>类型】 转换成Python的float类型 numpy.float(value)
  • 1. ‘float’转’float64’ xxx原本是’float’类型的 x = np.float64(x) 经过上面的xxx就变成了’float64’类型 2.’float64’转‘float’ yyy原本是’float64’类型的 y = np.float(y) 经过上面的yyy就变成了’...
  • <p>I have an array of float64 and want to convert each value to float32. <p>I've tried: <pre><code># What I have features64 [120]float64 # What I've tried features32 = [120]float32(features64) ...
  • Efficiency of CUDA vector types (float2, float3, float4) https://stackoverflow.com/questions/26676806/efficiency-of-cuda-vector-types-float2-float3-float4 I’m expanding njuffa’s comment into a ...
  • 比如main函数中有如下变量定义: price := 0.01 请问price的类型是float32还是float64?
  • java string to float, float to string

    千次阅读 2018-10-29 11:17:30
    float f = Float.parseFloat(&quot;25&quot;); String s = Float.toString(25.0f);
  • rtt 打印 float

    千次阅读 2017-03-03 18:19:35
    /*rtt print float*/ float float_value; float_value = 3.1415; char float_str[80]; sprintf(float_str, "Float value is %f\n", float_value); NRF_LOG_PRINTF(float_str);
  • java中Integer转Float总结以及BigDecimal 转float 一.先将Integer转化成int类型,在强制转float类型 例:Integer str = new Integer(20); int i = str.intValue(); float rr = (float)i; 输出结果为:20.0 ...
  • Java 字符串转float运算 float转字符串

    万次阅读 2017-09-15 14:56:13
    需求:字符串(字符串只有一位小数)转float进行运算, 将结果转成字符串(保留一位小数) 直接上代码: float f1 = 0.1f; String a1 ="1.5"; System.out.println(Float.parseFloat(a1)+f1); 答案:1.6 float f1 = ...
  • float属性

    千次阅读 2019-10-23 00:00:09
    float属性 注:浮动元素产生了浮动流        所有产生浮动流的元素,块级元素看不到它们;       产生了bfc的元素和文本类属性(inline)的元素...
  • 错误解决:ValueError: could not convert string to float

    万次阅读 多人点赞 2019-07-30 08:54:56
    有毒吧,之前好好的,突然报这个错: ValueError: could not convert string to float
  • float与double的区别,以及float为什么要加f

    万次阅读 多人点赞 2018-03-01 17:56:11
    单精度浮点数(float)与双精度浮点数(double)的区别如下: (1)在内存中占有的字节数不同 单精度浮点数(float)在机内占4个字节 双精度浮点数(double)在机内占8个字节 (2)有效数字位数不同 单精度...
  • 示例错误代码 ... float max(float array[],n); float a[5]={1,2,3,4,5}; printf("the max number is %d\n",max(a[5]); } //函数定义部分不重要。只是用作示例。 float max(float array[],n) { int i,...
  • 关于int/float/Intger/Float之间的转换

    千次阅读 2019-01-08 18:46:59
    对于int、float这样的基本类型,int类型可以自动转换为float,而float可以强制转为int。 但是如果涉及到Intger、Float这样的包装类型,则不可以强转。可以将其先转为String类型,然后使用Xxx.parseXxx方法转换。...
  • MySQL中的float、double和decimal类型

    万次阅读 2016-02-17 10:54:11
    MySQL中的float和decimal类型 float,double容易产生误差,对精确度要求比较高时,建议使用decimal来存,decimal在mysql内存是以字符串存储的,用于定义货币要求精确度高的数据。在数据迁移中,float(M,D)是非标准...
  • 3.string和float32、float64 4.string和time 5.转换函数说明 ParseInt函数的官方介绍 ParseFloat函数的官方介绍 FormatFloat函数的官方介绍 1.float64转intint转int64 // float64转int var a float64 a = ...
  • C++ float乘法怎样截取6位小数

    千次阅读 2017-07-20 14:15:11
    float
  • Float的用法

    千次阅读 2019-03-20 00:09:09
    float的用法 1.设计初期的用法 为了使文字环绕图片的用法。 2.有两种常见的使用方法 1.固定布局写法: .tupian{width:56px;float:right;} .wenzi{width:484px;float:right;} 2.流体布局写法: .tupian{width:56px;...
  • CSS float

    千次阅读 2014-03-23 23:37:46
    今天用了两三个小时终于彻底弄明白了CSS中float的内涵和用法,是这篇文章《CSS Float Theory: Things You Should Know》让我最终茅塞顿开。 虽然网上有成千上万篇文章讲float,讲clear both的用法,但是都是得其形,...

空空如也

1 2 3 4 5 ... 20
收藏数 204,809
精华内容 81,923
关键字:

float