猜测你为何重新获得同样的答案:

if( (1.0 + test) != 1.0)

这1.0是两倍不变的,因此,它使你的浮体翻了一番,使添加成为两倍。 您可能希望在此宣布一个临时浮标,以补充或使这些浮数不变(1.0f IIRC)。

您还可能陷入过度偏袒的临时性血压问题,可能需要迫使其储存中间商,以降低准确度。

这里可以迅速用你的范围搜索方法,但用正确的类型计算测试。 不过,我得到的答案略为大。

#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
", max);
   return 0;
}

它取决于你通过“怀孕水平”的含义。

浮动点数具有“正常”(热)数值,但也有特殊和次要数字。 如果你想确定不同的限额,则C标准预先界定了不变值:

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

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

以上方案每类印刷4个数值:

• the difference between 1 and the least value greater than 1 in that type (TYPE_EPSILON),
• the minimum positive normalized value in a given type (TYPE_MIN). This does not include subnormal numbers,
• the minimum positive value in a given type (nextafter*(0...)). This includes subnormal numbers,
• the minimum number greater than 1. This is the same as TYPE_EPSILON, but calculated in a different way.

根据你“割礼”的含义,上述任何东西都对你有用。

以上方案在我的电脑上的产出如下:

               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

我不相信你的算法应该如何发挥作用。 (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>() <<  
 ;
    std::cout << "Epsilon for double: 2^" << epsilon<double>() <<  
 ;
}

这相当于最小值,因此,如果加上1,仍可区分1。

产出:

Epsilon for float: 2^-23
Epsilon for double: 2^-52

744个浮动点格式的财产,在重新解释同一宽度的两种补充时,它们单单地增加积极价值,单单单单地减少负值(见32个轨道浮动的双位代表)。 他们还拥有以下财产:0 < «f(x)<∞, and >f(x+1) - f(x) ≥ |f (x) |f(x) ——f(x) ; f(x) 是重新解释x)。 以允许打字和始终使用ISO 754-1985的语文,我们可以利用这种语言,不断计算机器ep。 例如,在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”rel=“nofollow”https://en.wikipedia.org/wiki/Machine_epsilon

我要补充的是,通过使用<条码>长期双,你可以从浮动点计算中获得最高精确度。

为适用于@Rups解决方案,仅改动TYPE至long Double和>:

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

0.00000005960465188081798260100185871124267578125000

0.00000000000000000005421010862427522170625011179761

这种代码的一个问题是,汇编者将把浮动点变量输入微处理器的浮动点登记册。 如果你的微处理器只拥有两倍精确的浮动点登记册,那么对<代码>float和 double的精确度也将相同。

你们需要找到一种办法,迫使汇编者将浮动点值重新储存到每两种计算(即正确类型变量)之间的记忆中。 这样,它就不得不放弃登记册的进一步精确性。 但今天,汇编者正在优化你的法典。 因此,这很难实现。