这个数字的小数点多于 D 位吗？

Question

假设我想编写一个执行以下操作的函数：

给定一个数字 N，
当 N 舍入为 D1 位时
结果是否包含超过 D2 位小数，不包括尾随零？

例如，假设 N 是 0.01001，D1 是 4，D2 是 2。问题就变成了，.0100 是否包含超过 2 个小数位，不包括尾随零？答案是“不”。但如果 N 是 0.00101，答案将是“是”。

考虑到浮点数的限制，我正在寻找一种使用标准 C 库函数执行此操作的有效方法。

我的预期用法示例：如有必要，使用四位数字显示数字，否则使用两位数字显示。

（这不是作业题——这是作为一名专业程序员的结果，他在学生时代没有做这些作业。）

Answer 1

使用标准库执行此操作的唯一简单方法是使用正确格式的snprintf（或只是sprintf），然后自己数零。正确计算（二进制）浮点数的十进制表示是一项非常非常困难的任务，您不想尝试自己做，而且您编写比标准库更快的正确版本的机会几乎为零.

我希望我做对了；未经测试：

double n; /* the number N */
int d1, d2; /* the parameters d1 and d2 */
char s[MAXLEN], *z;
snprintf(s, sizeof s, "%.*f", d1, n);
for (z=s+strlen(s)-1; *z==0; z--);
if (strlen(++z)<d1-d2) puts("yes");
else puts("no");

编辑： 正如 ssianky 所指出的，snprintf 可能对其打印的精度有限制。实际上，只要实现文档本身，C 标准几乎允许任何浮点运算无缘无故地给出错误结果，但是鼓励 IEEE 行为，并且 POSIX 还要求正确舍入到 DECIMAL_DIG 位的结果，但是允许实现在打印足够多的位置以唯一确定实际浮点值之后打印废话（例如全零）。所以长话短说，如果d1 相当大，或者如果您的平台是病态的，基于snprintf 的方法可能无法给出正确的答案。 （实际上，他们会在 GNU 系统上给出正确答案，而在 Microsoft 系统上给出错误答案。）

如果您关心这个缺点并希望得到d1 的任何值的正确结果，则必须使用implement exact float-to-decimal code yourself。涉及将浮点值重复乘以 10 的循环是不够的。

编辑 2：查看 OP 的“预期用途”，使用 snprintf 似乎很容易。如果您想打印开头的值并且只是想决定要使用多少小数位，只需将其打印到一个字符串中，然后在显示它之前去掉尾随的零。事实上，%gprintf 格式说明符甚至可以做 OP 想要做的事情......

Answer 2

您可以先将您的数字乘以 10^D1 并将其四舍五入到最接近的整数，然后检查它是否可被 10^D2 整除。有一些舍入函数可供选择，它们将向上/向下舍入/远离零等，因此请务必检查您是否使用了您想要的。

下面的函数被编写成很小且独立的，但生产实现应该使用十次方的查找表，如注释行中所示。这将产生更快的性能并避免在浮点乘积中累积错误。

int f (double N, unsigned int D1, unsigned int D2)
{
   int i, n_mult_round, ten_d2;
   /* instead of the loop below, a real implementation should use */
   /* N *= dbl_powers_of_ten[D1]; */
   /* where dbl_powers_of_ten is a double array containing powers of ten */
   for (i = 0; i < D1; ++i) {
      N *= 10.0;
   }
   n_mult_round = (int) round (N);
   /* instead of the loop below, a real implementation should use */
   /* ten_d2 = int_powers_of_ten[D2]; */
   /* where int_powers_of_ten is an int array containing powers of ten */
   ten_d2 = 1;
   for (i = 0; i < D2; ++i) {
      ten_d2 *= 10;
   }
   if ( n_mult_round % ten_d2 == 0 ) {
      return ( 1 );
   }
   else {
      return ( 0 );
   }
}

Answer 3

1. 将其格式化为字符串以达到最大精度。
2. 从右边删除零，直到达到最小精度。

这里有一个不安全的实现来帮助您入门：

char buff[20]; /* make as big as necessary */
int maxPrecision = 4;
int minPrecision = 2;

sprintf(buff, "%.*f", maxPrecision, myFloat);

char *p = buff + (strlen(buff) - 1);
char *punct = strchr(buff, ".");

/* remove trailing zeros until we reach minPrecision */
while (*p == '0' && p > (punct + minPrecision))
    *p-- = 0; 

Answer 4

这个呢？ fmod 应该返回指定小数位数之后的小数，所以我们可以比较这两个数字，看看它们是否相等。

int needsD1Decimals(float N, int D1, int D2) {
    float pow1 = pow(0.1f, D1); // 0.0001
    float pow2 = pow(0.1f, D2); // 0.01
    float mod1 = fmod(N, pow1); // 0.00001
    float mod2 = fmod(N, pow2); // 0.00001
    if (fabs(mod1 - mod2) > (pow1 / 2)) { // > 0.00005 to handle errors
        return 1;
    }
    return 0;
}

如果您只是想打印出正确的答案，那么只打印最多小数位并在末尾截断零可能会更快：

void printNumber(float N, int D1, int D2) {
    char format[256];
    char result[256];
    sprintf(format, "%%.%df", D1);
    sprintf(result, format, N);
    char *end = result + strlen(result) - 1;
    int zeros = 0;
    while (end > result && end[0] == '0' && zeros < (D1 - D2))
    {
        zeros++;
        end--;
    }
    if (zeros >= (D1 - D2))
    {
        end[1] = '\0';
    }
    puts(result);
}

void doNumber(float N, int D1, int D2) {
    printf("%f, %d, %d: ", N, D1, D2);
    printNumber(N, D1, D2);
    printf("\n");
}

int _tmain(int argc, _TCHAR* argv[])
{
    doNumber(0.01001f, 4, 2);
    doNumber(0.010101f, 4, 2);
    doNumber(0.011001f, 4, 2);
    doNumber(5000.0f, 4, 2);
    return 0;
}

Answer 5

int foo(float number, int d1, int d2)
{
    assert((number > 0.0f) && (number < 1.0f) && (d1 <= FLT_DIG) && (d2 < d1) && (d2 > 0));

    int count = d1;
    int n = (int)(number * pow(10.0f, d1));

    if (n == 0) return 0;

    while ((n % 10) == 0)
    {
        n /= 10;
        count--;
    }

    return (count > d2) ? 1 : 0;
}