【问题标题】:Checking limits of own pow function in C?在C中检查自己的pow函数的限制?
【发布时间】:2018-12-06 06:34:51
【问题描述】:

所以我正在尝试实现我自己的 pow 函数。为了让事情变得更简单,我可以使用 int 类型作为指数。所以代码正在工作......主要是。我有一个名为 xmath.c 的文件,我在其中实现了我的 pow 函数和另一个 test.c 来测试限制。它不工作的唯一情况是pow(-111, INT_MAX)。我怎样才能改进我的代码?还告诉我是否也应该发布 test.c 代码。 xfabs 是另一个我必须自己实现的函数,而不是使用 fabs

忘记在我的帖子中包含 xfabs:

#define xfabs(x) (((x) > 0) ? (x) : (-(x)))

#include <stdio.h>
#include <errno.h>
#include <math.h>
#include <float.h>
#include "xmath.h"

double xpow(double x, int y)
{
    errno = 0;
    double product = 1;
    double prod = 1;
    int i;

    if (y == 0) {
        return 1.0;
    } else if (x == 0 && y < 0) {
        errno = EDOM;
        return 0.0;
    }

    if (xfabs(x) >= 1) {
        if (y > 0) {
            for (i = 0; i < y; i++) {
                if (xfabs(product) > DBL_MAX / xfabs(x)) {
                        errno = ERANGE;
                        return HUGE_VAL;
                    }
                    product *= x;
                }
            return product;
        } else if (y < 0) {
            for (i = 0; i > y; i--) {
                if (xfabs(product) < DBL_MIN / xfabs(x)) {
                    errno = ERANGE;
                    return -0.0;
                }
                product *= 1 / x;
            }
            return product;
        }

    } else if (xfabs(x) < 1) {
        if (y > 0) {
            for (i = 0; i < y; i++) {
                if (xfabs(prod) < DBL_MIN / xfabs(x)) {
                    errno = ERANGE;
                    return +0.0;
                }
                prod *= x;
            }
            return prod;
        } else if (y < 0) {
            for (i = 0; i > y; i--) {
                if (xfabs(prod) < DBL_MAX / xfabs(x)) {
                    errno = ERANGE;
                    return -HUGE_VAL;
                }
                prod *= 1 / x;
            }
            return prod;
        }
    }
}

这里是测试功能。我还在为我在 test.c 中使用的 xmath.c 创建一个目标文件:

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

#include "xmath.h"

void xpow_tests(void)
{
    printf("XPOW TESTS (SUCCESS == 1 / FAILURE == 0)\n");
    printf("=================================================\n");
    printf("Test (xpow(2, 5)): \t\t%i\t", xpow(2, 5) == pow(2, 5));
    xpow(2, 5);
    printf("errno: %i\n", errno);
    printf("Test (xpow(-2, -4)): \t\t%i\t", xpow(-2, -4) == pow(-2, -4));
    xpow(-2, -4);
    printf("errno: %i\n", errno);
    printf("Test (xpow(1, 15)): \t\t%i\t", xpow(1, 15) == pow(1, 15));
    xpow(1, 15);
    printf("errno: %i\n", errno);
    printf("Test (xpow(-4, 414)): \t\t%i\t", xpow(-4, 414) == pow(-4, 414));
    xpow(-4, 414);
    printf("errno: %i\n", errno);
    printf("Test (xpow(-5, 303)): \t\t%i\t", xpow(-5, 303) == pow(-5, 303));
    xpow(-5, 303);
    printf("errno: %i\n", errno);
    printf("Test (xpow(0, -3)): \t\t%i\t", xpow(0, -3) == 0);
    xpow(0, -3);
    printf("errno: %i\n", errno);
    printf("Test (xpow(1.0e-10, 100)): \t%i\t", xpow(1.0e-10, 100) == pow(1.0e-10, 100));
    xpow(1.0e-10, 100);
    printf("errno: %i\n", errno);
    printf("Test (xpow(-1.0e-10, 101)): \t%i\t", xpow(-1.0e-10, 101) == pow(-1.0e-10, 101));
    xpow(-1.0e-10, 101);
    printf("errno: %i\n", errno);
    printf("Test (xpow(-111, INT_MAX)): \t%i\t", xpow(-111, INT_MAX) == pow(-111, INT_MAX));
    xpow(-111, INT_MAX);
    printf("errno: %i\n", errno);
    printf("Test (xpow(-111, INT_MAX-1)): \t%i\t", xpow(-111, INT_MAX-1) == pow(-111, INT_MAX-1));
    xpow(-111, INT_MAX-1);
    printf("errno: %i\n", errno);
    printf("Test (xpow(-111, -INT_MAX)): \t%i\t", xpow(-111, -INT_MAX) == pow(-111, -INT_MAX));
    xpow(-111, -INT_MAX);
    printf("errno: %i\n", errno);
    printf("Test (xpow(-111, -INT_MAX+1)): \t%i\t", xpow(-111, -INT_MAX+1) == pow(-111, -INT_MAX+1));
    xpow(-111, -INT_MAX+1);
    printf("errno: %i\n", errno);
    printf("=================================================\n");
    printf("errno (EDOM: %i / ERANGE: %i)\n\n", EDOM, ERANGE);
}

int main(void)
{
    xpow_tests();
    return 0;
}

【问题讨论】:

  • “不工作”是什么意思?请在这里给我们一些具体的东西。
  • 所以函数根本不计算 pow(-111, INT_MAX) 这意味着我的函数 xpow 没有为这些值提供任何结果,或者它们不等于实际 pow 函数的值。 .这有帮助吗?
  • 无论如何它都会给出double 结果。您是否有此代码的测试用例,您只是随意敲打它吗?测试驱动开发,您可以针对所有边界条件进行明确定义的测试,这是这里的关键。
  • 是的,我将编辑测试功能...我知道该功能有点复杂...我不知道如何改进它,因为我还在学习...
  • 你熟悉溢出的概念吗? double 可以准确表示的最大尺寸是多少?我建议从较低的指数开始并增加它直到你的结果是垃圾,然后在调试器中逐步确定原因。

标签: c function testing pow


【解决方案1】:

警告:这不是解决您失败的测试用例本身的解决方案。

但是,我稍微简化了你的功能——这可能会有所帮助。

我大大简化/增强了您的测试用例功能 [使用一些预处理器技巧]。

但是,除了你失败的测试-111,INT_MAX,当我在这里运行它时,0,-3 测试报告失败。


这是修改后的来源:

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <math.h>
#include <float.h>
#include <limits.h>
//#include "xmath.h"

double
xfabs(double x)
{

    if (x < 0)
        x = -x;

    return x;
}

double
xpow(double x, int y)
{
    errno = 0;
    int i;
    double lim;
    double prod = 1;
    double abs_x;

    if (y == 0)
        return 1.0;
    if ((x == 0) && (y < 0)) {
        errno = EDOM;
        return 0.0;
    }

    abs_x = xfabs(x);

    if (abs_x >= 1) {
        if (y > 0) {
            lim = DBL_MAX / abs_x;
            for (i = 0; i < y; i++) {
                if (xfabs(prod) > lim) {
                    errno = ERANGE;
                    return HUGE_VAL;
                }
                prod *= x;
            }
        }

        if (y < 0) {
            lim = DBL_MIN / abs_x;
            for (i = 0; i > y; i--) {
                if (xfabs(prod) < lim) {
                    errno = ERANGE;
                    return -0.0;
                }
                prod *= 1 / x;
            }
        }

        return prod;
    }

    if (y > 0) {
        lim = DBL_MIN / abs_x;
        for (i = 0; i < y; i++) {
            if (xfabs(prod) < lim) {
                errno = ERANGE;
                return +0.0;
            }
            prod *= x;
        }
    }

    if (y < 0) {
        lim = DBL_MAX / abs_x;
        for (i = 0; i > y; i--) {
            if (xfabs(prod) < lim) {
                errno = ERANGE;
                return -HUGE_VAL;
            }
            prod *= 1 / x;
        }
    }

    return prod;
}

int passcnt = 0;
int failcnt = 0;

void
dotest(const char *name,double x,int y)
{
    int sverr_pow;
    int sverr_xpow;
    double expected;
    double actual;
    int passflg;

    printf("\n");
    printf("%s\n",name);

    errno = 0;
    expected = pow(x,y);
    sverr_pow = errno;

    printf("%.16g (pow)\n",expected);
    if (sverr_pow)
        printf("errno: %d (%s)\n",sverr_pow,strerror(sverr_pow));

    errno = 0;
    actual = xpow(x,y);
    sverr_xpow = errno;

    printf("%.16g (xpow)\n",actual);
    if (sverr_xpow)
        printf("errno: %d (%s)\n",sverr_xpow,strerror(sverr_xpow));

    if ((actual == expected) && (sverr_xpow == sverr_pow))
        passcnt += 1;
    else
        failcnt += 1;

    printf("Result: Value:%s errno:%s\n",
        (actual == expected) ? "PASS" : "FAIL",
        (sverr_xpow == sverr_pow) ? "PASS" : "FAIL");
}

#define TEST(x,y) \
    dotest(#x "," #y,x,y)

void xpow_tests(void)
{
    printf("XPOW TESTS (SUCCESS == 1 / FAILURE == 0)\n");
    printf("=================================================\n");

    TEST(2, 5);
    TEST(-2, -4);
    TEST(1, 15);
    TEST(-4, 414);
    TEST(-5, 303);
    TEST(0, -3);
    TEST(1.0e-10, 100);
    TEST(-1.0e-10, 101);
    TEST(-111, INT_MAX);
    TEST(-111, INT_MAX-1);
    TEST(-111, -INT_MAX);
    TEST(-111, -INT_MAX+1);

    printf("=================================================\n");
    printf("errno (EDOM: %i / ERANGE: %i)\n\n", EDOM, ERANGE);

    printf("PASSED: %d, FAILED: %d\n",passcnt,failcnt);
}

int
main(void)
{
    xpow_tests();
    return 0;
}

这是测试的输出:

XPOW TESTS (SUCCESS == 1 / FAILURE == 0)
=================================================

2,5
32 (pow)
32 (xpow)
Result: Value:PASS errno:PASS

-2,-4
0.0625 (pow)
0.0625 (xpow)
Result: Value:PASS errno:PASS

1,15
1 (pow)
1 (xpow)
Result: Value:PASS errno:PASS

-4,414
1.789931494904685e+249 (pow)
1.789931494904685e+249 (xpow)
Result: Value:PASS errno:PASS

-5,303
-6.136366831622158e+211 (pow)
-6.136366831622158e+211 (xpow)
Result: Value:PASS errno:PASS

0,-3
inf (pow)
errno: 34 (Numerical result out of range)
0 (xpow)
errno: 33 (Numerical argument out of domain)
Result: Value:FAIL errno:FAIL

1.0e-10,100
0 (pow)
errno: 34 (Numerical result out of range)
0 (xpow)
errno: 34 (Numerical result out of range)
Result: Value:PASS errno:PASS

-1.0e-10,101
-0 (pow)
errno: 34 (Numerical result out of range)
0 (xpow)
errno: 34 (Numerical result out of range)
Result: Value:PASS errno:PASS

-111,INT_MAX
-inf (pow)
errno: 34 (Numerical result out of range)
inf (xpow)
errno: 34 (Numerical result out of range)
Result: Value:FAIL errno:PASS

-111,INT_MAX-1
inf (pow)
errno: 34 (Numerical result out of range)
inf (xpow)
errno: 34 (Numerical result out of range)
Result: Value:PASS errno:PASS

-111,-INT_MAX
-0 (pow)
errno: 34 (Numerical result out of range)
-0 (xpow)
errno: 34 (Numerical result out of range)
Result: Value:PASS errno:PASS

-111,-INT_MAX+1
0 (pow)
errno: 34 (Numerical result out of range)
-0 (xpow)
errno: 34 (Numerical result out of range)
Result: Value:PASS errno:PASS
=================================================
errno (EDOM: 33 / ERANGE: 34)

PASSED: 10, FAILED: 2

【讨论】:

  • 是的,xpow(0, -3) 应该返回一个错误,因为你不能用负数的幂来计算 0。也感谢你清理了我的代码。
  • 不客气。我也考虑过比较errno 的值,所以我编辑了代码以将其作为测试通过的一部分。你的大部分函数逻辑似乎产生了很好的结果,所以我认为你非常接近。
  • 顺便说一句,TEST(0,-1) 应该被添加。它[当前]产生不匹配。
【解决方案2】:

为了正确起见,您应该添加特殊情况if (y == 0 &amp;&amp; x == 0) { errno = EDOM;

你有很多重复的代码。您应该添加 if(y&lt;0) return 1.0/xpow(x, -y); 以摆脱这些。

代码也非常低效,循环时间比必要的长。您应该利用 x^y=(x^(y/2))^2。以递归方式执行此操作将节省大量迭代。当然,你必须用一个小插件来处理奇数。

【讨论】:

  • 我正在考虑为 x && y = 0 添加一个案例,但 0 的 0 次方应该是 1,我有一个案例 y = 0 已经返回 1。我知道代码非常混乱和无能,但我首先想让它工作。如果可以的话,我会努力改进它。
  • @Saty 为什么应该是 1?数学上 0^0 没有定义。
  • 我认为练习是创建xpow,以便它完全复制pow。而且,pow(0,0) 返回1
  • @CraigEstey 是的,这是正确的。 idk google 说它是 1。从那以后我也考虑过如何实现代码并改进它。基本上我会尝试用一个循环而不是 4 来做所有事情,我需要检查 y 是否是指数是偶数或奇数。例如,如果 x 为负但 y 为偶数,则结果将为 HUGE_VAL 正,但如果 x 为负且 y 为奇数,则结果为负,因此 -HUGE_VAL。这也将解决 xpow(-111, INT_MAX) 的问题
  • @Saty 如果这是有道理的原因。数学上未定义的原因是0^x=0和x^0=1,0^0不能同时满足。
猜你喜欢
  • 1970-01-01
  • 2012-06-02
  • 1970-01-01
  • 2013-09-03
  • 2015-06-10
  • 2023-04-08
  • 1970-01-01
  • 1970-01-01
  • 2016-07-20
相关资源
最近更新 更多