标签: double-precision

我正在编写一个计算PI值的函数,并将其作为double返回.到现在为止还挺好.但是一旦函数在小数位后达到14位,就不能再保持.我假设这是因为双精度有限.我应该怎么做才能在小数点后继续获得更多数字？

我一直在制作一个矩阵类(作为一个学习练习),并且在测试我的反函数时遇到了问题.

我输入一个任意矩阵:

2 1 1
1 2 1
1 1 2

并得到它来计算逆,我得到了正确的结果:

0.75 -0.25 -0.25
-0.25 0.75 -0.25
-0.25 -0.25 0.75

但当我尝试将两者相乘以确保我得到单位矩阵时,我得到:

1 5.5111512e-017 0
0 1 0
-1.11022302e-0.16 0 1

为什么我得到这些结果？我会理解,如果我将奇怪的数字乘以我可以理解的一些舍入误差,但它所做的总和是:

2 * -0.25 + 1 * 0.75 + 1 * -0.25

这显然是0,而不是5.111512e-017

如果我手动让它进行计算; 例如:

std::cout << (2 * -0.25 + 1 * 0.75 + 1 * -0.25) << "\n";

我按预期得到0？

所有数字都表示为双打.这是我的多重过载:

Matrix operator*(const Matrix& A, const Matrix& B)
{
    if(A.get_cols() == B.get_rows())
    {
        Matrix temp(A.get_rows(), B.get_cols());
        for(unsigned m …

我有一个 double 的文本表示，想知道将它往返于 double 和 back 是否安全。如果我也想接受任何类型的输入类型，我怎么知道这一点？或者我怎么知道当用 Double.Parse 解析双字符串时是否有任何精度丢失？或者我如何 ToString a double 以匹配与另一个双字符串相同的格式？对这些问题中的任何一个的回答将是我认为的解决方案。

我问,因为我正在计算矩阵乘法,其中所有矩阵值都是整数.

我想使用LAPACK,以便获得正确的快速代码.将两个大整数(其乘积小于2^53)整数存储为doubles时,会产生double包含精确整数结果的整数吗？

何时BigDecimal使用输入double和BigDecimal输入String不同的结果似乎出现.

BigDecimal a = new BigDecimal(0.333333333);
BigDecimal b = new BigDecimal(0.666666666);

BigDecimal c = new BigDecimal("0.333333333");
BigDecimal d = new BigDecimal("0.666666666");

BigDecimal x = a.multiply(b);
BigDecimal y = c.multiply(d);

System.out.println(x);
System.out.println(y);

x输出为

0.222222221777777790569747304508155316795087227497352441864147715340493949298661391367204487323760986328125

而你是

0.222222221777777778

我错误地说这是因为双重不精确？但既然这是一个BigDecimal,不应该是一样的吗？

我正在努力将sqrt函数(对于64位双精度数)从fdlibm移植到我目前正在使用的模型检查器工具(cbmc).
作为我的一部分,我阅读了很多关于ieee-754标准的内容,但我认为我不理解基本操作(包括sqrt)的精度保证.

测试我的fdlibm的sqrt端口,我在64位double上使用sqrt进行了以下计算:

sqrt(1977061516825203605555216616167125005658976571589721139027150498657494589171970335387417823661417383745964289845929120708819092392090053015474001800648403714048.0) = 44464159913633855548904943164666890000299422761159637702558734139742800916250624.0

(这个案例在我的测试中打破了关于精度的简单后置条件;我不确定是否可以使用IEEE-754来实现这种后置条件)

为了进行比较,几个多精度工具计算如下:

sqrt(1977061516825203605555216616167125005658976571589721139027150498657494589171970335387417823661417383745964289845929120708819092392090053015474001800648403714048.0) =44464159913633852501611468455197640079591886932526256694498106717014555047373210.truncated

可以看出,左起第17个数字是不同的,意味着如下错误:

3047293474709469249920707535828633381008060627422728245868877413.0

问题1:是否允许这么大的错误？

标准是说每个基本操作(+, - ,*,/,sqrt)应该在0.5 ulps之内,这意味着它应该等于数学上精确的结果四舍五入到最近的fp表示(维基说的是一些库)只保证1 ulp,但目前并不重要).

问题2:这是否意味着,每个基本操作都应该有一个错误<2.220446e-16,64位双精度(机器epsilon)？

我用x86-32 linux系统(glibc/eglibc)计算了相同的结果,并得到了与fdlibm相同的结果,让我想到:

• a:我做错了什么(但是如何:printf将成为候选人,但我不知道是否可能是这个原因)
• b:错误/精度在这些库中很常见

在MATLAB(r2009b)中,我有一个包含值2147484101的uint32变量.

这个数字(4字节)是在抓取过程中从数字机器视觉相机中提取的.根据我的理解,它具有相机快门速度的单精度形式(应接近1/260s = 3.8ms).

如何使用MATLAB中提供的内容将此32位数转换为IEEE单精度浮点表示？

对于变量n中提到的值,我尝试使用nn = dec2hex(n,16)和hex2num(nn)的组合.但似乎hex2num期望十六进制编码是双精度的而不是单一的,因为它在这里.至少我用这种方法得到了奇怪的数字.

有任何想法吗？

编辑:尝试@Matt的答案如下:

typecast(uint32(2147484101),'single') %# without swapbytes
typecast(swapbytes(uint32(2147484101)),'single') %# with swapbytes

这使:

ans =

  -6.3478820e-043

ans =

  -2.0640313e+003

我在http://www.h-schmidt.net/FloatApplet/IEEE754.html上尝试了IEEE 754转换器(JAVA applet).

使用:

format hex
typecast(uint32(2147484101),'uint8') %# without swapbytes
typecast(swapbytes(uint32(2147484101)),'uint8') %# with swapbytes

给

ans =

   c5   01   00   80

ans =

   80   00   01   c5

将这些字节输入applet(十六进制)给出了与MATLAB相同的数字.

我有一个数字(比方说,34),我想找到它的下一个十的倍数.我可以这样做:

1. 将数字除以10
2. 将其四舍五入到一个整数
3. 乘以10.

经过一番研究后,我发现这是Objective C中的代码:

int number = 34;
int roundedNumber = ceil((double)number/10)*10;

我的问题是:什么是(double)for,为什么删除(double)导致它向下舍入而不是向上？

我从谷歌搜索中了解到,将浮动格式更改为"双精度",但说实话,这对我来说太复杂了.任何人都可以简单解释它在做什么吗？

我正在编写一个程序，其中我需要以非常高的精度（大约10^-10）存储数字，然后进一步使用它们作为参数（create_bloomfilter ([yet to decide the type] falsePositivity, long expected_num_of_elem)）。
我能够获得的最高精度是double（周围的东西10^-6）这还不够。

我们如何在 c 中以更高的精度存储数字？

从C++ 11标题,我想知道一个std::uniform_real_distribution<double>对象是否可以吐出一个大于0.99999999999999994的双精度？如果是这样,将该值乘以2将等于2.

例:

std::default_random_engine engine;
std::uniform_real_distribution<double> dist(0,1);

double num = dist(engine);

if (num > 0.99999999999999994) 
    num = 0.99999999999999994;

int test1 = (int)(0.99999999999999994 * 2);
int test2 = (int)(0.99999999999999995 * 2);

std::cout << test1 << std::endl; // 1
std::cout << test2 << std::endl; // 2