5

我试图找出 C 中各种浮点格式的精度级别（即浮点、双精度和长双精度）。这是我目前正在使用的代码：

#include <stdio.h>
#define N 100000

int main(void)
{
   float max = 1.0, min = 0.0, test;
   int i;                              /* Counter for the conditional loop */

   for (i = 0; i < N; i++) {
      test = (max + min) / 2.0;
      if( (1.0 + test) != 1.0)         /* If too high, set max to test and try again */
     max = test;
  if( (1.0 + test) == 1.0)     /* If too low, set min to test and try again */
         min = test;
   }
   printf("The epsilon machine is %.50lf\n", max);
   return 0;
}

正如预期的那样，这给出了大约 ~2^-64 的值。但是，当我将减速更改为双打或“长双打”时，我得到相同的答案，我应该得到一个较小的值，但我没有。有人有什么想法吗？

4

6 回答 6

9

这取决于您所说的“精度级别”。

浮点数具有“常规”（正常）值，但也有特殊的、次正常的数字。如果您想找出不同的限制，C 标准有预定义的常量：

#include <math.h>
#include <stdio.h>
#include <float.h>

int main(void)
{
    printf("%30s: %g\n", "FLT_EPSILON", FLT_EPSILON);
    printf("%30s: %g\n", "FLT_MIN", FLT_MIN);
    printf("%30s: %g\n", "nextafterf(0.0, 1.0)", nextafterf(0.0, 1.0));
    printf("%30s: %g\n", "nextafterf(1.0, 2.0)-1", (nextafterf(1.0, 2.0) - 1.0f));
    puts("");
    printf("%30s: %g\n", "DBL_EPSILON", DBL_EPSILON);
    printf("%30s: %g\n", "DBL_MIN", DBL_MIN);
    printf("%30s: %g\n", "nextafter(0.0, 1.0)", nextafter(0.0, 1.0));
    printf("%30s: %g\n", "nextafter(1.0, 2.0)-1", (nextafter(1.0, 2.0) - 1.0));
    puts("");
    printf("%30s: %Lg\n", "LDBL_EPSILON", LDBL_EPSILON);
    printf("%30s: %Lg\n", "LDBL_MIN", LDBL_MIN);
    printf("%30s: %Lg\n", "nextafterl(0.0, 1.0)", nextafterl(0.0, 1.0));
    printf("%30s: %Lg\n", "nextafterl(1.0, 2.0)-1", (nextafterl(1.0, 2.0) - 1.0));
    return 0;
}

上面的程序为每种类型打印 4 个值：

  • 1 与该类型 ( TYPE_EPSILON )中大于 1 的最小值之间的差，
  • 给定类型 ( TYPE_MIN )中的最小正归一化值。这不包括次正规数，
  • nextafter给定类型 ( * (0... ))中的最小正值。这包括次正常的数字，
  • 大于 1 的最小数。这与TYPE_EPSILON相同，但计算方式不同。

根据您所说的“精度”的含义，以上任何一项都可能对您有用，也可能没有任何用处。

这是上面程序在我的电脑上的输出：

               FLT_EPSILON: 1.19209e-07
                   FLT_MIN: 1.17549e-38
      nextafterf(0.0, 1.0): 1.4013e-45
    nextafterf(1.0, 2.0)-1: 1.19209e-07

               DBL_EPSILON: 2.22045e-16
                   DBL_MIN: 2.22507e-308
       nextafter(0.0, 1.0): 4.94066e-324
     nextafter(1.0, 2.0)-1: 2.22045e-16

              LDBL_EPSILON: 1.0842e-19
                  LDBL_MIN: 3.3621e-4932
      nextafterl(0.0, 1.0): 3.6452e-4951
    nextafterl(1.0, 2.0)-1: 1.0842e-19
于 2010-08-13T19:10:30.720 回答
2

我不确定你的算法应该如何工作。这个（C++）给出了正确的答案：

#include <iostream>

template<typename T>
int epsilon() {
    int pow = 0;
    T eps = 1;
    while (eps + 1 != 1) {
        eps /= 2;
        --pow;
    }
    return pow + 1;
}

int main() {
    std::cout << "Epsilon for float: 2^" << epsilon<float>() << '\n';
    std::cout << "Epsilon for double: 2^" << epsilon<double>() << '\n';
}

这将计算最小值，使得当加到 1 时仍可与 1 区分开来。

输出：

Epsilon for float: 2^-23
Epsilon for double: 2^-52
于 2010-08-13T16:32:58.063 回答
2

猜猜为什么你会得到相同的答案：

if( (1.0 + test) != 1.0)

这里 1.0 是一个双精度常数，因此它将您的浮点数提升为双精度并将加法作为双精度执行。您可能想在此处声明一个临时浮点数来执行加法，或者使这些浮点数常量（1.0fIIRC）。

您可能还陷入了临时浮点数过多的精度问题，并且可能需要强制它将中间体存储在内存中以降低到正确的精度。

这是重做范围搜索方法但以正确类型计算测试的快速方法。不过，我得到的答案有点太大了。

#include <stdio.h>
#define N 100000
#define TYPE float

int main(void)
{
   TYPE max = 1.0, min = 0.0, test;
   int i;

   for (i = 0; i < N; i++)
   {
      TYPE one_plus_test;

      test = (max + min) / ((TYPE)2.0);
      one_plus_test = ((TYPE)1.0) + test;
      if (one_plus_test == ((TYPE)1.0))
      {
         min = test;
      }
      else
      {
         max = test;
      }
   }
   printf("The epsilon machine is %.50lf\n", max);
   return 0;
}
于 2010-08-13T16:22:06.573 回答
2

IEEE 754 浮点格式具有这样的特性，当重新解释为相同宽度的二进制补码整数时，它们在正值上单调递增，在负值上单调递减（参见 32 位浮点数的二进制表示）。它们还具有 0 < |f(x)| 的性质。< ∞，并且 |f(x+1) - f(x)| ≥ |f(x) − f(x−1)| （其中 f(x) 是上述对 x 的整数重新解释）。在允许类型双关且始终使用 IEEE 754-1985 的语言中，我们可以利用它在恒定时间内计算机器 epsilon。例如，在 C 中：

typedef union {
  long long i64;
  double d64;
} dbl_64;

double machine_eps (double value)
{
    dbl_64 s;
    s.d64 = value;
    s.i64++;
    return s.d64 - value;
}

来自https://en.wikipedia.org/wiki/Machine_epsilon

于 2016-05-22T20:05:58.030 回答
1

我想补充一点，您可以使用long double.

要将其应用于@Rup 的解决方案，只需将TYPEtolong double和printf语句更改为：

printf("The epsilon machine is %.50Lf\n", max);

这是我机器上的 Epsilon 使用float：

0.00000005960465188081798260100185871124267578125000

并使用long double：

0.00000000000000000005421010862427522170625011179761

差异相当显着。

于 2016-01-25T00:31:53.667 回答
0

这种代码的一个问题是编译器会将浮点变量加载到微处理器的浮点寄存器中。float如果您的微处理器只有双精度浮点寄存器，则和的精度将相同double。

您需要找到一种方法来强制编译器在每两次计算之间将浮点值存储回内存（存储到正确类型的变量中）。这样，它必须丢弃寄存器的额外精度。但是今天的编译器在优化你的代码方面很聪明。所以这可能很难实现。

于 2010-08-13T18:38:59.167 回答