在C中检查自身pow函数的极限？_C_Function_Testing_Pow

在C中检查自身pow函数的极限？

c function testing

在C中检查自身pow函数的极限？,c,function,testing,pow,C,Function,Testing,Pow,所以我正在尝试实现我自己的pow功能。为了使事情更简单一些，我允许使用int类型作为指数。所以代码是有效的…主要是。我有一个名为xmath.c的文件，在其中我实现了我的pow函数和另一个test.c来测试限制。它不工作的唯一情况是pow（-111，INT\u MAX）。如何改进代码？还要告诉我是否也应该发布test.c代码xfabs是我必须自己实现的另一个功能，而不是使用fabs 忘了在我的帖子中包含xfabs： #define xfabs(x) (((x) > 0) ? (x) : (-

所以我正在尝试实现我自己的pow功能。为了使事情更简单一些，我允许使用int类型作为指数。所以代码是有效的…主要是。我有一个名为xmath.c的文件，在其中我实现了我的pow函数和另一个test.c来测试限制。它不工作的唯一情况是

pow（-111，INT\u 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;
        }
    }
}

定义xfab（x）（（x）>0）？（x）：（（x））） #包括 #包括 #包括 #包括 #包括“xmath.h” 双xpow（双x，整数y） { errno=0；双积=1；双针=1； int i；如果（y==0）{ 返回1.0； }else如果（x==0&&y<0）{ 厄尔诺=以东；返回0.0； } 如果（xfabs（x）>=1）{ 如果（y>0）{ 对于（i=0；iDBL_MAX/xfabs（x））{ errno=ERANGE；回报巨大； } 乘积*=x； } 退货产品； }else if（y<0）{ 对于（i=0；i>y；i--）{ if（xfabs（产品）0）{ 对于（i=0；iy；i--）{ if（xfabs（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;
}

#包括
#包括
#包括
#包括
#包括
#包括“xmath.h”
无效xpow\U测试（无效）
{
printf（“XPOW测试（成功==1/失败==0）\n”）；
printf（“================================================================\n”）；
printf（“测试（xpow（2,5））：\t\t%i\t”，xpow（2,5）=pow（2,5））；
xpow（2,5）；
printf（“错误号：%i\n”，错误号）；
printf（“测试（xpow（-2，-4））：\t\t%i\t”，xpow（-2，-4）=功率（-2，-4））；
xpow（-2，-4）；
printf（“错误号：%i\n”，错误号）；
printf（“Test（xpow（1,15））：\t\t%i\t”，xpow（1,15）=pow（1,15））；
xpow（1,15）；
printf（“错误号：%i\n”，错误号）；
printf（“Test（xpow（-4414））：\t\t%i\t”，xpow（-4414）=pow（-4414））；
xpow（-4414）；
printf（“错误号：%i\n”，错误号）；
printf（“测试（xpow（-5303））：\t\t%i\t”，xpow（-5303）=pow（-5303））；
xpow（-5303）；
printf（“错误号：%i\n”，错误号）；
printf（“测试（xpow（0，-3））：\t\t%i\t”，xpow（0，-3）==0）；
xpow（0，-3）；
printf（“错误号：%i\n”，错误号）；
printf（“测试（xpow（1.0e-10100））：\t%i\t”，xpow（1.0e-10100）=pow（1.0e-10100））；
xpow（1.0e-10100）；
printf（“错误号：%i\n”，错误号）；
printf（“测试（xpow（-1.0e-10101））：\t%i\t”，xpow（-1.0e-10101）=功率（-1.0e-10101））；
xpow（-1.0e-10101）；
printf（“错误号：%i\n”，错误号）；
printf（“测试（xpow（-111，INT_MAX））：\t%i\t”，xpow（-111，INT_MAX）=功率（-111，INT_MAX））；
xpow（-111，INT_MAX）；
printf（“错误号：%i\n”，错误号）；
printf（“测试（xpow（-111，INT_MAX-1））：\t%i\t”，xpow（-111，INT_MAX-1）=功率（-111，INT_MAX-1））；
xpow（-111，INT_MAX-1）；
printf（“错误号：%i\n”，错误号）；
printf（“测试（xpow（-111，-INT_MAX））：\t%i\t”，xpow（-111，-INT_MAX）=功率（-111，-INT_MAX））；
xpow（-111，-INT_MAX）；
printf（“错误号：%i\n”，错误号）；
printf（“测试（xpow（-111，-INT_MAX+1））：\t%i\t”，xpow（-111，-INT_MAX+1）=功率（-111，-INT_MAX+1））；
xpow（-111，-INT_MAX+1）；
printf（“错误号：%i\n”，错误号）；
printf（“================================================================\n”）；
printf（“错误号（EDOM:%i/语言：%i）\n\n”，EDOM，语言）；
}
内部主（空）
{
xpow_测试（）；
返回0；
}

为了确保正确性，如果（y==0&&x==0）{errno=EDOM；

您有很多重复的代码。您应该添加

if（y警告：这并不能解决您失败的测试用例本身
但是，我简化了你的函数，这可能会有帮助
我还大大简化/增强了您的测试用例功能[使用了一些预处理器技巧]
但是，除了失败的测试-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;
}

“不工作”意味着什么？请给我们一些具体的东西来建立在这里。所以函数根本不计算pow（-111，INT_MAX）这意味着我的函数xpow不会给出这些值的任何结果，或者它们不等于真实pow函数的值。这有帮助吗？不管怎样，它都会给出一个双结果。你有这个代码的测试用例吗？你只是随机地敲打它吗？测试驱动开发，你有一个定义良好的测试你的边界条件，是这里的关键。是的，我将编辑测试函数…函数有点复杂，我知道…我不知道如何改进它，因为我还在学习…你熟悉溢出的概念吗？以及一个双精度可能代表的最大大小是什么？我建议从一个较低的exp开始onent并将其递增，直到结果变成垃圾，然后在调试器中逐步确定原因。是的，xpow（0，-3）应返回一个错误，因为无法以幂次计算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