<math.h> declares several functions to raise one number to the power of another (an exponential), and perform the inverse operation (a logarithm).

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

#include <complex.h>
float complex cpowf(float complex x, float complex y);
double complex cpow(double complex x, double complex y);
long double complex cpowl(long double complex x, long double complex y);

#include <tgmath.h>
floating-type pow(floating-type x);

The pow functions take two arguments, x and y, and return x raised to the power of y, x^y.

#include <math.h>
float sqrtf(float x);
double sqrt(double x);
long double sqrtl(long double x);

#include <complex.h>
float complex csqrtf(float complex x);
double complex csqrt(double complex x);
long double complex csqrtl(long double complex x);

#include <tgmath.h>
floating-type sqrt(floating-type x);

The sqrt functions return the square root of the argument, √x or x^½, equivalent to pow(x, 0.5).

#include <math.h>
float cbrtf(float x);
double cbrt(double x);
long double cbrtl(long double x);

#include <tgmath.h>
real-floating-type cbrt(real-floating-type x);

The cbrt functions return the cube root of the argument, ∛x or x^⅓, equivalent to pow(x, 1.0 / 3.0).

#include <math.h>
float expf(float x);
double exp(double x);
long double expl(long double x);

#include <complex.h>
float complex cexpf(float complex x);
double complex cexp(double complex x);
long double complex cexpl(long double complex x);

#include <tgmath.h>
floating-type exp(floating-type x);

The exp functions return e raised to the power of the argument, e^x, equivalent to pow(e, x).

#include <math.h>
float exp2f(float x);
double exp2(double x);
long double exp2l(long double x);

#include <tgmath.h>
real-floating-type exp2(real-floating-type x);

The exp2 functions return 2 raised to the power of the argument, 2^x, equivalent to pow(2.0, x).

#include <math.h>
float expm1f(float x);
double expm1(double x);
long double expm1l(long double x);

#include <tgmath.h>
real-floating-type expm1(real-floating-type x);

The expm1 functions return one less than e raised to the power of the argument, e^x−1, equivalent to exp(x) - 1.0.

#include <math.h>
float logf(float x);
double log(double x);
long double logl(long double x);

#include <complex.h>
float complex clogf(float complex x);
double complex clog(double complex x);
long double complex clogl(long double complex x);

#include <tgmath.h>
floating-type log(floating-type x);

The log functions return the natural (base-e) logarithm of the argument, ln x or log_e x.

#include <math.h>
float log1pf(float x);
double log1p(double x);
long double log1pl(long double x);

#include <tgmath.h>
real-floating-type log1p(real-floating-type x);

The log functions return the natural (base-e) logarithm of one plus the argument, ln (x+1) or log_e (x+1), equivalent to log(x + 1.0).

#include <math.h>
float log2f(float x);
double log2(double x);
long double log2l(long double x);

#include <tgmath.h>
real-floating-type log2(real-floating-type x);

The log2 functions return the base-2 logarithm of the argument, log₂ x.

#include <math.h>
float log10f(float x);
double log10(double x);
long double log10l(long double x);

#include <tgmath.h>
real-floating-type log10(real-floating-type x);

The log10 functions return the base-10 logarithm of the argument, log₁₀ x.

#include <math.h>
float logbf(float x);
double logb(double x);
long double logbl(long double x);

#include <tgmath.h>
real-floating-type logb(real-floating-type x);

The logb functions return the base-b logarithm of the argument, log_b x, where b is FLT_RADIX.