# powl(3) [osx man page]

```POW(3)							   BSD Library Functions Manual 						    POW(3)

NAME
pow -- power function

SYNOPSIS
#include <math.h>

double
pow(double x, double y);

long double
powl(long double x, long double y);

float
powf(float x, float y);

DESCRIPTION
The pow() functions compute x raised to the power y.

SPECIAL VALUES
pow(+-0, y) returns +-infinity and raises the "divide-by-zero" floating-point exception for y an odd integer < 0.

pow(+-0, y) returns +infinity and raises the "divide-by-zero" floating-point exception for y < 0 and not an odd integer.

pow(+-0, y) returns +-0 for y an odd integer > 0.

pow(+-0, y) returns +0 for y > 0 and not an odd integer.

pow(-1, +-infinity) returns 1.

pow(1, y) returns 1 for any y, even a NaN.

pow(x, +-0) returns 1 for any x, even a NaN.

pow(x, y) returns a NaN and raises the "invalid" floating-point exception for finite x < 0 and finite non-integer y.

pow(x, -infinity) returns +infinity for |x| < 1.

pow(x, -infinity) returns +0 for |x| > 1.

pow(x, +infinity) returns +0 for |x| < 1.

pow(x, +infinity) returns +infinity for |x| > 1.

pow(-infinity, y) returns -0 for y an odd integer < 0.

pow(-infinity, y) returns +0 for y < 0 and not an odd integer.

pow(-infinity, y) returns -infinity for y an odd integer > 0.

pow(-infinity, y) returns +infinity for y > 0 and not an odd integer.

pow(+infinity, y) returns +0 for y < 0.

pow(+infinity, y) returns +infinity for y > 0.

A domain error occurs if x is finite and negative and y is finite and not an integer.

A domain error can occur if x is 0 and y less than or equal to 0.

Range errors may occur.

VECTOR OPERATIONS
If you need to apply the pow() functions to SIMD vectors or arrays, using the following functions provided by the Accelerate.framework may
give significantly better performance:

#include <Accelerate/Accelerate.h>

vFloat vpowf(vFloat x, vFloat y);
vFloat vpowf(vFloat x, vSInt32 y);
void vvpowf(float *z, const float *y, const float *x, const int *n);
void vvpow(double *z, const double *y, const double *x, const int *n);
void vvpowsf(float *z, const float *y, const float *x, const int *n);
void vvpows(double *z, const double *y, const double *x, const int *n);

exp(3) math(3)

STANDARDS
The pow() function conforms to ISO/IEC 9899:2011.

4th Berkeley Distribution					 December 11, 2006					 4th Berkeley Distribution```

## Check Out this Related Man Page

```LOG(3)							   BSD Library Functions Manual 						    LOG(3)

NAME
log, log2, log10, log1p, -- logarithm functions

SYNOPSIS
#include <math.h>

double
log(double x);

long double
logl(long double x);

float
logf(float x);

double
log2(double x);

long double
log2l(long double x);

float
log2f(float x);

double
log10(double x);

long double
log10l(long double x);

float
log10f(float x);

double
log1p(double x);

long double
log1pl(long double x);

float
log1pf(float x);

DESCRIPTION
The log() function computes the value of the natural logarithm of argument x.

The log2() function computes the value of the logarithm of argument x to base 2.

The log10() function computes the value of the logarithm of argument x to base 10.

If x is nearly zero, then the common expression log(1 + x) will not be able to produce accurate results, as most (or all) of the information
in x will be lost by addition.  Instead, use log1p(x) to perform the same computation without undue loss of accuracy.  If you find yourself
using this function, you are likely to also be interested in the expm1() function.

SPECIAL VALUES
log(+-0), log2(+-0), and log10(+-0) return -infinity and raise the "divide-by-zero" floating-point exception.

log(1), log2(1), and log10(1) return +0.

log(x), log2(x), and log10(x) return a NaN and raise the "invalid" floating-point exception for x < 0.

log(+infinity), log2(+infinity), and log10(+infinity) return +infinity.

log1p(+-0) returns +-0.

log1p(-1) returns -infinity and raises the "divide-by-zero" floating-point exception.

log1p(x) returns a NaN and raises the "invalid" floating-point exception for x < -1.

log1p(+infinity) returns +infinity.

VECTOR OPERATIONS
If you need to apply the log() functions to SIMD vectors or arrays, using the following functions provided by the Accelerate.framework may
give significantly better performance:

#include <Accelerate/Accelerate.h>

vFloat vlogf(vFloat x);
vFloat vlog1pf(vFloat x);
vFloat vlog10f(vFloat x);
void vvlogf(float *y, const float *x, const int *n);
void vvlog(double *y, const double *x, const int *n);
void vvlog1pf(float *y, const float *x, const int *n);
void vvlog1p(double *y, const double *x, const int *n);
void vvlog10f(float *y, const float *x, const int *n);
void vvlog10(double *y, const double *x, const int *n);
void vvlog2f(float *y, const float *x, const int *n);
void vvlog2(double *y, const double *x, const int *n);