標準ライブラリヘッダー <cmath>

 

C++

コンパイラサポート

フリースタンディングとホスト

言語

標準ライブラリ

標準ライブラリヘッダー

名前付き要件

機能テストマクロ (C++20)

言語サポートライブラリ

コンセプトライブラリ (C++20)

診断ライブラリ

メモリ管理ライブラリ

メタプログラミングライブラリ (C++11)

汎用ユーティリティライブラリ

コンテナライブラリ

イテレータライブラリ

Rangesライブラリ (C++20)

アルゴリズムライブラリ

文字列ライブラリ

テキスト処理ライブラリ

数値ライブラリ

日付と時刻ライブラリ

入出力ライブラリ

ファイルシステムライブラリ (C++17)

並行サポートライブラリ (C++11)

実行制御ライブラリ (C++26)

Technical specifications (技術仕様)

シンボルインデックス

外部ライブラリ

 

標準ライブラリヘッダー

言語サポート <cfloat> <climits> <compare> (C++20) <contracts> (C++26) <coroutine> (C++20) <csetjmp> <csignal> <cstdarg> <cstddef> <cstdint> (C++11) <cstdlib> <exception> <initializer_list> (C++11)    <limits> <new> <source_location> (C++20) <stdfloat> (C++23) <typeinfo> <version> (C++20) コンセプト <concepts> (C++20) 診断 <cassert> <cerrno> <debugging> (C++26) <stacktrace> (C++23) <stdexcept> <system_error> (C++11) メモリ管理 <memory> <memory_resource> (C++17) <scoped_allocator> (C++11) メタプログラミング <type_traits> (C++11) <ratio> (C++11)

汎用ユーティリティ <any> (C++17) <bitset> <bit> (C++20) <charconv> (C++17) <expected> (C++23) <format> (C++20) <functional> <optional> (C++17) <tuple> (C++11) <typeindex> (C++11) <utility> <variant> (C++17) コンテナ <array> (C++11) <deque> <flat_map> (C++23) <flat_set> (C++23) <forward_list> (C++11) <hive> (C++26) <inplace_vector> (C++26)    <list> <map> <mdspan> (C++23) <queue> <set> <span> (C++20) <stack> <unordered_map> (C++11) <unordered_set> (C++11) <vector> イテレータ <iterator> Ranges <generator> (C++23) <ranges> (C++20)

アルゴリズム <algorithm> <numeric> 文字列 <cctype> <cstring> <cuchar> (C++11) <cwchar> <cwctype> <string_view> (C++17) <string> テキスト処理 <clocale> <codecvt> (C++11/17/26*) <locale> <regex> (C++11) <text_encoding> (C++26)    数値 <cfenv> (C++11) <cmath> <complex> <linalg> (C++26) <numbers> (C++20) <random> (C++11) <simd> (C++26) <valarray> 時間 <chrono> (C++11) <ctime> C互換 <ccomplex> (C++11/17/20*) <ciso646> (C++20 まで) <cstdalign> (C++11/17/20*) <cstdbool> (C++11/17/20*) <ctgmath> (C++11/17/20*)

入出力 <cinttypes> (C++11) <cstdio> <filesystem> (C++17) <fstream> <iomanip> <iosfwd> <iostream> <ios> <istream> <ostream> <print> (C++23) <spanstream> (C++23) <sstream> <streambuf> <strstream> (C++98/26*) <syncstream> (C++20) 並行性サポート <atomic> (C++11) <barrier> (C++20) <condition_variable> (C++11) <future> (C++11) <hazard_pointer> (C++26) <latch> (C++20) <mutex> (C++11) <rcu> (C++26) <semaphore> (C++20) <shared_mutex> (C++14) <stdatomic.h> (C++23) <stop_token> (C++20) <thread> (C++11) 実行サポート <execution> (C++17)

 

このヘッダーは元々C標準ライブラリの<math.h>でした。

このヘッダーは数値ライブラリの一部です。

型
float_t (C++11)	floatと少なくとも同じ幅の最も効率的な浮動小数点型 (typedef)
double_t (C++11)	doubleと少なくとも同じ幅の最も効率的な浮動小数点型 (typedef)
マクロ
HUGE_VALFHUGE_VALHUGE_VALL (C++11)(C++11)	それぞれ float, double, long double のオーバーフロー値を示す (マクロ定数)
INFINITY (C++11)	正の無限大、または float 型でオーバーフローすることが保証される値に評価される (マクロ定数)
NAN (C++11)	float 型のクワイエット NaN に評価される (マクロ定数)
math_errhandlingMATH_ERRNOMATH_ERREXCEPT (C++11)(C++11)(C++11)	一般的な数学関数で使用されるエラーハンドリングメカニズムを定義する (マクロ定数)
分類
FP_NORMALFP_SUBNORMALFP_ZEROFP_INFINITEFP_NAN (C++11)(C++11)(C++11)(C++11)(C++11)	浮動小数点数のカテゴリを示す (マクロ定数)
関数
基本的な数学関数
abs(float)fabsfabsffabsl (C++11)(C++11)	浮動小数点数値の絶対値 (\(\small{|x|}\)|x|) (関数)
fmodfmodffmodl (C++11)(C++11)	浮動小数点数の除算操作における剰余 (関数)
remainderremainderfremainderl (C++11)(C++11)(C++11)	除算操作における符号付き剰余 (関数)
remquoremquofremquol (C++11)(C++11)(C++11)	除算操作における符号付き剰余および商の下位3ビット (関数)
fmafmaffmal (C++11)(C++11)(C++11)	融合積和演算 (関数)
fmaxfmaxffmaxl (C++11)(C++11)(C++11)	2つの浮動小数点数値のうち大きい方 (関数)
fminfminffminl (C++11)(C++11)(C++11)	2つの浮動小数点数値のうち小さい方 (関数)
fdimfdimffdiml (C++11)(C++11)(C++11)	2つの浮動小数点値の正の差 (\({\small\max{(0, x-y)}}\)max(0, x-y)) (関数)
nannanfnanl (C++11)(C++11)(C++11)	非数 (not-a-number, NaN) (関数)
線形補間
lerp (C++20)	線形補間関数 (関数)
指数関数
expexpfexpl (C++11)(C++11)	与えられたべき乗に累乗した e を返す (\({\small e^x}\)ex) (関数)
exp2exp2fexp2l (C++11)(C++11)(C++11)	与えられたべき乗に累乗した 2 を返す (\({\small 2^x}\)2x) (関数)
expm1expm1fexpm1l (C++11)(C++11)(C++11)	与えられたべき乗に累乗した e から 1 を引いた値を返す (\({\small e^x-1}\)ex-1) (関数)
loglogflogl (C++11)(C++11)	自然対数 (e を底とする) を計算する (\({\small\ln{x}}\)ln(x)) (関数)
log10log10flog10l (C++11)(C++11)	常用対数 (10 を底とする) を計算する (\({\small\log_{10}{x}}\)log10(x)) (関数)
log2log2flog2l (C++11)(C++11)(C++11)	与えられた数値の 2 を底とする対数 (\({\small\log_{2}{x}}\)log2(x)) (関数)
log1plog1pflog1pl (C++11)(C++11)(C++11)	与えられた数値に 1 を足した値の自然対数 (e を底とする) (\({\small\ln{(1+x)}}\)ln(1+x)) (関数)
べき乗関数
powpowfpowl (C++11)(C++11)	数値を指定されたべき乗に累乗する (\(\small{x^y}\)xy) (関数)
sqrtsqrtfsqrtl (C++11)(C++11)	平方根を計算する (\(\small{\sqrt{x}}\)√x) (関数)
cbrtcbrtfcbrtl (C++11)(C++11)(C++11)	立方根を計算する (\(\small{\sqrt[3]{x}}\)3√x) (関数)
hypothypotfhypotl (C++11)(C++11)(C++11)	斜辺 \(\scriptsize{\sqrt{x^2+y^2}}\)√x2 +y2 を計算する および \(\scriptsize{\sqrt{x^2+y^2+z^2}}\)√x2 +y2 +z2 (C++17 から) (関数)
三角関数
sinsinfsinl (C++11)(C++11)	正弦を計算する (\({\small\sin{x}}\)sin(x)) (関数)
coscosfcosl (C++11)(C++11)	余弦を計算する (\({\small\cos{x}}\)cos(x)) (関数)
tantanftanl (C++11)(C++11)	正接を計算する (\({\small\tan{x}}\)tan(x)) (関数)
asinasinfasinl (C++11)(C++11)	逆正弦を計算する (\({\small\arcsin{x}}\)arcsin(x)) (関数)
acosacosfacosl (C++11)(C++11)	逆余弦を計算する (\({\small\arccos{x}}\)arccos(x)) (関数)
atanatanfatanl (C++11)(C++11)	逆正接を計算する (\({\small\arctan{x}}\)arctan(x)) (関数)
atan2atan2fatan2l (C++11)(C++11)	符号を用いて象限を決定する逆正接 (関数)
双曲線関数
sinhsinhfsinhl (C++11)(C++11)	双曲線正弦を計算する (\({\small\sinh{x}}\)sinh(x)) (関数)
coshcoshfcoshl (C++11)(C++11)	双曲線余弦を計算する (\({\small\cosh{x}}\)cosh(x)) (関数)
tanhtanhftanhl (C++11)(C++11)	双曲線正接を計算する (\({\small\tanh{x}}\)tanh(x)) (関数)
asinhasinhfasinhl (C++11)(C++11)(C++11)	逆双曲線正弦を計算する (\({\small\operatorname{arsinh}{x}}\)arsinh(x)) (関数)
acoshacoshfacoshl (C++11)(C++11)(C++11)	逆双曲線余弦を計算する (\({\small\operatorname{arcosh}{x}}\)arcosh(x)) (関数)
atanhatanhfatanhl (C++11)(C++11)(C++11)	逆双曲線正接を計算する (\({\small\operatorname{artanh}{x}}\)artanh(x)) (関数)
誤差関数とガンマ関数
erferfferfl (C++11)(C++11)(C++11)	誤差関数 (関数)
erfcerfcferfcl (C++11)(C++11)(C++11)	相補誤差関数 (関数)
tgammatgammaftgammal (C++11)(C++11)(C++11)	ガンマ関数 (関数)
lgammalgammaflgammal (C++11)(C++11)(C++11)	ガンマ関数の自然対数 (関数)
最近接整数浮動小数点演算
ceilceilfceill (C++11)(C++11)	与えられた値以上の最小の整数 (関数)
floorfloorffloorl (C++11)(C++11)	与えられた値以下の最大の整数 (関数)
trunctruncftruncl (C++11)(C++11)(C++11)	与えられた値の絶対値以下の最大の整数 (関数)
roundroundfroundllroundlroundflroundlllroundllroundfllroundl (C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)	最近接整数、中間値はゼロから遠い方に丸める (関数)
nearbyintnearbyintfnearbyintl (C++11)(C++11)(C++11)	現在の丸めモードを使用して最近接整数を求める (関数)
rintrintfrintllrintlrintflrintlllrintllrintfllrintl (C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)	現在の丸めモードを使用して最近接整数を求める 結果が異なる場合は例外を送出する (関数)
浮動小数点操作関数
frexpfrexpffrexpl (C++11)(C++11)	数値を仮数部と2を底とする指数部に分解する (関数)
ldexpldexpfldexpl (C++11)(C++11)	数値に2の整数乗を掛ける (関数)
modfmodffmodfl (C++11)(C++11)	数値を整数部と小数部に分解する (関数)
scalbnscalbnfscalbnlscalblnscalblnfscalblnl (C++11)(C++11)(C++11)(C++11)(C++11)(C++11)	数値に FLT_RADIX のべき乗を掛ける (関数)
ilogbilogbfilogbl (C++11)(C++11)(C++11)	数値の指数部を抽出する (関数)
logblogbflogbl (C++11)(C++11)(C++11)	数値の指数部を抽出する (関数)
nextafternextafterfnextafterlnexttowardnexttowardfnexttowardl (C++11)(C++11)(C++11)(C++11)(C++11)(C++11)	与えられた値に向かって、次に表現可能な浮動小数点数値を求める (関数)
copysigncopysignfcopysignl (C++11)(C++11)(C++11)	浮動小数点数値の符号をコピーする (関数)
分類と比較
fpclassify (C++11)	与えられた浮動小数点数値を分類する (関数)
isfinite (C++11)	与えられた数値が有限値かチェックする (関数)
isinf (C++11)	与えられた数値が無限大かチェックする (関数)
isnan (C++11)	与えられた数値が NaN かチェックする (関数)
isnormal (C++11)	与えられた数値が正規化数かチェックする (関数)
signbit (C++11)	与えられた数値が負数かチェックする (関数)
isgreater (C++11)	最初の浮動小数点数引数が2番目より大きいかチェックする (関数)
isgreaterequal (C++11)	最初の浮動小数点数引数が2番目以上かチェックする (関数)
isless (C++11)	最初の浮動小数点数引数が2番目より小さいかチェックする (関数)
islessequal (C++11)	最初の浮動小数点数引数が2番目以下かチェックする (関数)
islessgreater (C++11)	最初の浮動小数点数引数が2番目より小さいか、または大きいかチェックする (関数)
isunordered (C++11)	2つの浮動小数点数値が順序付けられていないかチェックする (関数)
数学特殊関数
assoc_laguerreassoc_laguerrefassoc_laguerrel (C++17)(C++17)(C++17)	ラゲール陪多項式 (関数)
assoc_legendreassoc_legendrefassoc_legendrel (C++17)(C++17)(C++17)	ルジャンドル陪多項式 (関数)
betabetafbetal (C++17)(C++17)(C++17)	ベータ関数 (関数)
comp_ellint_1comp_ellint_1fcomp_ellint_1l (C++17)(C++17)(C++17)	（完全）第一種楕円積分 (関数)
comp_ellint_2comp_ellint_2fcomp_ellint_2l (C++17)(C++17)(C++17)	（完全）第二種楕円積分 (関数)
comp_ellint_3comp_ellint_3fcomp_ellint_3l (C++17)(C++17)(C++17)	（完全）第三種楕円積分 (関数)
cyl_bessel_icyl_bessel_ifcyl_bessel_il (C++17)(C++17)(C++17)	正則変形ベッセル関数 (関数)
cyl_bessel_jcyl_bessel_jfcyl_bessel_jl (C++17)(C++17)(C++17)	（第一種）円柱ベッセル関数 (関数)
cyl_bessel_kcyl_bessel_kfcyl_bessel_kl (C++17)(C++17)(C++17)	非正則変形ベッセル関数 (関数)
cyl_neumanncyl_neumannfcyl_neumannl (C++17)(C++17)(C++17)	円柱ノイマン関数 (関数)
ellint_1ellint_1fellint_1l (C++17)(C++17)(C++17)	（不完全）第一種楕円積分 (関数)
ellint_2ellint_2fellint_2l (C++17)(C++17)(C++17)	（不完全）第二種楕円積分 (関数)
ellint_3ellint_3fellint_3l (C++17)(C++17)(C++17)	（不完全）第三種楕円積分 (関数)
expintexpintfexpintl (C++17)(C++17)(C++17)	指数積分 (関数)
hermitehermitefhermitel (C++17)(C++17)(C++17)	エルミート多項式 (関数)
legendrelegendreflegendrel (C++17)(C++17)(C++17)	ルジャンドル多項式 (関数)
laguerrelaguerreflaguerrel (C++17)(C++17)(C++17)	ラゲール多項式 (関数)
riemann_zetariemann_zetafriemann_zetal (C++17)(C++17)(C++17)	リーマンのゼータ関数 (関数)
sph_besselsph_besselfsph_bessell (C++17)(C++17)(C++17)	（第一種）球ベッセル関数 (関数)
sph_legendresph_legendrefsph_legendrel (C++17)(C++17)(C++17)	球面ルジャンドル陪関数 (関数)
sph_neumannsph_neumannfsph_neumannl (C++17)(C++17)(C++17)	球ノイマン関数 (関数)

概要

/* floating-point-type */型のパラメータを少なくとも1つ持つ各関数について、関数シグネチャ内の/* floating-point-type */のすべての使用がその浮動小数点型に置き換えられた、各cv修飾なし浮動小数点型に対するオーバーロードが提供されます。

std::abs以外の/* floating-point-type */型のパラメータを少なくとも1つ持つ各関数について、追加のオーバーロードが提供されます。これにより、/* floating-point-type */パラメータに対応するすべての引数が算術型を持つ場合、そのようなすべての引数は、すべてのそのような引数の型のうち、最大の浮動小数点変換ランクと最大の浮動小数点変換サブランクルールを持つ浮動小数点型に効果的にキャストされます。ここで、整数型の引数はdoubleと同じ浮動小数点変換ランクを持つとみなされます。最大のランクとサブランクルールを持つそのような浮動小数点型が存在しない場合、オーバーロード解決は提供されたオーバーロードから使用可能な候補を導き出しません。

namespace std {
  using float_t = /* see description */;
  using double_t = /* see description */;
}
 
#define HUGE_VAL /* see description */
#define HUGE_VALF /* see description */
#define HUGE_VALL /* see description */
#define INFINITY /* see description */
#define NAN /* see description */
#define FP_INFINITE /* see description */
#define FP_NAN /* see description */
#define FP_NORMAL /* see description */
#define FP_SUBNORMAL /* see description */
#define FP_ZERO /* see description */
#define FP_FAST_FMA /* see description */
#define FP_FAST_FMAF /* see description */
#define FP_FAST_FMAL /* see description */
#define FP_ILOGB0 /* see description */
#define FP_ILOGBNAN /* see description */
#define MATH_ERRNO /* see description */
#define MATH_ERREXCEPT /* see description */
 
#define math_errhandling /* see description */
 
namespace std {
  /* floating-point-type */ acos(/* floating-point-type */ x);
  float acosf(float x);
  long double acosl(long double x);
 
  /* floating-point-type */ asin(/* floating-point-type */ x);
  float asinf(float x);
  long double asinl(long double x);
 
  /* floating-point-type */ atan(/* floating-point-type */ x);
  float atanf(float x);
  long double atanl(long double x);
 
  /* floating-point-type */ atan2(/* floating-point-type */ y,
                                  /* floating-point-type */ x);
  float atan2f(float y, float x);
  long double atan2l(long double y, long double x);
 
  /* floating-point-type */ cos(/* floating-point-type */e x);
  float cosf(float x);
  long double cosl(long double x);
 
  /* floating-point-type */ sin(/* floating-point-type */ x);
  float sinf(float x);
  long double sinl(long double x);
 
  /* floating-point-type */ tan(/* floating-point-type */ x);
  float tanf(float x);
  long double tanl(long double x);
 
  /* floating-point-type */ acosh(/* floating-point-type */ x);
  float acoshf(float x);
  long double acoshl(long double x);
 
  /* floating-point-type */ asinh(/* floating-point-type */ x);
  float asinhf(float x);
  long double asinhl(long double x);
 
  /* floating-point-type */ atanh(/* floating-point-type */ x);
  float atanhf(float x);
  long double atanhl(long double x);
 
  /* floating-point-type */ cosh(/* floating-point-type */ x);
  float coshf(float x);
  long double coshl(long double x);
 
  /* floating-point-type */ sinh(/* floating-point-type */ x);
  float sinhf(float x);
  long double sinhl(long double x);
 
  /* floating-point-type */ tanh(/* floating-point-type */ x);
  float tanhf(float x);
  long double tanhl(long double x);
 
  /* floating-point-type */ exp(/* floating-point-type */ x);
  float expf(float x);
  long double expl(long double x);
 
  /* floating-point-type */ exp2(/* floating-point-type */ x);
  float exp2f(float x);
  long double exp2l(long double x);
 
  /* floating-point-type */ expm1(/* floating-point-type */ x);
  float expm1f(float x);
  long double expm1l(long double x);
 
  constexpr /* floating-point-type */ frexp(/* floating-point-type */ value, int* exp);
  constexpr float frexpf(float value, int* exp);
  constexpr long double frexpl(long double value, int* exp);
 
  constexpr int ilogb(/* floating-point-type */ x);
  constexpr int ilogbf(float x);
  constexpr int ilogbl(long double x);
 
  constexpr /* floating-point-type */ ldexp(/* floating-point-type */ x, int exp);
  constexpr float ldexpf(float x, int exp);
  constexpr long double ldexpl(long double x, int exp);
 
  /* floating-point-type */ log(/* floating-point-type */ x);
  float logf(float x);
  long double logl(long double x);
 
  /* floating-point-type */ log10(/* floating-point-type */ x);
  float log10f(float x);
  long double log10l(long double x);
 
  /* floating-point-type */ log1p(/* floating-point-type */ x);
  float log1pf(float x);
  long double log1pl(long double x);
 
  /* floating-point-type */ log2(/* floating-point-type */ x);
  float log2f(float x);
  long double log2l(long double x);
 
  constexpr /* floating-point-type */ logb(/* floating-point-type */ x);
  constexpr float logbf(float x);
  constexpr long double logbl(long double x);
 
  constexpr /* floating-point-type */ modf(/* floating-point-type */ value,
                                           /* floating-point-type */* iptr);
  constexpr float modff(float value, float* iptr);
  constexpr long double modfl(long double value, long double* iptr);
 
  constexpr /* floating-point-type */ scalbn(/* floating-point-type */ x, int n);
  constexpr float scalbnf(float x, int n);
  constexpr long double scalbnl(long double x, int n);
 
  constexpr /* floating-point-type */ scalbln(/* floating-point-type */ x, long int n);
  constexpr float scalblnf(float x, long int n);
  constexpr long double scalblnl(long double x, long int n);
 
  /* floating-point-type */ cbrt(/* floating-point-type */ x);
  float cbrtf(float x);
  long double cbrtl(long double x);
 
  // absolute values
  constexpr int abs(int j);                     // freestanding
  constexpr long int abs(long int j);           // freestanding
  constexpr long long int abs(long long int j); // freestanding
  constexpr /* floating-point-type */
    abs(/* floating-point-type */ j);           // freestanding-deleted
 
  constexpr /* floating-point-type */ fabs(/* floating-point-type */ x);
  constexpr float fabsf(float x);
  constexpr long double fabsl(long double x);
 
  /* floating-point-type */ hypot(/* floating-point-type */ x,
                                  /* floating-point-type */ y);
  float hypotf(float x, float y);
  long double hypotl(long double x, long double y);
 
  // three-dimensional hypotenuse
  float hypot(/* floating-point-type */ x,
              /* floating-point-type */ y,
              /* floating-point-type */ z);
 
  /* floating-point-type */ pow(/* floating-point-type */ x,
                                /* floating-point-type */ y);
  float powf(float x, float y);
  long double powl(long double x, long double y);
 
  /* floating-point-type */ sqrt(/* floating-point-type */ x);
  float sqrtf(float x);
  long double sqrtl(long double x);
 
  /* floating-point-type */ erf(/* floating-point-type */ x);
  float erff(float x);
  long double erfl(long double x);
 
  /* floating-point-type */ erfc(/* floating-point-type */ x);
  float erfcf(float x);
  long double erfcl(long double x);
 
  /* floating-point-type */ lgamma(/* floating-point-type */ x);
  float lgammaf(float x);
  long double lgammal(long double x);
 
  /* floating-point-type */ tgamma(/* floating-point-type */ x);
  float tgammaf(float x);
  long double tgammal(long double x);
 
  constexpr /* floating-point-type */ ceil(/* floating-point-type */ x);
  constexpr float ceilf(float x);
  constexpr long double ceill(long double x);
 
  constexpr /* floating-point-type */ floor(/* floating-point-type */ x);
  constexpr float floorf(float x);
  constexpr long double floorl(long double x);
 
  /* floating-point-type */ nearbyint(/* floating-point-type */ x);
  float nearbyintf(float x);
  long double nearbyintl(long double x);
 
  /* floating-point-type */ rint(/* floating-point-type */ x);
  float rintf(float x);
  long double rintl(long double x);
 
  long int lrint(/* floating-point-type */ x);
  long int lrintf(float x);
  long int lrintl(long double x);
 
  long long int llrint(/* floating-point-type */ x);
  long long int llrintf(float x);
  long long int llrintl(long double x);
 
  constexpr /* floating-point-type */ round(/* floating-point-type */ x);
  constexpr float roundf(float x);
  constexpr long double roundl(long double x);
 
  constexpr long int lround(/* floating-point-type */ x);
  constexpr long int lroundf(float x);
  constexpr long int lroundl(long double x);
 
  constexpr long long int llround(/* floating-point-type */ x);
  constexpr long long int llroundf(float x);
  constexpr long long int llroundl(long double x);
 
  constexpr /* floating-point-type */ trunc(/* floating-point-type */ x);
  constexpr float truncf(float x);
  constexpr long double truncl(long double x);
 
  constexpr /* floating-point-type */ fmod(/* floating-point-type */ x,
                                           /* floating-point-type */ y);
  constexpr float fmodf(float x, float y);
  constexpr long double fmodl(long double x, long double y);
 
  constexpr /* floating-point-type */ remainder(/* floating-point-type */ x,
                                                /* floating-point-type */ y);
  constexpr float remainderf(float x, float y);
  constexpr long double remainderl(long double x, long double y);
 
  constexpr /* floating-point-type */ remquo(/* floating-point-type */ x,
                                             /* floating-point-type */ y, int* quo);
  constexpr float remquof(float x, float y, int* quo);
  constexpr long double remquol(long double x, long double y, int* quo);
 
  constexpr /* floating-point-type */ copysign(/* floating-point-type */ x,
                                               /* floating-point-type */ y);
  constexpr float copysignf(float x, float y);
  constexpr long double copysignl(long double x, long double y);
 
  double nan(const char* tagp);
  float nanf(const char* tagp);
  long double nanl(const char* tagp);
 
  constexpr /* floating-point-type */ nextafter(/* floating-point-type */ x,
                                                /* floating-point-type */ y);
  constexpr float nextafterf(float x, float y);
  constexpr long double nextafterl(long double x, long double y);
 
  constexpr /* floating-point-type */ nexttoward(/* floating-point-type */ x,
                                                 long double y);
  constexpr float nexttowardf(float x, long double y);
  constexpr long double nexttowardl(long double x, long double y);
 
  constexpr /* floating-point-type */ fdim(/* floating-point-type */ x,
                                           /* floating-point-type */ y);
  constexpr float fdimf(float x, float y);
  constexpr long double fdiml(long double x, long double y);
 
  constexpr /* floating-point-type */ fmax(/* floating-point-type */ x,
                                           /* floating-point-type */ y);
  constexpr float fmaxf(float x, float y);
  constexpr long double fmaxl(long double x, long double y);
 
  constexpr /* floating-point-type */ fmin(/* floating-point-type */ x,
                                           /* floating-point-type */ y);
  constexpr float fminf(float x, float y);
  constexpr long double fminl(long double x, long double y);
 
  constexpr /* floating-point-type */ fma(/* floating-point-type */ x,
                                          /* floating-point-type */ y,
                                          /* floating-point-type */ z);
  constexpr float fmaf(float x, float y, float z);
  constexpr long double fmal(long double x, long double y, long double z);
 
  // linear interpolation
  constexpr /* floating-point-type */ lerp(/* floating-point-type */ a,
                                           /* floating-point-type */ b,
                                           /* floating-point-type */ t) noexcept;
 
  // classification / comparison functions
  constexpr int fpclassify(/* floating-point-type */ x);
 
  constexpr bool isfinite(/* floating-point-type */ x);
 
  constexpr bool isinf(/* floating-point-type */ x);
 
  constexpr bool isnan(/* floating-point-type */ x);
 
  constexpr bool isnormal(/* floating-point-type */ x);
 
  constexpr bool signbit(/* floating-point-type */ x);
 
  constexpr bool isgreater(/* floating-point-type */ x,
                           /* floating-point-type */ y);
 
  constexpr bool isgreaterequal(/* floating-point-type */ x,
                                /* floating-point-type */ y);
 
  constexpr bool isless(/* floating-point-type */ x,
                        /* floating-point-type */ y);
 
  constexpr bool islessequal(/* floating-point-type */ x,
                             /* floating-point-type */ y);
 
  constexpr bool islessgreater(/* floating-point-type */ x,
                               /* floating-point-type */ y);
 
  constexpr bool isunordered(/* floating-point-type */ x,
                             /* floating-point-type */ y);
 
  // mathematical special functions
 
  // associated Laguerre polynomials
  /* floating-point-type */ assoc_laguerre(unsigned n, unsigned m,
                                           /* floating-point-type */ x);
  float assoc_laguerref(unsigned n, unsigned m, float x);
  long double assoc_laguerrel(unsigned n, unsigned m, long double x);
 
  // associated Legendre functions
  /* floating-point-type */ assoc_legendre(unsigned l, unsigned m,
                                           /* floating-point-type */ x);
  float assoc_legendref(unsigned l, unsigned m, float x);
  long double assoc_legendrel(unsigned l, unsigned m, long double x);
 
  // beta function
  /* floating-point-type */ beta(/* floating-point-type */ x,
                                 /* floating-point-type */ y);
  float betaf(float x, float y);
  long double betal(long double x, long double y);
 
  // complete elliptic integral of the first kind
  /* floating-point-type */ comp_ellint_1(/* floating-point-type */ k);
  float comp_ellint_1f(float k);
  long double comp_ellint_1l(long double k);
 
  // complete elliptic integral of the second kind
  /* floating-point-type */ comp_ellint_2(/* floating-point-type */ k);
  float comp_ellint_2f(float k);
  long double comp_ellint_2l(long double k);
 
  // complete elliptic integral of the third kind
  /* floating-point-type */ comp_ellint_3(/* floating-point-type */ k,
                                          /* floating-point-type */ nu);
  float comp_ellint_3f(float k, float nu);
  long double comp_ellint_3l(long double k, long double nu);
 
  // regular modified cylindrical Bessel functions
  /* floating-point-type */ cyl_bessel_i(/* floating-point-type */ nu,
                                         /* floating-point-type */ x);
  float cyl_bessel_if(float nu, float x);
  long double cyl_bessel_il(long double nu, long double x);
 
  // cylindrical Bessel functions of the first kind
  /* floating-point-type */ cyl_bessel_j(/* floating-point-type */ nu,
                                         /* floating-point-type */ x);
  float cyl_bessel_jf(float nu, float x);
  long double cyl_bessel_jl(long double nu, long double x);
 
  // irregular modified cylindrical Bessel functions
  /* floating-point-type */ cyl_bessel_k(/* floating-point-type */ nu,
                                         /* floating-point-type */ x);
  float cyl_bessel_kf(float nu, float x);
  long double cyl_bessel_kl(long double nu, long double x);
 
  // cylindrical Neumann functions;
  // cylindrical Bessel functions of the second kind
  /* floating-point-type */ cyl_neumann(/* floating-point-type */ nu,
                                        /* floating-point-type */ x);
  float cyl_neumannf(float nu, float x);
  long double cyl_neumannl(long double nu, long double x);
 
  // incomplete elliptic integral of the first kind
  /* floating-point-type */ ellint_1(/* floating-point-type */ k,
                                     /* floating-point-type */ phi);
  float ellint_1f(float k, float phi);
  long double ellint_1l(long double k, long double phi);
 
  // incomplete elliptic integral of the second kind
  /* floating-point-type */ ellint_2(/* floating-point-type */ k,
                                     /* floating-point-type */ phi);
  float ellint_2f(float k, float phi);
  long double ellint_2l(long double k, long double phi);
 
  // incomplete elliptic integral of the third kind
  /* floating-point-type */ ellint_3(/* floating-point-type */ k,
                                     /* floating-point-type */ nu,
                                     /* floating-point-type */ phi);
  float ellint_3f(float k, float nu, float phi);
  long double ellint_3l(long double k, long double nu, long double phi);
 
  // exponential integral
  /* floating-point-type */ expint(/* floating-point-type */ x);
  float expintf(float x);
  long double expintl(long double x);
 
  // Hermite polynomials
  /* floating-point-type */ hermite(unsigned n, /* floating-point-type */ x);
  float hermitef(unsigned n, float x);
  long double hermitel(unsigned n, long double x);
 
  // Laguerre polynomials
  /* floating-point-type */ laguerre(unsigned n, /* floating-point-type */ x);
  float laguerref(unsigned n, float x);
  long double laguerrel(unsigned n, long double x);
 
  // Legendre polynomials
  /* floating-point-type */ legendre(unsigned l, /* floating-point-type */ x);
  float legendref(unsigned l, float x);
  long double legendrel(unsigned l, long double x);
 
  // Riemann zeta function
  /* floating-point-type */ riemann_zeta(/* floating-point-type */ x);
  float riemann_zetaf(float x);
  long double riemann_zetal(long double x);
 
  // spherical Bessel functions of the first kind
  /* floating-point-type */ sph_bessel(unsigned n, /* floating-point-type */ x);
  float sph_besself(unsigned n, float x);
  long double sph_bessell(unsigned n, long double x);
 
  // spherical associated Legendre functions
  /* floating-point-type */ sph_legendre(unsigned l, unsigned m,
                                         /* floating-point-type */ theta);
  float sph_legendref(unsigned l, unsigned m, float theta);
  long double  sph_legendrel(unsigned l, unsigned m, long double theta);
 
  // spherical Neumann functions;
  // spherical Bessel functions of the second kind
  /* floating-point-type */ sph_neumann(unsigned n, /* floating-point-type */ x);
  float sph_neumannf(unsigned n, float x);
  long double sph_neumannl(unsigned n, long double x);
}