在c運算指數無POW（）

int main() 
{ 
    int n = 0; 
    int base = 0; 
    while(n < 10) 
    { 
     int x = 2; 
     int answer = power(x, n); 
     float neganswer = negpower(x, n); 
     printf("%d %d %f\n", base, answer, neganswer); 
     base++; 
     n++; 
    } 
    return EXIT_SUCCESS; 
} 

int power(int base, int power) 
{ 
    int result, i; 
    result = 1; 
    for (i=0; i < power; i++) 
    { 
     result *= base; 
    } 
    return result; 
} 

int negpower(int base, int power) 
{ 
    float result, i; 

    result = 1.0; 

    for (i=0; i < power; i++) 
    { 
     result = result/base; 
    } 
    return result; 
}

所以我想在此功能，我已經取得了打電話，我認爲它正確地計算它，但是它只是輸出1.0000000通過0.0000000直接緊隨其後。我認爲我在攜帶浮動值方面存在問題，任何人都可以參加？在c運算指數無POW（）

感謝

來源

2013-09-23 Jake Cooper

這不是明智的做法是讓你的循環指數浮動（儘管它不應該引起在這種情況下麻煩）。 –

我會做的（除了固定返回類型的負值）有負功率返回'1.0 /功率（基礎，功率）'。（而且我還會將變量「power」改爲其他的東西 - 這對於多個項目使用相同的名稱是一個非常糟糕的主意。） –

接受了您的建議Hot Licks，我不知道我沒有使用手前的互惠。然而，我不能選擇你的答案作爲評論以來的最佳答案，對嗎？ –

這是因爲你返回float從negpower()其中有回報的int類型並將其分配給一個float neganswer。
變化

int negpower(int base, int power)

到

float negpower(int base, int power)

輸出：

enter image description here

旁註：

總是添加必需的頭文件。

如果函數定義出現在main()之後，則應聲明原型。

來源

2013-09-23 17:22:00 haccks

答案簡單得多。當您實際返回float時，您的否定功能將返回int。改變原型，它應該工作正常。

來源

2013-09-23 17:22:03 slugonamission

那麼，那第二點可能不是真的，因爲'result'在該函數中的類型是'float'。 –

@DennisMeng道歉，我誤解了。我有時會忘記C的類型提升規則，所以我刪除了這一點。謝謝！ – slugonamission

你在那裏有各種各樣的整數。當你這樣做時，小數點會被截斷。你應該讓你的電源函數返回浮點數，並使用浮點數base。

來源

2013-09-23 17:24:34 SuperTron

只要結果或基數是浮點數，'/'的結果都是浮點數。 –

是的，但電源功能仍然會返回ints ... – SuperTron

是的，如果方法簽名未被更正。 –

這是優化的庫，如果你有興趣：

#ifdef DOCUMENTATION 
title pow x raised to power y 
index x raised to power y 
usage 
    .s 
    double x, y, f, pow(); 
    .br 
    f = pow(x, y); 
    .s 
description 
    .s 
    Returns value of x raised to power y 
    .s 
diagnostics 
    .s 
    There are three error possible error messages from this function. 
    .s 
    If the x argument is negative the message 'pow arg negative', 
    followed by the value of x, is written to stderr. The value 
    of pow for |x| is returned. 
    .s 
    If x = 0.0 and y <= 0.0 or if result overflows the message 'pow 
    overflow', followed by the value of y, is written to stderr. 
    The value of HUGE is returned. 
    .s 
    If the result underflows and if warnings are enabled (normally not), 
    the message 'pow underflow', followed by the value of y, is written 
    to stderr. The value of 0 is returned. 
    .s 
    The suggestion of Cody and Waite, that the domain be reduced to 
    simplify the overflow test, has been adopted, consequently overflow 
    is reported if the result would exceed HUGE * 2**(-1/16). 
    2**(-1/16) is approximately 0.9576. 
    .s 
internal 
    .s 
    Algorithm from Cody and Waite pp. 84-124. This algorithm required 
    two auxiliary programs POWGA1 and POWGA2 to calculate, respectively, 
    the arrays a1[] and a2[] used to represent the powers of 2**(-1/16) 
    to more than machine precision. 
    The source code for these programs are in the files POWGA1.AUX and 
    POWGA2.AUX. The octal table on page 98 of Cody and Waite is in the 
    file POWOCT.DAT which is required on stdin by POWGA2. 
    .s 
author 
    .s 
    Hamish Ross. 
    .s 
date 
    .s 
    27-Jan-85 
#endif 

#include <math.h> 

#define MAXEXP 2031  /* (MAX_EXP * 16) - 1   */ 
#define MINEXP -2047  /* (MIN_EXP * 16) - 1   */ 

static double a1[] = { 
    1.0, 
    0.95760328069857365, 
    0.91700404320467123, 
    0.87812608018664974, 
    0.84089641525371454, 
    0.80524516597462716, 
    0.77110541270397041, 
    0.73841307296974966, 
    0.70710678118654752, 
    0.67712777346844637, 
    0.64841977732550483, 
    0.62092890603674203, 
    0.59460355750136054, 
    0.56939431737834583, 
    0.54525386633262883, 
    0.52213689121370692, 
    0.50000000000000000 
}; 
static double a2[] = { 
    0.24114209503420288E-17, 
    0.92291566937243079E-18, 
    -0.15241915231122319E-17, 
    -0.35421849765286817E-17, 
    -0.31286215245415074E-17, 
    -0.44654376565694490E-17, 
    0.29306999570789681E-17, 
    0.11260851040933474E-17 
}; 
static double p1 = 0.833333333333332114e-1; 
static double p2 = 0.125000000005037992e-1; 
static double p3 = 0.223214212859242590e-2; 
static double p4 = 0.434457756721631196e-3; 
static double q1 = 0.693147180559945296e0; 
static double q2 = 0.240226506959095371e0; 
static double q3 = 0.555041086640855953e-1; 
static double q4 = 0.961812905951724170e-2; 
static double q5 = 0.133335413135857847e-2; 
static double q6 = 0.154002904409897646e-3; 
static double q7 = 0.149288526805956082e-4; 
static double k = 0.442695040888963407; 
double pow(x, y) 
double x, y; 
{ 
    double frexp(), g, ldexp(), r, u1, u2, v, w, w1, w2, y1, y2, z; 
    int iw1, m, p; 

    if (y == 0.0) 
    return(1.0); 
    if (x <= 0.0) { 
    if (x == 0.0) { 
     if (y > 0.0) 
     return(x); 
     cmemsg(FP_POWO, &y); 
     return(HUGE); 
    } 
    else { 
     cmemsg(FP_POWN, &x); 
     x = -x; 
    } 
    } 
    g = frexp(x, &m); 
    p = 0; 
    if (g <= a1[8]) 
    p = 8; 
    if (g <= a1[p + 4]) 
    p += 4; 
    if (g <= a1[p + 2]) 
    p += 2; 
    p++; 
    z = ((g - a1[p]) - a2[p/2])/(g + a1[p]); 
    z += z; 
    v = z * z; 
    r = (((p4 * v + p3) * v + p2) * v + p1) * v * z; 
    r += k * r; 
    u2 = (r + z * k) + z; 
    u1 = 0.0625 * (double)(16 * m - p); 
    y1 = 0.0625 * (double)((int)(16.0 * y)); 
    y2 = y - y1; 
    w = u2 * y + u1 * y2; 
    w1 = 0.0625 * (double)((int)(16.0 * w)); 
    w2 = w - w1; 
    w = w1 + u1 * y1; 
    w1 = 0.0625 * (double)((int)(16.0 * w)); 
    w2 += (w - w1); 
    w = 0.0625 * (double)((int)(16.0 * w2)); 
    iw1 = 16.0 * (w1 + w); 
    w2 -= w; 
    while (w2 > 0.0) { 
    iw1++; 
    w2 -= 0.0625; 
    } 
    if (iw1 > MAXEXP) { 
    cmemsg(FP_POWO, &y); 
    return(HUGE); 
    } 
    if (iw1 < MINEXP) { 
    cmemsg(FP_POWU, &y); 
    return(0.0); 
    } 
    m = iw1/16; 
    if (iw1 >= 0) 
    m++;  
    p = 16 * m - iw1; 
    z = ((((((q7*w2 + q6)*w2 + q5)*w2 + q4)*w2 + q3)*w2 + q2)*w2 + q1)*w2; 
    z = a1[p] + a1[p] * z; 
    return(ldexp(z, m)); 
}

來源

2013-09-23 18:12:25 cMinor

在c運算指數無POW（）

回答

相關問題