标签: floating-point-precision

我正在寻找一种能够在单精度和双精度之间进行转换的方法.一个例子是划分2个整数并获得浮动结果.怎么可能？

我正在学习更多,然后我想了解浮点数.

让我们说我需要补充:

1 10000000 00000000000000000000000

1 01111000 11111000000000000000000

2的补充形式.

第一位是符号,接下来的8位是指数,最后23位是mantisa.

如果不转换为科学记数法,我该如何添加这两个数字？你能一步一步走吗？

这个东西有什么好的资源吗？视频和练习示例会很棒.

我有一个类来计算一个数字的Luhn校验和.它将整数作为输入并返回true或false以指示有效性或其他方式,或者如果给出不适当的数据类型作为输入则抛出异常.

代码如下(完整源代码在GitHub上):

class Luhn extends abstr\Prop implements iface\Prop
{
    /**
     * Test that the given data passes a Luhn check. 
     * 
     * @return bool True if the data passes the Luhn check
     * @throws \InvalidArgumentException 
     * @see http://en.wikipedia.org/wiki/Luhn_algorithm
     */
    public function isValid ()
    {
        $data   = $this -> getData ();
        $valid  = false;

        switch (gettype ($data))
        {
            case 'NULL'     :
                $valid  = true;
            break;
            case 'integer'  :
                // Get the sequence of digits that make up the number …

int main() {
float a = 20000000;
float b = 1;
float c = a+b;

if (c==a) { printf("equal"); }

else { printf("not equal");}
return 0;
}

当我跑这个时,它说"平等".但当我将a的值更改为2000000(少一个零)时答案是否定的.为什么？

我正在进行人工智能的博士研究,而且我已经开始使用CUDA库作为我的测试平台了.我以前玩过CUDA,我对GPGPU的工作原理有基本的了解,但我对浮点精度感到不安.

看看GTX680,我看到FP64:1/24 FP32,而特斯拉的完整FP64为1.31 TFLOPS.我很清楚,一张是游戏卡,而另一张是专业卡.

我问的原因很简单:我买不起特斯拉,但我可能得到两个GTX680.虽然主要目标是拥有尽可能多的CUDA内核和内存,但浮点精度可能会成为一个问题.

我的问题是:

1. Gaming GPU中的小浮点精度有多大妥协？
2. 是不是32位浮点精度的1/24太小了？特别是与之前的费米1/8 FP32相比
3. 由于浮动精度较小,是否存在计算结果错误的风险？即在SVM,VSM,Matrix操作,深度信念网络等中,由于浮点较小,我可能会遇到算法结果的问题,还是仅仅意味着操作需要更长时间/使用更多内存？

谢谢 !

以下测试将失败 C#

Assert.AreEqual<double>(10.0d, 16.1d - 6.1d);

问题似乎是浮点错误.

16.1d - 6.1d == 10.000000000000002

这使我在编写使用代码的单元测试时感到头痛double.有没有办法来解决这个问题？

在gcc上4.7.3,我的fegetround()函数返回FE_TONEAREST.根据c ++参考,这意味着从零开始四舍五入.本质上,它意味着在乘法后调整尾数的精度时保存移出的最后一位(因为它将是它应该的两倍).然后,将保存的位添加到最终的尾数结果中.

例如,浮点乘法给出以下结果:

0x38b7aad5 * 0x38b7aad5 = 0x3203c5af

乘法后的尾数是

  1011 0111 1010 1010 1101 0101
x 1011 0111 1010 1010 1101 0101
-------------------------------
1[000 0011 1100 0101 1010 1110] [1]000 0101 1001 0101 0011 1001

该[23'b]组保持有效数字,而该[1'b]组保持最后一位移出.请注意,结果的尾数是

[000 0011 1100 0101 1010 1111]

最后一位切换到,1因为由于舍入模式,该[1'b1]组被添加到拼接的尾数([23'b]集合).

这是一个让我感到难过的例子,因为它让我觉得硬件没有正确地舍入.

0x20922800 * 0x20922800 = 0x1a6e34c (check this on your machine)

  1010 0110 1110 0011 0100 1101
x 1010 …

看看IEEE float/double表示

[mantissa sign][signed exponent][unsigned mantissa]

我是否正确地假设以数字方式对这些值进行排序总是导致与按字典顺序对位模式进行排序相同？

我的另一个问题是如何获取Java中float/double的位模式(IEEE表示)的位(或更确切地说字节)？(或者仅在HotSpot JVM上,如果未指定内部表示.)

如何为任意精度小数(如java.math.BigDecimal)构造类似IEEE的表示？

在C中,如果你有一个数字除以它,你能超过1.0吗？基本上,x/x(例如5.1/5.1)最终会大于1.0吗？x可以是float,double或long double.请注意,x/x不是文字代码,就像变量x本身一样.

我试着寻找这个答案,但很难找到好的搜索条件.

public class Exponents {
    public static void main(String[] args) {
        float expFloat = 1.38e-43f;                 // 1.38 here
        System.out.println(expFloat);
    }
}

输出:

1.37E-43

这太疯狂了.输出应为1.38,其他输出正常.1.39显示1.39,1.37显示1.37,但1.38显示1.37 ---我的意思是这怎么可能？

更多的实验表明--- 1.47显示1.47,1.49显示1.49但1.48显示1.49.此外,1.58显示1.58,但1.59显示1.58.