Namespaces
Variants

Standard library header <cmath>

From cppreference.net
C++
Standard library headers

このヘッダーは元々C標準ライブラリに <math.h> として存在していました。

このヘッダは numeric ライブラリの一部です。

目次

型

float_t
(C++11)
floatと少なくとも同じ幅を持つ最も効率的な浮動小数点型 float
(typedef)
double_t
(C++11)
doubleと少なくとも同じ幅を持つ最も効率的な浮動小数点型 double
(typedef)

マクロ

(C++11) (C++11)
float 、 double および long double のオーバーフロー値をそれぞれ示す
(マクロ定数)
(C++11)
正の無限大または float のオーバーフローが保証される値に評価される
(マクロ定数)
(C++11)
float 型のquiet NaNに評価される
(マクロ定数)
(C++11) (C++11) (C++11)
共通の数学関数で使用されるエラー処理メカニズムを定義する
(マクロ定数)
分類
(C++11) (C++11) (C++11) (C++11) (C++11)
浮動小数点カテゴリを示す
(マクロ定数)

関数

基本操作
(C++11) (C++11)
浮動小数点値の絶対値 ( |x| )
(関数)
(C++11) (C++11)
浮動小数点除算の剰余
(関数)
(C++11) (C++11) (C++11)
除算演算の符号付き剰余
(関数)
(C++11) (C++11) (C++11)
除算操作の符号付き剰余および下位3ビット
(関数)
(C++11) (C++11) (C++11)
融合積和演算
(関数)
(C++11) (C++11) (C++11)
2つの浮動小数点値の大きい方
(関数)
(C++11) (C++11) (C++11)
2つの浮動小数点値の小さい方
(関数)
(C++11) (C++11) (C++11)
2つの浮動小数点値の正の差 ( max(0, x-y) )
(関数)
(C++11) (C++11) (C++11)
非数 (NaN)
(関数)
線形補間
(C++20)
線形補間関数
(関数)
指数関数
(C++11) (C++11)
指定された累乗に引き上げられた e を返す（ e x ）
(関数)
(C++11) (C++11) (C++11)
指定された値の 2 のべき乗を返す ( 2 x )
(関数)
(C++11) (C++11) (C++11)
指定された値の指数から 1 を引いた値を返す ( e x -1 )
(関数)
(C++11) (C++11)
自然対数（底 e ）を計算する（ ln(x) ）
(関数)
(C++11) (C++11)
常用（底 10 ）対数を計算する ( log 10 (x) )
(関数)
(C++11) (C++11) (C++11)
指定された数値の底 2 の対数 ( log 2 (x) )
(関数)
(C++11) (C++11) (C++11)
指定された数値に1を加えた値の自然対数（底 e ）、すなわち 1 プラス指定数値の自然対数（ ln(1+x) ）
(関数)
累乗関数
(C++11) (C++11)
数値を指定された累乗に引き上げる ( x y )
(関数)
(C++11) (C++11)
平方根を計算する ( √ x )
(関数)
(C++11) (C++11) (C++11)
立方根を計算する ( 3 √ x )
(関数)
(C++11) (C++11) (C++11)
斜辺を計算する √ x 2
+y 2
および √ x 2
+y 2
+z 2
(C++17以降)
(関数)
三角関数
(C++11) (C++11)
正弦を計算する ( sin(x) )
(関数)
(C++11) (C++11)
余弦を計算する ( cos(x) )
(関数)
(C++11) (C++11)
タンジェントを計算する ( tan(x) )
(関数)
(C++11) (C++11)
アークサインを計算する ( arcsin(x) )
(関数)
(C++11) (C++11)
アークコサインを計算する ( arccos(x) )
(関数)
(C++11) (C++11)
アークタンジェントを計算する ( arctan(x) )
(関数)
(C++11) (C++11)
符号を使用して象限を決定する逆正接
(関数)
双曲線関数
(C++11) (C++11)
双曲線正弦を計算する ( sinh(x) )
(関数)
(C++11) (C++11)
双曲線余弦を計算する ( cosh(x) )
(関数)
(C++11) (C++11)
双曲線正接を計算する ( tanh(x) )
(関数)
(C++11) (C++11) (C++11)
逆双曲線正弦を計算する ( arsinh(x) )
(関数)
(C++11) (C++11) (C++11)
逆双曲線余弦を計算する ( arcosh(x) )
(関数)
(C++11) (C++11) (C++11)
逆双曲線正接を計算する ( artanh(x) )
(関数)
誤差関数とガンマ関数
(C++11) (C++11) (C++11)
誤差関数
(関数)
(C++11) (C++11) (C++11)
相補誤差関数
(関数)
(C++11) (C++11) (C++11)
ガンマ関数
(関数)
(C++11) (C++11) (C++11)
ガンマ関数の自然対数
(関数)
最近接整数浮動小数点演算
(C++11) (C++11)
指定された値以上の最小の整数
(関数)
(C++11) (C++11)
指定された値以下の最大の整数
(関数)
(C++11) (C++11) (C++11)
指定された値の絶対値以下の最も近い整数
(関数)
(C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11)
最も近い整数へ丸める（中間値の場合にはゼロから遠ざかる方向に丸める）
(関数)
(C++11) (C++11) (C++11)
現在の丸めモードを使用して最も近い整数を返す
(関数)
(C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11)
現在の丸めモードを使用して最も近い整数へ丸め、
結果が異なる場合は例外を発生させる
(関数)
浮動小数点操作関数
(C++11) (C++11)
数値を仮数と基数 2 の指数に分解する
(関数)
(C++11) (C++11)
数値に2の整数乗を乗算する
(関数)
(C++11) (C++11)
数値を整数部と小数部に分解する
(関数)
(C++11) (C++11) (C++11) (C++11) (C++11) (C++11)
数値を FLT_RADIX の累乗で乗算する
(関数)
(C++11) (C++11) (C++11)
数値の指数部を抽出する
(関数)
(C++11) (C++11) (C++11)
数値の指数部を抽出する
(関数)
(C++11) (C++11) (C++11) (C++11) (C++11) (C++11)
指定された値に向かう次の表現可能な浮動小数点値
(関数)
(C++11) (C++11) (C++11)
浮動小数点値の符号をコピーする
(関数)
分類と比較
(C++11)
指定された浮動小数点値を分類する
(関数)
(C++11)
指定された数値が有限値を持つかどうかをチェックする
(関数)
(C++11)
指定された数値が無限大かどうかをチェックする
(関数)
(C++11)
指定された数値がNaNであるかどうかをチェックする
(関数)
(C++11)
指定された数値が正規であるかどうかをチェックする
(関数)
(C++11)
指定された数値が負であるかどうかをチェックする
(関数)
(C++11)
第1浮動小数点引数が第2引数より大きいかどうかをチェックする
(関数)
(C++11)
第1浮動小数点引数が第2引数以上かどうかをチェックする
(関数)
(C++11)
最初の浮動小数点引数が2番目より小さいかどうかをチェックする
(関数)
(C++11)
第1浮動小数点引数が第2引数以下かどうかをチェックする
(関数)
(C++11)
最初の浮動小数点引数が2番目の引数より小さいか大きいかをチェックする
(関数)
(C++11)
2つの浮動小数点値が非順序であるかどうかをチェックする
(関数)
数学的特殊関数
(C++17) (C++17) (C++17)
関連ラゲール多項式
(関数)
(C++17) (C++17) (C++17)
関連ルジャンドル多項式
(関数)
(C++17) (C++17) (C++17)
ベータ関数
(関数)
(C++17) (C++17) (C++17)
第1種完全楕円積分
(関数)
(C++17) (C++17) (C++17)
第二種完全楕円積分
(関数)
(C++17) (C++17) (C++17)
第3種完全楕円積分
(関数)
(C++17) (C++17) (C++17)
通常変形円筒ベッセル関数
(関数)
(C++17) (C++17) (C++17)
円筒ベッセル関数（第一種）
(関数)
(C++17) (C++17) (C++17)
不規則変形円筒ベッセル関数
(関数)
(C++17) (C++17) (C++17)
円柱ノイマン関数
(関数)
(C++17) (C++17) (C++17)
第一種不完全楕円積分
(関数)
(C++17) (C++17) (C++17)
第二種不完全楕円積分
(関数)
(C++17) (C++17) (C++17)
第三種不完全楕円積分
(関数)
(C++17) (C++17) (C++17)
指数積分
(関数)
(C++17) (C++17) (C++17)
エルミート多項式
(関数)
(C++17) (C++17) (C++17)
ルジャンドル多項式
(関数)
(C++17) (C++17) (C++17)
ラゲール多項式
(関数)
(C++17) (C++17) (C++17)
リーマンゼータ関数
(関数)
(C++17) (C++17) (C++17)
球ベッセル関数（第一種）
（関数）
(C++17) (C++17) (C++17)
球面陪ルジャンドル関数
(関数)
(C++17) (C++17) (C++17)
球面ノイマン関数
(関数)

概要

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

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

namespace std {
  using float_t = /* 説明を参照 */;
  using double_t = /* 説明を参照 */;
}
#define HUGE_VAL /* 説明を参照 */
#define HUGE_VALF /* 説明を参照 */
#define HUGE_VALL /* 説明を参照 */
#define INFINITY /* 説明を参照 */
#define NAN /* 説明を参照 */
#define FP_INFINITE /* 説明を参照 */
#define FP_NAN /* 説明を参照 */
#define FP_NORMAL /* 説明を参照 */
#define FP_SUBNORMAL /* 説明を参照 */
#define FP_ZERO /* 説明を参照 */
#define FP_FAST_FMA /* 説明を参照 */
#define FP_FAST_FMAF /* 説明を参照 */
#define FP_FAST_FMAL /* 説明を参照 */
#define FP_ILOGB0 /* 詳細は説明を参照 */
#define FP_ILOGBNAN /* 説明を参照 */
#define MATH_ERRNO /* 説明を参照 */
#define MATH_ERREXCEPT /* 説明を参照 */
#define math_errhandling /* 詳細は説明を参照 */
namespace std {
  /* 浮動小数点型 */ acos(/* 浮動小数点型 */ x);
  float acosf(float x);
  long double acosl(long double x);
  /* 浮動小数点型 */ asin(/* 浮動小数点型 */ x);
  float asinf(float x);
  long double asinl(long double x);
  /* 浮動小数点型 */ atan(/* 浮動小数点型 */ x);
  float atanf(float x);
  long double atanl(long double x);
  /* 浮動小数点型 */ atan2(/* 浮動小数点型 */ y,
                                  /* 浮動小数点型 */ x);
  float atan2f(float y, float x);
  long double atan2l(long double y, long double x);
  /* 浮動小数点型 */ cos(/* 浮動小数点型 */e x);
  float cosf(float x);
  long double cosl(long double x);
  /* 浮動小数点型 */ sin(/* 浮動小数点型 */ x);
  float sinf(float x);
  long double sinl(long double x);
  /* 浮動小数点型 */ tan(/* 浮動小数点型 */ x);
  float tanf(float x);
  long double tanl(long double x);
  /* 浮動小数点型 */ acosh(/* 浮動小数点型 */ x);
  float acoshf(float x);
  long double acoshl(long double x);
  /* 浮動小数点型 */ asinh(/* 浮動小数点型 */ x);
  float asinhf(float x);
  long double asinhl(long double x);
  /* 浮動小数点型 */ atanh(/* 浮動小数点型 */ x);
  float atanhf(float x);
  long double atanhl(long double x);
  /* 浮動小数点型 */ cosh(/* 浮動小数点型 */ x);
  float coshf(float x);
  long double coshl(long double x);
  /* 浮動小数点型 */ sinh(/* 浮動小数点型 */ x);
  float sinhf(float x);
  long double sinhl(long double x);
  /* 浮動小数点型 */ tanh(/* 浮動小数点型 */ x);
  float tanhf(float x);
  long double tanhl(long double x);
  /* 浮動小数点型 */ exp(/* 浮動小数点型 */ x);
  float expf(float x);
  long double expl(long double x);
  /* 浮動小数点型 */ exp2(/* 浮動小数点型 */ x);
  float exp2f(float x);
  long double exp2l(long double x);
  /* 浮動小数点型 */ expm1(/* 浮動小数点型 */ x);
  float expm1f(float x);
  long double expm1l(long double x);
  constexpr /* 浮動小数点型 */ frexp(/* 浮動小数点型 */ value, int* exp);
  constexpr float frexpf(float value, int* exp);
  constexpr long double frexpl(long double value, int* exp);
  constexpr int ilogb(/* 浮動小数点型 */ x);
  constexpr int ilogbf(float x);
  constexpr int ilogbl(long double x);
  constexpr /* 浮動小数点型 */ ldexp(/* 浮動小数点型 */ x, int exp);
  constexpr float ldexpf(float x, int exp);
  constexpr long double ldexpl(long double x, int exp);
  /* 浮動小数点型 */ log(/* 浮動小数点型 */ x);
  float logf(float x);
  long double logl(long double x);
  /* 浮動小数点型 */ log10(/* 浮動小数点型 */ x);
  float log10f(float x);
  long double log10l(long double x);
  /* 浮動小数点型 */ log1p(/* 浮動小数点型 */ x);
  float log1pf(float x);
  long double log1pl(long double x);
  /* 浮動小数点型 */ log2(/* 浮動小数点型 */ x);
  float log2f(float x);
  long double log2l(long double x);
  constexpr /* 浮動小数点型 */ logb(/* 浮動小数点型 */ x);
  constexpr float logbf(float x);
  constexpr long double logbl(long double x);
  constexpr /* 浮動小数点型 */ modf(/* 浮動小数点型 */ value,
                                           /* 浮動小数点型 */* iptr);
  constexpr float modff(float value, float* iptr);
  constexpr long double modfl(long double value, long double* iptr);
  constexpr /* 浮動小数点型 */ scalbn(/* 浮動小数点型 */ x, int n);
  constexpr float scalbnf(float x, int n);
  constexpr long double scalbnl(long double x, int n);
  constexpr /* 浮動小数点型 */ scalbln(/* 浮動小数点型 */ x, long int n);
  constexpr float scalblnf(float x, long int n);
  constexpr long double scalblnl(long double x, long int n);
  /* 浮動小数点型 */ cbrt(/* 浮動小数点型 */ x);
  float cbrtf(float x);
  long double cbrtl(long double x);
  // 絶対値
  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 /* 浮動小数点型 */
    abs(/* 浮動小数点型 */ j);           // freestanding-deleted
  constexpr /* 浮動小数点型 */ fabs(/* 浮動小数点型 */ x);
  constexpr float fabsf(float x);
  constexpr long double fabsl(long double x);
  /* 浮動小数点型 */ hypot(/* 浮動小数点型 */ x,
                                  /* 浮動小数点型 */ y);
  float hypotf(float x, float y);
  long double hypotl(long double x, long double y);
  // 三次元の斜辺
  float hypot(/* 浮動小数点型 */ x,
              /* 浮動小数点型 */ y,
              /* 浮動小数点型 */ z);
  /* 浮動小数点型 */ pow(/* 浮動小数点型 */ x,
                                /* 浮動小数点型 */ y);
  float powf(float x, float y);
  long double powl(long double x, long double y);
  /* 浮動小数点型 */ sqrt(/* 浮動小数点型 */ x);
  float sqrtf(float x);
  long double sqrtl(long double x);
  /* 浮動小数点型 */ erf(/* 浮動小数点型 */ x);
  float erff(float x);
  long double erfl(long double x);
  /* 浮動小数点型 */ erfc(/* 浮動小数点型 */ x);
  float erfcf(float x);
  long double erfcl(long double x);
  /* 浮動小数点型 */ lgamma(/* 浮動小数点型 */ x);
  float lgammaf(float x);
  long double lgammal(long double x);
  /* 浮動小数点型 */ tgamma(/* 浮動小数点型 */ x);
  float tgammaf(float x);
  long double tgammal(long double x);
  constexpr /* 浮動小数点型 */ ceil(/* 浮動小数点型 */ x);
  constexpr float ceilf(float x);
  constexpr long double ceill(long double x);
  constexpr /* 浮動小数点型 */ floor(/* 浮動小数点型 */ x);
  constexpr float floorf(float x);
  constexpr long double floorl(long double x);
  /* 浮動小数点型 */ nearbyint(/* 浮動小数点型 */ x);
  float nearbyintf(float x);
  long double nearbyintl(long double x);
  /* 浮動小数点型 */ rint(/* 浮動小数点型 */ x);
  float rintf(float x);
  long double rintl(long double x);
  long int lrint(/* 浮動小数点型 */ x);
  long int lrintf(float x);
  long int lrintl(long double x);
  long long int llrint(/* 浮動小数点型 */ x);
  long long int llrintf(float x);
  long long int llrintl(long double x);
  constexpr /* 浮動小数点型 */ round(/* 浮動小数点型 */ x);
  constexpr float roundf(float x);
  constexpr long double roundl(long double x);
  constexpr long int lround(/* 浮動小数点型 */ x);
  constexpr long int lroundf(float x);
  constexpr long int lroundl(long double x);
  constexpr long long int llround(/* 浮動小数点型 */ x);
  constexpr long long int llroundf(float x);
  constexpr long long int llroundl(long double x);
  constexpr /* 浮動小数点型 */ trunc(/* 浮動小数点型 */ x);
  constexpr float truncf(float x);
  constexpr long double truncl(long double x);
  constexpr /* 浮動小数点型 */ fmod(/* 浮動小数点型 */ x,
                                           /* 浮動小数点型 */ y);
  constexpr float fmodf(float x, float y);
  constexpr long double fmodl(long double x, long double y);
  constexpr /* 浮動小数点型 */ remainder(/* 浮動小数点型 */ x,
                                                /* 浮動小数点型 */ y);
  constexpr float remainderf(float x, float y);
  constexpr long double remainderl(long double x, long double y);
  constexpr /* 浮動小数点型 */ remquo(/* 浮動小数点型 */ x,
                                             /* 浮動小数点型 */ 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 /* 浮動小数点型 */ copysign(/* 浮動小数点型 */ x,
                                               /* 浮動小数点型 */ 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 /* 浮動小数点型 */ nextafter(/* 浮動小数点型 */ x,
                                                /* 浮動小数点型 */ y);
  constexpr float nextafterf(float x, float y);
  constexpr long double nextafterl(long double x, long double y);
  constexpr /* 浮動小数点型 */ nexttoward(/* 浮動小数点型 */ x,
                                                 long double y);
  constexpr float nexttowardf(float x, long double y);
  constexpr long double nexttowardl(long double x, long double y);
  constexpr /* 浮動小数点型 */ fdim(/* 浮動小数点型 */ x,
                                           /* 浮動小数点型 */ y);
  constexpr float fdimf(float x, float y);
  constexpr long double fdiml(long double x, long double y);
  constexpr /* 浮動小数点型 */ fmax(/* 浮動小数点型 */ x,
                                           /* 浮動小数点型 */ y);
  constexpr float fmaxf(float x, float y);
  constexpr long double fmaxl(long double x, long double y);
  constexpr /* 浮動小数点型 */ fmin(/* 浮動小数点型 */ x,
                                           /* 浮動小数点型 */ y);
  constexpr float fminf(float x, float y);
  constexpr long double fminl(long double x, long double y);
  constexpr /* 浮動小数点型 */ fma(/* 浮動小数点型 */ x,
                                          /* 浮動小数点型 */ y,
                                          /* 浮動小数点型 */ z);
  constexpr float fmaf(float x, float y, float z);
  constexpr long double fmal(long double x, long double y, long double z);
  // 線形補間
  constexpr /* 浮動小数点型 */ lerp(/* 浮動小数点型 */ a,
                                           /* 浮動小数点型 */ b,
                                           /* 浮動小数点型 */ t) noexcept;
  // 分類 / 比較関数
  constexpr int fpclassify(/* 浮動小数点型 */ x);
  constexpr bool isfinite(/* 浮動小数点型 */ x);
  constexpr bool isinf(/* 浮動小数点型 */ x);
  constexpr bool isnan(/* 浮動小数点型 */ x);
  constexpr bool isnormal(/* 浮動小数点型 */ x);
  constexpr bool signbit(/* 浮動小数点型 */ x);
  constexpr bool isgreater(/* 浮動小数点型 */ x,
                           /* 浮動小数点型 */ y);
  constexpr bool isgreaterequal(/* 浮動小数点型 */ x,
                                /* 浮動小数点型 */ y);
  constexpr bool isless(/* 浮動小数点型 */ x,
                        /* 浮動小数点型 */ y);
  constexpr bool islessequal(/* 浮動小数点型 */ x,
                             /* 浮動小数点型 */ y);
  constexpr bool islessgreater(/* 浮動小数点型 */ x,
                               /* 浮動小数点型 */ y);
  constexpr bool isunordered(/* 浮動小数点型 */ x,
                             /* 浮動小数点型 */ y);
  // 数学的特殊関数
  // 関連ラゲール多項式
  /* 浮動小数点型 */ assoc_laguerre(unsigned n, unsigned m,
                                           /* 浮動小数点型 */ x);
  float assoc_laguerref(unsigned n, unsigned m, float x);
  long double assoc_laguerrel(unsigned n, unsigned m, long double x);
  // 関連ルジャンドル関数
  /* 浮動小数点型 */ assoc_legendre(unsigned l, unsigned m,
                                           /* 浮動小数点型 */ x);
  float assoc_legendref(unsigned l, unsigned m, float x);
  long double assoc_legendrel(unsigned l, unsigned m, long double x);
  // ベータ関数
  /* 浮動小数点型 */ beta(/* 浮動小数点型 */ x,
                                 /* 浮動小数点型 */ y);
  float betaf(float x, float y);
  long double betal(long double x, long double y);
  // 第一種完全楕円積分
  /* 浮動小数点型 */ comp_ellint_1(/* 浮動小数点型 */ k);
  float comp_ellint_1f(float k);
  long double comp_ellint_1l(long double k);
  // 第二種完全楕円積分
  /* 浮動小数点型 */ comp_ellint_2(/* 浮動小数点型 */ k);
  float comp_ellint_2f(float k);
  long double comp_ellint_2l(long double k);
  // 第三種完全楕円積分
  /* 浮動小数点型 */ comp_ellint_3(/* 浮動小数点型 */ k,
                                          /* 浮動小数点型 */ nu);
  float comp_ellint_3f(float k, float nu);
  long double comp_ellint_3l(long double k, long double nu);
  // 修正円筒ベッセル関数（通常型）
  /* 浮動小数点型 */ cyl_bessel_i(/* 浮動小数点型 */ nu,
                                         /* 浮動小数点型 */ x);
  float cyl_bessel_if(float nu, float x);
  long double cyl_bessel_il(long double nu, long double x);
  // 第一種円柱ベッセル関数
  /* 浮動小数点型 */ cyl_bessel_j(/* 浮動小数点型 */ nu,
                                         /* 浮動小数点型 */ x);
  float cyl_bessel_jf(float nu, float x);
  long double cyl_bessel_jl(long double nu, long double x);
  // 不規則変形円筒ベッセル関数
  /* 浮動小数点型 */ cyl_bessel_k(/* 浮動小数点型 */ nu,
                                         /* 浮動小数点型 */ x);
  float cyl_bessel_kf(float nu, float x);
  long double cyl_bessel_kl(long double nu, long double x);
  // 円柱ノイマン関数;
  // 第二種円柱ベッセル関数
  /* 浮動小数点型 */ cyl_neumann(/* 浮動小数点型 */ nu,
                                        /* 浮動小数点型 */ x);
  float cyl_neumannf(float nu, float x);
  long double cyl_neumannl(long double nu, long double x);
  // 第一種不完全楕円積分
  /* 浮動小数点型 */ ellint_1(/* 浮動小数点型 */ k,
                                     /* 浮動小数点型 */ phi);
  float ellint_1f(float k, float phi);
  long double ellint_1l(long double k, long double phi);
  // 第二種不完全楕円積分
  /* 浮動小数点型 */ ellint_2(/* 浮動小数点型 */ k,
                                     /* 浮動小数点型 */ phi);
  float ellint_2f(float k, float phi);
  long double ellint_2l(long double k, long double phi);
  // 第三種不完全楕円積分
  /* 浮動小数点型 */ ellint_3(/* 浮動小数点型 */ k,
                                     /* 浮動小数点型 */ nu,
                                     /* 浮動小数点型 */ phi);
  float ellint_3f(float k, float nu, float phi);
  long double ellint_3l(long double k, long double nu, long double phi);
  // 指数積分
  /* 浮動小数点型 */ expint(/* 浮動小数点型 */ x);
  float expintf(float x);
  long double expintl(long double x);
  // エルミート多項式
  /* 浮動小数点型 */ hermite(unsigned n, /* 浮動小数点型 */ x);
  float hermitef(unsigned n, float x);
  long double hermitel(unsigned n, long double x);
  // ラゲール多項式
  /* 浮動小数点型 */ laguerre(unsigned n, /* 浮動小数点型 */ x);
  float laguerref(unsigned n, float x);
  long double laguerrel(unsigned n, long double x);
  // ルジャンドル多項式
  /* 浮動小数点型 */ legendre(unsigned l, /* 浮動小数点型 */ x);
  float legendref(unsigned l, float x);
  long double legendrel(unsigned l, long double x);
  // リーマンゼータ関数
  /* 浮動小数点型 */ riemann_zeta(/* 浮動小数点型 */ x);
  float riemann_zetaf(float x);
  long double riemann_zetal(long double x);
  // 第一種球ベッセル関数
  /* 浮動小数点型 */ sph_bessel(unsigned n, /* 浮動小数点型 */ x);
  float sph_besself(unsigned n, float x);
  long double sph_bessell(unsigned n, long double x);
  // 球面陪ルジャンドル関数
  /* 浮動小数点型 */ sph_legendre(unsigned l, unsigned m,
                                         /* 浮動小数点型 */ theta);
  float sph_legendref(unsigned l, unsigned m, float theta);
  long double  sph_legendrel(unsigned l, unsigned m, long double theta);
  // 球ノイマン関数;
  // 第二種球ベッセル関数
  /* 浮動小数点型 */ sph_neumann(unsigned n, /* 浮動小数点型 */ x);
  float sph_neumannf(unsigned n, float x);
  long double sph_neumannl(unsigned n, long double x);
}