6

Вопрос по c, printf, floating-point – C динамически печатает double, без потери точности и без конечных нулей

Я новичок в C и учусь вне книги / в интернете. Я'я пытаюсь написать функцию, которую я могу передать любомуdouble чтобы и вернутьint использоваться вprintf("%.*lf" ... утверждение такое, чтоint возвращаемое значение не будет ни уменьшать точность, ни производить конечные нули.

У меня есть рабочая функция, но она довольно большая, так как написана для удобства чтения и вся закомментирована.

Чтобы подвести итог функции, я считаю, сколько делений на 10 требуется, чтобы получитьdouble В диапазоне10 > d >= 0, взять только дробную часть и положить его вstring с п десятичных знаков гдеn = 15 - number_of_digits_left_of_decimal (Я читал этот типdouble можно отслеживать только 15 цифр), проверьтеstring справа налево для конечных нулей и счетчика, и, наконец, вернутьint это представляет число ненулевых цифр справа от десятичного числа.

Есть ли более простой способ? Благодарю.

int get_number_of_digits_after_decimal(double d)
{
  int i = 0;      /* sometimes you need an int */
  int pl = 0;     /* precision left = 15 - sigfigs */
  int sigfigs = 1; /* the number of digits in d */
  char line[20];  /* used to find last non-zero digit right of the decimal place */
  double temp;    /* a copy of d used for destructive calculations */

  /* find digits to right of decimal */
  temp = d;
  while(sigfigs < 15)
  {
    if(temp < 0)
      temp *= -1;
    if(temp < 10)
      break;
    temp /= 10;
    ++sigfigs;
  }
  /* at this point 10 > temp >= 0
  * decrement temp unitl 1 > temp >=0 */
  while(temp > 1)
  {
    --temp;
  }
  if(temp == 0)
    return(0);
  pl = 15 - sigfigs;   /* if n digits left of decimal, 15-n to right */
  switch(pl)
  {
  case 14:
    sprintf(line, "%.14lf", d);
    break;
  case 13:
    sprintf(line, "%.13lf", d);
    break;
  case 12:
    sprintf(line, "%.12lf", d);
    break;
  case 11:
    sprintf(line, "%.11lf", d);
    break;
  case 10:
    sprintf(line, "%.10lf", d);
    break;
  case 9:
    sprintf(line, "%.9f", d);
    break;
  case 8:
    sprintf(line, "%.8lf", d);
    break;
  case 7:
    sprintf(line, "%.7lf", d);
    break;
  case 6:
    sprintf(line, "%.6lf", d);
    break;
  case 5:
    sprintf(line, "%.5lf", d);
    break;
  case 4:
    sprintf(line, "%.4lf", d);
    break;
  case 3:
    sprintf(line, "%.3lf", d);
    break;
  case 2:
    sprintf(line, "%.2lf", d);
    break;
  case 1:
    sprintf(line, "%.1lf", d);
    break;
  case 0:
    return(0);
    break;
  }
  i = (strlen(line) - 1); /* last meaningful digit char */
  while(1) /* start at end of string, move left checking for first non-zero */
  {
    if(line[i] == '0') /* if 0 at end */
    {
      --i;
      --pl;
    }
    else
    {
      break;
    }
  }
  return(pl);
}

<span>Ты можешь использовать<code>sprintf(line, "%.*f", pl, d);</code> вместо.<code>switch</code></span>

Mar 04, 2013, 5:18 AMотJonathan Leffler

2ответа

5

Первое, что я замечаю, это то, что выперераспределениеtemp от10 и это вызывает потерю точности.

Не останавливать вас и не отговаривать от повторных попыток, но правильная реализация этого значительно сложнее, чем вымы показали.

Гай Л. Стил и Джон Л. Уайт написали статью под названием «Как правильно печатать числа с плавающей точкой это детализирует некоторые подводные камни и представляет рабочий алгоритм для печати чисел с плавающей запятой. Это'хорошее чтение

8

Там'Вероятно, не проще. Это'Это довольно сложная проблема.

Ваш код неПравильное решение по нескольким причинам:

  • Большинство практических реализаций арифметики с плавающей точкойдесятичные, они двоичные. Таким образом, когда вы умножаете число с плавающей точкой на 10 или делите его на 10, вы можете потерять точность (это зависит от числа).
  • Хотя стандарт64-bit IEEE-754 резервы формата с плавающей точкой53 биты для мантиссы, что эквивалентно =floor(log10(2 ^ 53))15 десятичные цифры, допустимое число в этом формате может потребоваться до1080 десятичные цифры в дробной части при печати точно, о чем вы спрашиваете.

Одним из способов решения этой проблемы является использование%a спецификатор типа формата вsnprintf(), который будет печатать значение с плавающей запятой с использованием шестнадцатеричных цифр для мантиссы, а стандарт С 1999 года гарантирует, что он будет печатать все значащие цифры, если формат с плавающей запятой равен radix-2 (AKA base-2 или просто двоичный) , Таким образом, с этим вы можете получить все двоичные цифры мантиссы числа. И отсюда вы сможете выяснить, сколько десятичных цифр в дробной части.

Теперь обратите внимание, что:

1.00000 = 2+0 = 1,00000 (двоичный)

0,50000 = 2-1 = 0.10000

0,25000 = 2-2 = 0,01000

0,12500 = 2-3 = 0,00100

0.06250 = 2-4 = 0,00010

0,03125 = 2-5 = 0,00001

и так далее.

Вы можете ясно видеть здесь, что двоичная цифра вi-я позиция справа от точки в двоичном представлении создает последнюю ненулевую десятичную цифру также вi-я позиция справа от точки в десятичном представлении.

Итак, если вы знаете, где младший значащий ненулевой бит находится в двоичном числе с плавающей запятой, вы можете выяснить, сколько десятичных цифр необходимо для точной печати дробной части числа.

И это то, что делает моя программа.

Код:

// file: PrintFullFraction.c
//
// compile with gcc 4.6.2 or better:
//   gcc -Wall -Wextra -std=c99 -O2 PrintFullFraction.c -o PrintFullFraction.exe
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#if FLT_RADIX != 2
#error currently supported only FLT_RADIX = 2
#endif

int FractionalDigits(double d)
{
  char buf[
           1 + // sign, '-' or '+'
           (sizeof(d) * CHAR_BIT + 3) / 4 + // mantissa hex digits max
           1 + // decimal point, '.'
           1 + // mantissa-exponent separator, 'p'
           1 + // mantissa sign, '-' or '+'
           (sizeof(d) * CHAR_BIT + 2) / 3 + // exponent decimal digits max
           1 // string terminator, '\0'
          ];
  int n;
  char *pp, *p;
  int e, lsbFound, lsbPos;

  // convert d into "+/- 0x h.hhhh p +/- ddd" representation and check for errors
  if ((n = snprintf(buf, sizeof(buf), "%+a", d)) < 0 ||
      (unsigned)n >= sizeof(buf))
    return -1;

//printf("{%s}", buf);

  // make sure the conversion didn't produce something like "nan" or "inf"
  // instead of "+/- 0x h.hhhh p +/- ddd"
  if (strstr(buf, "0x") != buf + 1 ||
      (pp = strchr(buf, 'p')) == NULL)
    return 0;

  // extract the base-2 exponent manually, checking for overflows
  e = 0;
  p = pp + 1 + (pp[1] == '-' || pp[1] == '+'); // skip the exponent sign at first
  for (; *p != '\0'; p++)
  {
    if (e > INT_MAX / 10)
      return -2;
    e *= 10;
    if (e > INT_MAX - (*p - '0'))
      return -2;
    e += *p - '0';
  }
  if (pp[1] == '-') // apply the sign to the exponent
    e = -e;

//printf("[%s|%d]", buf, e);

  // find the position of the least significant non-zero bit
  lsbFound = lsbPos = 0;
  for (p = pp - 1; *p != 'x'; p--)
  {
    if (*p == '.')
      continue;
    if (!lsbFound)
    {
      int hdigit = (*p >= 'a') ? (*p - 'a' + 10) : (*p - '0'); // assuming ASCII chars
      if (hdigit)
      {
        static const int lsbPosInNibble[16] = { 0,4,3,4,  2,4,3,4, 1,4,3,4, 2,4,3,4 };
        lsbFound = 1;
        lsbPos = -lsbPosInNibble[hdigit];
      }
    }
    else
    {
      lsbPos -= 4;
    }
  }
  lsbPos += 4;

  if (!lsbFound)
    return 0; // d is 0 (integer)

  // adjust the least significant non-zero bit position
  // by the base-2 exponent (just add them), checking
  // for overflows

  if (lsbPos >= 0 && e >= 0)
    return 0; // lsbPos + e >= 0, d is integer

  if (lsbPos < 0 && e < 0)
    if (lsbPos < INT_MIN - e)
      return -2; // d isn't integer and needs too many fractional digits

  if ((lsbPos += e) >= 0)
    return 0; // d is integer

  if (lsbPos == INT_MIN && -INT_MAX != INT_MIN)
    return -2; // d isn't integer and needs too many fractional digits

  return -lsbPos;
}

const double testData[] =
{
  0,
  1, // 2 ^ 0
  0.5, // 2 ^ -1
  0.25, // 2 ^ -2
  0.125,
  0.0625, // ...
  0.03125,
  0.015625,
  0.0078125, // 2 ^ -7
  1.0/256, // 2 ^ -8
  1.0/256/256, // 2 ^ -16
  1.0/256/256/256, // 2 ^ -24
  1.0/256/256/256/256, // 2 ^ -32
  1.0/256/256/256/256/256/256/256/256, // 2 ^ -64
  3.14159265358979323846264338327950288419716939937510582097494459,
  0.1,
  INFINITY,
#ifdef NAN
  NAN,
#endif
  DBL_MIN
};

int main(void)
{
  unsigned i;
  for (i = 0; i < sizeof(testData) / sizeof(testData[0]); i++)
  {
    int digits = FractionalDigits(testData[i]);
    assert(digits >= 0);
    printf("%f %e %.*f\n", testData[i], testData[i], digits, testData[i]);
  }
  return 0;
}

Выход (ideone):

0.000000 0.000000e+00 0
1.000000 1.000000e+00 1
0.500000 5.000000e-01 0.5
0.250000 2.500000e-01 0.25
0.125000 1.250000e-01 0.125
0.062500 6.250000e-02 0.0625
0.031250 3.125000e-02 0.03125
0.015625 1.562500e-02 0.015625
0.007812 7.812500e-03 0.0078125
0.003906 3.906250e-03 0.00390625
0.000015 1.525879e-05 0.0000152587890625
0.000000 5.960464e-08 0.000000059604644775390625
0.000000 2.328306e-10 0.00000000023283064365386962890625
0.000000 5.421011e-20 0.0000000000000000000542101086242752217003726400434970855712890625
3.141593 3.141593e+00 3.141592653589793115997963468544185161590576171875
0.100000 1.000000e-01 0.1000000000000000055511151231257827021181583404541015625
inf inf inf
nan nan nan
0.000000 2.225074e-308 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201383090232717332404064219215980462331830553327416887204434813918195854283159012511020564067339731035811005152434161553460108856012385377718821130777993532002330479610147442583636071921565046942503734208375250806650616658158948720491179968591639648500635908770118304874799780887753749949451580451605050915399856582470818645113537935804992115981085766051992433352114352390148795699609591288891602992641511063466313393663477586513029371762047325631781485664350872122828637642044846811407613911477062801689853244110024161447421618567166150540154285084716752901903161322778896729707373123334086988983175067838846926092773977972858659654941091369095406136467568702398678315290680984617210924625396728515625

Ты это видишьπ а также0.1 верны только до15 десятичные цифры и остальные цифры показывают, к чему действительно округлились числа, поскольку эти числа не могут быть точно представлены в двоичном формате с плавающей запятой.

Вы также можете увидеть, чтоDBL_MINНаименьший положительный нормированныйdouble значение, имеет1022 цифры в дробной части и из тех, что есть715 значимые цифры.

Возможные проблемы с этим решением:

  • Ваш компиляторprintf() функции не поддерживают%a или неправильно печатать все цифры, запрашиваемые точностью (это вполне возможно).
  • Ваш компьютер использует недвоичные форматы с плавающей точкой (это крайне редко).

RelatedQuestions