标签: floating-point-precision

有人说双精度浮点数的机器epsilon是2 ^ -53,而其他(更常见的)是2 ^ -52.我已经使用除了1之外的整数以及从上方和下方(在matlab中)进行估算来估计机器精度,并且已经获得两个值作为结果.为什么在实践中可以观察到这两个值？我认为应该总是在2 ^ -52左右产生一个epsilon.

根据IEEE Std 754-2008标准,二进制64双精度浮点格式的指数字段宽度为11位,通过1023的指数偏差进行补偿.该标准还规定最大指数为1023,并且最低为-1022.为什么最大指数不是:

2^10 + 2^9 + 2^8 + 2^7 + 2^6 + 2^5 + 2^4 + 2^3 + 2^2 + 2^1 + 2^0 - 1023 = 1024

并且最小指数不是:

0 - 1023 = -1023

谢谢!

我们可以安全地使用浮点数作为循环计数器,并在每次迭代时按小数量递增/递减它们,就像下面看似无风险的程序一样吗？​​当然我知道使用浮点数作为==运算符的操作数是愚蠢的要做的事情.但是为了"正常"目的使用浮动作为其他比较操作的操作数有什么问题？通过"正常",我的意思是,即使浮点数可能不是数字的精确数字表示,但是不是0.000000001无关的变化,在大多数情况下可以忽略吗？(例如,在以下程序中甚至不明显)

但是说,这就是我的理解.假设表示不精确,5.0实际上是4.999999.因此,当我们在每次迭代时继续递减0.5时,与0的最后一次比较可能会变为假,并且循环可能会因为相差0.000001,不显示当前输出的最后一行.我希望你能得到我的漂移.我怎么了？

#include<stdio.h>

int main(void)
{
float f;

for(f=5.0;f>=0;f-=0.5)
printf("%f\n",f);
}

输出:

5.000000
4.500000
4.000000
3.500000
3.000000
2.500000
2.000000
1.500000
1.000000
0.500000
0.000000

这是go中的示例代码：

package main

import "fmt"

func mult32(a, b float32) float32 { return a*b }
func mult64(a, b float64) float64 { return a*b }


func main() {
    fmt.Println(3*4.3)                  // A1, 12.9
    fmt.Println(mult32(3, 4.3))         // B1, 12.900001
    fmt.Println(mult64(3, 4.3))         // C1, 12.899999999999999

    fmt.Println(12.9 - 3*4.3)           // A2, 1.8033161362862765e-130
    fmt.Println(12.9 - mult32(3, 4.3))  // B2, -9.536743e-07
    fmt.Println(12.9 - mult64(3, 4.3))  // C2, 1.7763568394002505e-15

    fmt.Println(12.9 - 3*4.3)                               // A4, 1.8033161362862765e-130
    fmt.Println(float32(12.9) - float32(3)*float32(4.3))    // B4, -9.536743e-07
    fmt.Println(float64(12.9) - float64(3)*float64(4.3))    // C4, 1.7763568394002505e-15

}

A1，B1和C1行之间的结果差异是可以理解的。但是，从A2到C2的魔力来了。B2和C2的结果都不匹配A2行的结果。x2行（x …

对于x的值,测试(x == 0)是否为真？当且仅当x = 0的值时,是否存在某种余量或测试是否返回真？

我在java中编写了一个关于浮点的程序,但得到的输出并不准确; 而用C编写的相同程序确实产生了准确的结果.

代码片段:

public class One {

public static void main(String...args){

    double i, num=0.0;
    for(i=0;i<10;i++)
    num=num+0.1;
    System.out.println(num);

    }
}

输出:0.9999999999999999

C中的程序是这样的

#include<stdio.h>
main()
{

double i,num=0.0;
for(i=0;i<10;i++)
num=num+0.1;

printf("%f",num);

}

输出:1.00000

我究竟做错了什么？

我正在尝试绘制一个DataFrame使用pandas但它不起作用(有关详细信息,请参阅此类似的线程).我认为问题的一部分可能是我的DataFrame似乎是objects:

>>> df.dtypes
Field          object
Moment         object
Temperature    object

但是,如果我要将所有值转换为类型float,我会失去很多精度.列Moment中的所有值都是表单-132.2036E-06并转换为将float其df1 = df.astype(float)更改为-0.000132.

有谁知道如何保持精度？

好的,所以我得到一些数字不能用二进制正确表示,就像1/3不能用十进制完全表示一样.

那么为什么我在console.log(0.3)它返回0.3但是当我在console.log(0.1 + 0.2)时返回0.30000000000000004

为什么简单地输出0.3时会出现错误(如果是偶数),但是当加法发生时却没有？

我想要计算9^19.我的代码是:

    cout.setf(ios::fixed, ios::floatfield);
    cout.setf(ios::showpoint);
    cout<<pow(9,19)<<endl;

结果的最后2位数等于0:1350851717672992000.在Python中,9**19得到了我1350851717672992089L.似乎浮点问题.我怎么能提高精度pow？或者如何预制更好的精密功率pow？

我正在使用gcc版本4.8.2进行编译.

我想在C++中计算以下形式的总和

float result = float(x1)/y1+float(x2)/y2+....+float(xn)/yn

xi,yi都是整数.结果将是实际值的近似值.至关重要的是,该近似值小于或等于实际值.我可以假设我的所有价值观都是有限的和积极的.我尝试使用nextf(,0),就像在此代码段中一样.

cout.precision( 15 );
float a = 1.0f / 3.0f * 10; //3 1/3
float b = 2.0f / 3.0f * 10; //6 2/3
float af = nextafterf( a , 0 );
float bf = nextafterf( b , 0 );
cout << a << endl;
cout << b << endl;
cout << af << endl;
cout << bf << endl;
float sumf = 0.0f;
for ( int i = 1; i <= 3; i++ ) …