Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://en.cppreference.com/w/c/numeric/math/../fenv/../math/pow.html below:

pow, powf, powl - cppreference.com

float powf( float base, float exponent );

double pow( double base, double exponent );

long double powl( long double base, long double exponent );

#define pow( base, exponent )

1-3) Computes the value of base raised to the power exponent.

Type-generic macro: If any argument has type

,

is called. Otherwise, if any argument has integer type or has type

,

is called. Otherwise,

is called. If at least one argument is complex or imaginary, then the macro invokes the corresponding complex function (

,

,

).

If no errors occur, base raised to the power of exponent (baseexponent
) is returned.

If a domain error occurs, an implementation-defined value is returned (NaN where supported).

If a pole error or a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned.

If a range error occurs due to underflow, the correct result (after rounding) is returned.

Errors are reported as specified in math_errhandling.

If base is finite and negative and exponent is finite and non-integer, a domain error occurs and a range error may occur.

If base is zero and exponent is zero, a domain error may occur.

If base is zero and exponent is negative, a domain error or a pole error may occur.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),

• pow(+0, exponent), where exponent is a negative odd integer, returns +∞ and raises FE_DIVBYZERO
• pow(-0, exponent), where exponent is a negative odd integer, returns -∞ and raises FE_DIVBYZERO
• pow(±0, exponent), where exponent is negative, finite, and is an even integer or a non-integer, returns +∞ and raises FE_DIVBYZERO
• pow(±0, -∞) returns +∞ and may raise FE_DIVBYZERO(until C23)
• pow(+0, exponent), where exponent is a positive odd integer, returns +0
• pow(-0, exponent), where exponent is a positive odd integer, returns -0
• pow(±0, exponent), where exponent is positive non-integer or a positive even integer, returns +0
• pow(-1, ±∞) returns 1
• pow(+1, exponent) returns 1 for any exponent, even when exponent is NaN
• pow(base, ±0) returns 1 for any base, even when base is NaN
• pow(base, exponent) returns NaN and raises FE_INVALID if base is finite and negative and exponent is finite and non-integer.
• pow(base, -∞) returns +∞ for any |base|<1
• pow(base, -∞) returns +0 for any |base|>1
• pow(base, +∞) returns +0 for any |base|<1
• pow(base, +∞) returns +∞ for any |base|>1
• pow(-∞, exponent) returns -0 if exponent is a negative odd integer
• pow(-∞, exponent) returns +0 if exponent is a negative non-integer or negative even integer
• pow(-∞, exponent) returns -∞ if exponent is a positive odd integer
• pow(-∞, exponent) returns +∞ if exponent is a positive non-integer or positive even integer
• pow(+∞, exponent) returns +0 for any negative exponent
• pow(+∞, exponent) returns +∞ for any positive exponent
• except where specified above, if any argument is NaN, NaN is returned.

Although pow cannot be used to obtain a root of a negative number, cbrt is provided for the common case where exponent is 1 / 3.

#include <errno.h>
#include <fenv.h>
#include <math.h>
#include <stdio.h>
// #pragma STDC FENV_ACCESS ON
 
int main(void)
{
    // typical usage
    printf("pow(2, 10) = %f\n", pow(2, 10));
    printf("pow(2, 0.5) = %f\n", pow(2, 0.5));
    printf("pow(-2, -3) = %f\n", pow(-2, -3));
 
    // special values
    printf("pow(-1, NAN) = %f\n", pow(-1, NAN));
    printf("pow(+1, NAN) = %f\n", pow(+1, NAN));
    printf("pow(INFINITY, 2) = %f\n", pow(INFINITY, 2));
    printf("pow(INFINITY, -1) = %f\n", pow(INFINITY, -1));
 
    // error handling
    errno = 0; feclearexcept(FE_ALL_EXCEPT);
    printf("pow(-1, 1/3) = %f\n", pow(-1, 1.0 / 3));
    if (errno == EDOM)
        perror("    errno == EDOM");
    if (fetestexcept(FE_INVALID))
        puts("    FE_INVALID raised");
 
    feclearexcept(FE_ALL_EXCEPT);
    printf("pow(-0, -3) = %f\n", pow(-0.0, -3));
    if (fetestexcept(FE_DIVBYZERO))
        puts("    FE_DIVBYZERO raised");
}

Possible output:

pow(2, 10) = 1024.000000
pow(2, 0.5) = 1.414214
pow(-2, -3) = -0.125000
pow(-1, NAN) = nan
pow(+1, NAN) = 1.000000
pow(INFINITY, 2) = inf
pow(INFINITY, -1) = 0.000000
pow(-1, 1/3) = -nan
    errno == EDOM: Numerical argument out of domain
    FE_INVALID raised
pow(-0, -3) = -inf
    FE_DIVBYZERO raised

• C23 standard (ISO/IEC 9899:2024):

• 7.12.7.5 The pow functions

• 7.27 Type-generic math <tgmath.h>

• F.10.4.5 The pow functions (p: 524-525)

• C17 standard (ISO/IEC 9899:2018):

• 7.12.7.4 The pow functions (p: 248-249)

• 7.25 Type-generic math <tgmath.h> (p: 373-375)

• F.10.4.4 The pow functions (p: 524-525)

• C11 standard (ISO/IEC 9899:2011):

• 7.12.7.4 The pow functions (p: 248-249)

• 7.25 Type-generic math <tgmath.h> (p: 373-375)

• F.10.4.4 The pow functions (p: 524-525)

• C99 standard (ISO/IEC 9899:1999):

• 7.12.7.4 The pow functions (p: 229)

• 7.22 Type-generic math <tgmath.h> (p: 335-337)

• F.9.4.4 The pow functions (p: 461)

• C89/C90 standard (ISO/IEC 9899:1990):

• 4.5.5.1 The pow function

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4