标签: double-precision

我编写了程序,并在Intel Core i5-2500上的Visual Studio 2010中为x64和x86平台编译.x64版本执行大约需要19秒,x86大约需要17秒.这种行为的原因是什么？

#include "timer.h"

#include <vector>
#include <iostream>
#include <algorithm>
#include <string>
#include <sstream>

/********************DECLARATIONS************************************************/
class Vector
{
public:
    Vector():x(0),y(0),z(0){}

    Vector(double x, double y, double z)
        : x(x)
        , y(y)
        , z(z)
    {
    }

    double x;
    double y;
    double z;
};


double Dot(const Vector& a, const Vector& b)
{
    return a.x * b.x + a.y * b.y + a.z * b.z;
}


class Vector2
{
public:
    typedef double value_type;

    Vector2():x(0),y(0){}

    Vector2(double x, double y)
        : x(x)
        , …

甚至是不准确的吗？我用Apfloat任意精度重新实现了整个事情,并且我开始时应该知道它没有任何区别!

public static double bearing(LatLng latLng1, LatLng latLng2) {
 double deltaLong = toRadians(latLng2.longitude - latLng1.longitude);

 double lat1 = toRadians(latLng1.latitude);
 double lat2 = toRadians(latLng2.latitude);

 double y = sin(deltaLong) * cos(lat2);
 double x = cos(lat1) * sin(lat2) - sin(lat1) * cos(lat2) * cos(deltaLong);
 double result = toDegrees(atan2(y, x));
 return (result + 360.0) % 360.0;
}

@Test
 public void testBearing() {

  LatLng first = new LatLng(36.0, 174.0);
  LatLng second = new LatLng(36.0, 175.0);
  assertEquals(270.0, LatLng.bearing(second, first), 0.005);
  assertEquals(90.0, LatLng.bearing(first, second), 0.005);
 }

测试中的第一个断言给出了: …

在java中这个简单的"双重"计算有什么问题？

我知道一些十进制数字不能正确地用float/double二进制格式表示,但是使用变量d3,java能够存储并显示2.64而没有任何问题.

double d1 = 4.64;
double d2 = 2.0;
double d3 = 2.64;
double d4 = d1 - d2;

System.out.println("d1      : " + d1);
System.out.println("d2      : " + d2);
System.out.println("d3      : " + d3);
System.out.println("d4      : " + d4);
System.out.println("d1 - d2 : " + (d1 - d2));

回答,

d1      : 4.64
d2      : 2.0
d3      : 2.64
d4      : 2.6399999999999997
d1 - d2 : 2.6399999999999997

我想从那些double在Java中使用原始相等经验的人那里得到一些建议.使用d1 == d2两个双打d1并且d2由于可能的舍入误差而不够.

我的问题是:

1. Java是否Double.compare(d1,d2) == 0在某种程度上处理舍入错误？如1.7文档中所述,0如果d1在数值上等于,则返回值d2.是否有人确定它们在数值上是什么意思？

2. 对某些delta值使用相对误差计算,是否会推荐使用delta的通用(非特定于应用程序)值？请参阅下面的示例.

下面是考虑相对误差来检查相等性的通用函数.delta您建议从简单的操作+, - ,/,*操作中捕获大多数舍入错误的价值是多少？

public static boolean isEqual(double d1, double d2) {
    return d1 == d2 || isRelativelyEqual(d1,d2);
}

private static boolean isRelativelyEqual(double d1, double d2) {
    return delta > Math.abs(d1- d2) / Math.max(Math.abs(d1), Math.abs(d2));
}

我试图在PHP中将64位浮点数转换为64位整数(并返回).我需要保留字节,所以我正在使用pack和unpack函数.我正在寻找的功能基本上是Java的Double.doubleToLongBits()方法.http://docs.oracle.com/javase/7/docs/api/java/lang/Double.html#doubleToLongBits(double)

我设法得到这个远远的帮助来自php docs for pack()的评论:

function encode($int) {
        $int = round($int);

        $left = 0xffffffff00000000;
        $right = 0x00000000ffffffff;

        $l = ($int & $left) >>32;
        $r = $int & $right;

        return unpack('d', pack('NN', $l, $r))[1];
}
function decode($float) {
        $set = unpack('N2', pack('d', $float));
        return $set[1] << 32 | $set[2];
}

这很好用,大部分......

echo decode(encode(10000000000000));

亿

echo encode(10000000000000);

1.1710299640683E-305

但是这里变得棘手......

echo decode(1.1710299640683E-305);

-6629571225977708544

我不知道这里有什么问题.亲自试试:http://pastebin.com/zWKC97Z7

你需要在Linux上使用64位PHP.该网站似乎模拟了该设置:http://www.compileonline.com/execute_php_online.php

我注意到,当我存储一个double值,例如x = 0.56657011973046234在sqlite数据库中,然后在以后检索它时,我得到了y = 0.56657011973046201.根据sqlite规范和.NET规范(我最初都不打算阅读:)这是预期和正常的.

我的问题是,虽然高精度并不重要,但我的应用程序处理用户输入/选择代表基本3D信息的双打,然后对它们运行模拟以查找结果.此输入可以保存到sqlite数据库,以便重新加载并在以后重新运行.

之所以出现这种混淆,是因为新创建的一系列输入显然会在存储和重新加载后以相同的输入方式略微模拟(因为双值已经改变).这是合乎逻辑的,但不是理想的.

我还没有谈到如何处理这个问题,但与此同时我想将用户输入限制/钳位到可以精确存储在sqlite数据库中的值.因此,如果用户输入0.56657011973046234,它实际上被转换为0.56657011973046201.

但是,鉴于一个数字,我无法弄清楚数据库中存储了什么值,而不是实际存储和从数据库中检索它,这看起来很笨拙.有没有确定的方法这样做？

我正在测试我的一些代码,在javascript中我添加.1 + .2并且它给了我.30000000000000004而不是.3.我不明白这一点.但当我添加.1 + .3时,它给了我.4.我用Google搜索并找到了关于Double Precision添加的内容.但我不知道它是什么.

对于java中的double值,乘法运算符的保证精度是多少？

例如,2.2*100是220.00000000000003,但220是双数.220.00000000000003是220后的下一个双倍.

是否有可能建立甚至粗略地说明在处理doublejava中的两个值(加/减)时最大精度损失是多少？可能最坏的情况是两个数字无法准确表示,然后对它们执行操作,这导致一个也无法准确表示的值.

我一直在读取传感器读数的时间戳值,但由于它们以纳秒为单位提供,我认为我会将它们转换为加倍并进行转换.结果数字是一个17位数值加上分隔符.

试图直接打印它会产生科学记数法,这是我不想要的,因此我使用DecimalFormat类将其输出到4位小数的预期值.问题是,即使调试器显示了17个十进制数字,即使在'doubleValue()'调用之后,输出字符串也会显示15个数字.

码:

...
Double timestamp = (new Date().getTime()) +       // Example: 1.3552299670232847E12
            ((event.timestamp - System.nanoTime()) / 1000000D);
DecimalFormat dfmt = new DecimalFormat("#.####");

switch(event.sensor.getType()){
    case Sensor.TYPE_LINEAR_ACCELERATION:
    case Sensor.TYPE_ACCELEROMETER:
        accel = event.values.clone();
        String line = "A" + LOGSEPARATOR +              
            dfmt.format(timestamp.doubleValue()) + // Prints: 1355229967023.28
...

我认为这可能是一个Android精度问题,但调试器的格式化程序也显示错误的精度.我在本地java程序中测试了这个,并且两个调用具有相同的数字量.

这是一个DecimalFormat错误/限制吗？或者我做错了什么？