# pow

## PROLOG



           This manual page is part of the POSIX Programmer's Manual.  The
           Linux implementation of this interface may differ (consult the
           corresponding Linux manual page for details of Linux behavior), or
           the interface may not be implemented on Linux.
    


## NAME



           pow, powf, powl — power function
    


## SYNOPSIS



           #include <math.h>
    
           double pow(double _x_ , double _y_);
           float powf(float _x_ , float _y_);
           long double powl(long double _x_ , long double _y_);
    


## DESCRIPTION



           The functionality described on this reference page is aligned with
           the ISO C standard. Any conflict between the requirements
           described here and the ISO C standard is unintentional. This
           volume of POSIX.1‐2017 defers to the ISO C standard.
    
           These functions shall compute the value of _x_ raised to the power
           _y_ , _xy_.  If _x_ is negative, the application shall ensure that _y_ is
           an integer value.
    
           An application wishing to check for error situations should set
           _errno_ to zero and call _feclearexcept_(FE_ALL_EXCEPT) before calling
           these functions. On return, if _errno_ is non-zero or
           _fetestexcept_(FE_INVALID | FE_DIVBYZERO | FE_OVERFLOW |
           FE_UNDERFLOW) is non-zero, an error has occurred.
    


## RETURN VALUE



           Upon successful completion, these functions shall return the value
           of _x_ raised to the power _y_.
    
           For finite values of _x_ < 0, and finite non-integer values of _y_ , a
           domain error shall occur and either a NaN (if representable), or
           an implementation-defined value shall be returned.
    
           If the correct value would cause overflow, a range error shall
           occur and _pow_(), _powf_(), and _powl_() shall return ±HUGE_VAL,
           ±HUGE_VALF, and ±HUGE_VALL, respectively, with the same sign as
           the correct value of the function.
    
           If the correct value would cause underflow, and is not
           representable, a range error may occur, and _pow_(), _powf_(), and
           _powl_() shall return 0.0, or (if IEC 60559 Floating-Point is not
           supported) an implementation-defined value no greater in magnitude
           than DBL_MIN, FLT_MIN, and LDBL_MIN, respectively.
    
           For _y_ < 0, if _x_ is zero, a pole error may occur and _pow_(), _powf_(),
           and _powl_() shall return ±HUGE_VAL, ±HUGE_VALF, and ±HUGE_VALL,
           respectively.  On systems that support the IEC 60559 Floating-
           Point option, if _x_ is ±0, a pole error shall occur and _pow_(),
           _powf_(), and _powl_() shall return ±HUGE_VAL, ±HUGE_VALF, and
           ±HUGE_VALL, respectively if _y_ is an odd integer, or HUGE_VAL,
           HUGE_VALF, and HUGE_VALL, respectively if _y_ is not an odd integer.
    
           If _x_ or _y_ is a NaN, a NaN shall be returned (unless specified
           elsewhere in this description).
    
           For any value of _y_ (including NaN), if _x_ is +1, 1.0 shall be
           returned.
    
           For any value of _x_ (including NaN), if _y_ is ±0, 1.0 shall be
           returned.
    
           For any odd integer value of _y_ > 0, if _x_ is ±0, ±0 shall be
           returned.
    
           For _y_ > 0 and not an odd integer, if _x_ is ±0, +0 shall be
           returned.
    
           If _x_ is -1, and _y_ is ±Inf, 1.0 shall be returned.
    
           For |_x_ | < 1, if _y_ is -Inf, +Inf shall be returned.
    
           For |_x_ | > 1, if _y_ is -Inf, +0 shall be returned.
    
           For |_x_ | < 1, if _y_ is +Inf, +0 shall be returned.
    
           For |_x_ | > 1, if _y_ is +Inf, +Inf shall be returned.
    
           For _y_ an odd integer < 0, if _x_ is -Inf, -0 shall be returned.
    
           For _y_ < 0 and not an odd integer, if _x_ is -Inf, +0 shall be
           returned.
    
           For _y_ an odd integer > 0, if _x_ is -Inf, -Inf shall be returned.
    
           For _y_ > 0 and not an odd integer, if _x_ is -Inf, +Inf shall be
           returned.
    
           For _y_ < 0, if _x_ is +Inf, +0 shall be returned.
    
           For _y_ > 0, if _x_ is +Inf, +Inf shall be returned.
    
           If the correct value would cause underflow, and is representable,
           a range error may occur and the correct value shall be returned.
    


## ERRORS



           These functions shall fail if:
    
           Domain Error
                       The value of _x_ is negative and _y_ is a finite non-
                       integer.
    
                       If the integer expression (_math_errhandling_ &
                       MATH_ERRNO) is non-zero, then _errno_ shall be set to
                       **[EDOM]**.  If the integer expression (_math_errhandling_ &
                       MATH_ERREXCEPT) is non-zero, then the invalid
                       floating-point exception shall be raised.
    
           Pole Error  The value of _x_ is zero and _y_ is negative.
    
                       If the integer expression (_math_errhandling_ &
                       MATH_ERRNO) is non-zero, then _errno_ shall be set to
                       **[ERANGE]**.  If the integer expression (_math_errhandling_
                       & MATH_ERREXCEPT) is non-zero, then the divide-by-zero
                       floating-point exception shall be raised.
    
           Range Error The result overflows.
    
                       If the integer expression (_math_errhandling_ &
                       MATH_ERRNO) is non-zero, then _errno_ shall be set to
                       **[ERANGE]**.  If the integer expression (_math_errhandling_
                       & MATH_ERREXCEPT) is non-zero, then the overflow
                       floating-point exception shall be raised.
    
           These functions may fail if:
    
           Pole Error  The value of _x_ is zero and _y_ is negative.
    
                       If the integer expression (_math_errhandling_ &
                       MATH_ERRNO) is non-zero, then _errno_ shall be set to
                       **[ERANGE]**.  If the integer expression (_math_errhandling_
                       & MATH_ERREXCEPT) is non-zero, then the divide-by-zero
                       floating-point exception shall be raised.
    
           Range Error The result underflows.
    
                       If the integer expression (_math_errhandling_ &
                       MATH_ERRNO) is non-zero, then _errno_ shall be set to
                       **[ERANGE]**.  If the integer expression (_math_errhandling_
                       & MATH_ERREXCEPT) is non-zero, then the underflow
                       floating-point exception shall be raised.
    
           _The following sections are informative._
    


## EXAMPLES



           None.
    


## APPLICATION USAGE



           On error, the expressions (_math_errhandling_ & MATH_ERRNO) and
           (_math_errhandling_ & MATH_ERREXCEPT) are independent of each other,
           but at least one of them must be non-zero.
    


## RATIONALE



           None.
    


## FUTURE DIRECTIONS



           None.
    


* * *