28.7 Mathematical functions for floating-point types [c.math] C++N4910:2022 (670) p1339.cpp

# はじめに(Introduction)
N4910  Working Draft, Standard for Programming Language C++
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/n4910.pdf

n4910は、ISO/IEC JTC1 SC22 WG21の作業原案(Working Draft)です。
公式のISO/IEC 14882原本ではありません。
ISO/IEC JTC1 SC22 WG21では、可能な限り作業文書を公開し、幅広い意見を求めています。
一連の記事はコード断片をコンパイルできる形にする方法を検討してコンパイル、リンク、実行して、規格案の原文と処理系(g++, Clang++)との違いを確認し、技術内容を検討し、ISO/IEC JTC1 SC22 WG21にフィードバックするために用います。
また、CERT C++, MISRA C++等のコーディング標準のコード断片をコンパイルする際の参考にさせていただこうと考えています。CERT C++, MISRA C++が標準化の動きとの時間的なずれがあれば確認できれば幸いです。また、boostライブラリとの関連、Linux OS, TOPPERSカーネル、g++(GCC), clang++(LLVM）との関係も調査中です。
何か、抜け漏れ、耳より情報がありましたらおしらせくださると幸いです。

 <この項は書きかけです。順次追記します。>

## 背景(back ground)
C/C++でコンパイルエラーが出ると、途方にくれることがしばしばあります。
何回かに１回は、該当するエラーが検索できます。
ただ、条件が違っていて、そこでの修正方法では目的を達成しないこともしばしばです。いろいろな条件のコンパイルエラーとその対応方法について、広く記録することによって、いつか同じエラーに遭遇した時にやくに立つことを目指しています。

この半年の間で、三度、自分のネットでの記録に助けられたことがあります。
また過去に解決できなかった記録を１０種類以上、最近になって解決できたことがあります。それは、主に次の３つの情報に基づいています。

https://stackoverflow.com

http://ja.cppreference.com/

cpprefjp - C++日本語リファレンス

https://cpprefjp.github.io/

コンパイラの実装状況

https://cpprefjp.github.io/implementation-status.html

また
https://researchmap.jp/joub9b3my-1797580/#_1797580
に記載したサイトのお世話になっています。

## 作業方針(sequence)
Clang++では-std=c++03, C++2bの2種類
g++では-std=c++03, c++2bの２種類
でコンパイルし、

１）コンパイルエラーを収集する。
２）コンパイルエラーをなくす方法を検討する。
コンパイルエラーになる例を示すだけが目的のコードは、コンパイルエラーをなくすのではなく、コンパイルエラーの種類を収集するだけにする。
文法を示すのが目的のコード場合に、コンパイルエラーをなくすのに手間がかかる場合は、順次作業します。
３）リンクエラーをなくす方法を検討する。
文法を示すのが目的のコード場合に、リンクエラーをなくすのに手間がかかる場合は、順次作業します。
４）意味のある出力を作る。
コンパイル、リンクが通っても、意味のある出力を示そうとすると、コンパイル・リンクエラーが出て収拾できそうにない場合がある。順次作業します。

１）だけのものから４）まで進んだものと色々ある状態です。一歩でも前に進むご助言をお待ちしています。「検討事項」の欄に現状を記録するようにしています。

### C++N4910:2022 Standard Working Draft on ISO/IEC 14882(0) sample code compile list  

https://qiita.com/kaizen_nagoya/items/fc957ddddd402004bb91

### C++N4741, 2018 Standard Working Draft on ISO/IEC 14882 sample code compile list
https://qiita.com/kaizen_nagoya/items/3294c014044550896010

### C++N4606, 2016符号断片編纂一覧(example code compile list)
C++N4606, 2016 Working Draft 2016, ISO/IEC 14882, C++ standard(1) Example code compile list
https://qiita.com/kaizen_nagoya/items/df5d62c35bd6ed1c3d43/

### C++N3242, 2011 sample code compile list on clang++ and g++
https://qiita.com/kaizen_nagoya/items/685b5c1a2c17c1bf1318

## 編纂器(Compiler)
### clang++ --version
> Debian clang version 14.0.5-++20220610033153+c12386ae247c-1~exp1~20220610153237.151
Target: x86_64-pc-linux-gnu, Thread model: posix, InstalledDir: /usr/bin

### g++- --version
> g++ (GCC) 12.1.0  Copyright (C) 2022 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

# 28.7 Mathematical functions for floating-point types [c.math] C++N4910:2022 (670) p1339.cpp

## 算譜(source code)

```c++:p1339.cpp
// C++N4910 Committee Draft, Standard for Programming Language C++
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/n4910.pdf
const char * n4910 = "28.7 Mathematical functions for floating-point types [c.math] C++N4910:2022 (670) p1339.cpp";
// Debian clang version 14.0.5-++20220610033153+c12386ae247c-
// g++ (GCC) 12.1.0 Copyright (C) 2022 Free Software Foundation, Inc.
// Edited by Dr. OGAWA Kiyoshi. Compile procedure and results record.
// C++N4910:2022 Standard Working Draft on ISO/IEC 14882(0) sample code compile list
// https://qiita.com/kaizen_nagoya/items/fc957ddddd402004bb91

#include "N4910.h"

using namespace std;

// 28.7.1 Header <cmath> synopsis  [cmath.syn]
namespace std {
using float_t = see_below;
using double_t = see_below;
namespace std {
float acos(float x); // see 16.2
double acos(double x);
long double acos(long double x);
float acosf(float x);
long double acosl(long double x);
float asin(float x); // see 16.2
double asin(double x);
long double asin(long double x);
float asinf(float x);
long double asinl(long double x);
float atan(float x);
double atan(double x);
long double atan(long double x);
float atanf(float x);
long double atanl(long double x);
float atan2(float y, float x);
double atan2(double y, double x);
long double atan2(long double y, long double x); // see 16.2
float atan2f(float y, float x);
long double atan2l(long double y, long double x);
float cos(float x);
double cos(double x);
long double cos(long double x);
float cosf(float x);
long double cosl(long double x);
float sin(float x);
double sin(double x);
long double sin(long double x);
float sinf(float x);
long double sinl(long double x);
float tan(float x);
double tan(double x);
long double tan(long double x);
float tanf(float x);
long double tanl(long double x);
float acosh(float x);
double acosh(double x);
long double acosh(long double x);
float acoshf(float x);
long double acoshl(long double x);
float asinh(float x);
double asinh(double x);
long double asinh(long double x);
float asinhf(float x);
long double asinhl(long double x);
float atanh(float x);
double atanh(double x);
long double atanh(long double x);
float atanhf(float x);
long double atanhl(long double x);
float cosh(float x);
double cosh(double x);
long double cosh(long double x);
// see 16.2
// see 16.2
// see 16.2 // see 16.2
// see 16.2 // see 16.2
// see 16.2 // see 16.2
// see 16.2 // see 16.2
// see 16.2 // see 16.2
// see 16.2 // see 16.2
// see 16.2 // see 16.2
// see 16.2 // see 16.2
// see 16.2
float coshf(float x);
long double coshl(long double x);
float sinh(float x);
double sinh(double x);
long double sinh(long double x);
float sinhf(float x);
long double sinhl(long double x);
float tanh(float x);
double tanh(double x);
long double tanh(long double x);
float tanhf(float x);
long double tanhl(long double x);
float exp(float x);
double exp(double x);
long double exp(long double x);
float expf(float x);
long double expl(long double x);
float exp2(float x);
double exp2(double x);
long double exp2(long double x);
float exp2f(float x);
long double exp2l(long double x);
float expm1(float x);
double expm1(double x);
long double expm1(long double x);
float expm1f(float x);
long double expm1l(long double x);
// see 16.2 // see 16.2
// see 16.2 // see 16.2
// see 16.2 // see 16.2
// see 16.2 // see 16.2
// see 16.2 // see 16.2
constexpr float frexp(float value, int* exp);
constexpr double frexp(double value, int* exp);
constexpr long double frexp(long double value, int* exp); // see 16.2
constexpr float frexpf(float value, int* exp);
constexpr long double frexpl(long double value, int* exp);
constexpr int ilogb(float x);
constexpr int ilogb(double x);
constexpr int ilogb(long double x);
constexpr int ilogbf(float x);
constexpr int ilogbl(long double x);
constexpr float ldexp(float x, int exp);
constexpr double ldexp(double x, int exp);
constexpr long double ldexp(long double x, int exp); // see 16.2
constexpr float ldexpf(float x, int exp);
constexpr long double ldexpl(long double x, int exp);
float log(float x);
double log(double x);
long double log(long double x);
float logf(float x);
long double logl(long double x);
float log10(float x);
double log10(double x);
long double log10(long double x);
float log10f(float x);
long double log10l(long double x);
// see 16.2 // see 16.2
// see 16.2 // see 16.2
// see 16.2
// see 16.2 // see 16.2
// see 16.2
float log1p(float x);
double log1p(double x);
long double log1p(long double x);
float log1pf(float x);
long double log1pl(long double x);
float log2(float x);
double log2(double x);
long double log2(long double x);
float log2f(float x);
long double log2l(long double x);
// see 16.2 // see 16.2
// see 16.2 // see 16.2
constexpr float logb(float x);
constexpr double logb(double x);
constexpr long double logb(long double x);
constexpr float logbf(float x);
constexpr long double logbl(long double x);
// see 16.2 // see 16.2
constexpr float modf(float value, float* iptr); // see 16.2
constexpr double modf(double value, double* iptr);
constexpr long double modf(long double value, long double* iptr); // see 16.2
constexpr float modff(float value, float* iptr);
constexpr long double modfl(long double value, long double* iptr);
constexpr float scalbn(float x, int n); // see 16.2
constexpr double scalbn(double x, int n);
constexpr long double scalbn(long double x, int n); // see 16.2
constexpr float scalbnf(float x, int n);
constexpr long double scalbnl(long double x, int n);
constexpr float scalbln(float x, long int n); // see 16.2
constexpr double scalbln(double x, long int n);
constexpr long double scalbln(long double x, long int n); // see 16.2
constexpr float scalblnf(float x, long int n);
constexpr long double scalblnl(long double x, long int n);
float cbrt(float x);
double cbrt(double x);
long double cbrt(long double x);
float cbrtf(float x);
long double cbrtl(long double x);
// see 16.2 // see 16.2
// 28.7.2, absolute values
constexpr int abs(int j);
constexpr long int abs(long int j);
constexpr long long int abs(long long int j);
constexpr float abs(float j);
constexpr double abs(double j);
constexpr long double abs(long double j);
constexpr float fabs(float x);
constexpr double fabs(double x);
constexpr long double fabs(long double x);
constexpr float fabsf(float x);
constexpr long double fabsl(long double x);
// see 16.2 // see 16.2
float hypot(float x, float y); // see 16.2
double hypot(double x, double y);
long double hypot(long double x, long double y); // see 16.2
float hypotf(float x, float y);
long double hypotl(long double x, long double y);
// 28.7.3, three-dimensional hypotenuse
float hypot(float x, float y, float z);
double hypot(double x, double y, double z);
long double hypot(long double x, long double y, long double z);
float pow(float x, float y); // see 16.2
double pow(double x, double y);
long double pow(long double x, long double y);
float powf(float x, float y);
long double powl(long double x, long double y);
// see 16.2
float sqrt(float x);
double sqrt(double x);
long double sqrt(long double x);
float sqrtf(float x);
long double sqrtl(long double x);
float erf(float x);
double erf(double x);
long double erf(long double x);
float erff(float x);
long double erfl(long double x);
float erfc(float x);
double erfc(double x);
long double erfc(long double x);
float erfcf(float x);
long double erfcl(long double x);
float lgamma(float x);
double lgamma(double x);
long double lgamma(long double x);
float lgammaf(float x);
long double lgammal(long double x);
float tgamma(float x);
double tgamma(double x);
long double tgamma(long double x);
float tgammaf(float x);
long double tgammal(long double x);
// see 16.2 // see 16.2
// see 16.2 // see 16.2
// see 16.2 // see 16.2
// see 16.2 // see 16.2
// see 16.2 // see 16.2
constexpr float ceil(float x);
constexpr double ceil(double x);
constexpr long double ceil(long double x);
constexpr float ceilf(float x);
constexpr long double ceill(long double x);
constexpr float floor(float x);
constexpr double floor(double x);
constexpr long double floor(long double x);
constexpr float floorf(float x);
constexpr long double floorl(long double x);
// see 16.2 // see 16.2
// see 16.2 // see 16.2
float nearbyint(float x); // see 16.2
double nearbyint(double x);
long double nearbyint(long double x); // see 16.2
float nearbyintf(float x);
long double nearbyintl(long double x);
float rint(float x);
double rint(double x);
long double rint(long double x);
float rintf(float x);
long double rintl(long double x);
// see 16.2 // see 16.2
long int lrint(float x);
long int lrint(double x);
long int lrint(long double x);
long int lrintf(float x);
long int lrintl(long double x);
long long int llrint(float x);
long long int llrint(double x);
long long int llrint(long double x);
long long int llrintf(float x);
long long int llrintl(long double x);
// see 16.2 // see 16.2
// see 16.2 // see 16.2
constexpr float round(float x);
constexpr double round(double x);
constexpr long double round(long double x);
constexpr float roundf(float x);
constexpr long double roundl(long double x);
constexpr long int lround(float x);
constexpr long int lround(double x);
constexpr long int lround(long double x);
constexpr long int lroundf(float x);
constexpr long int lroundl(long double x);
// see 16.2 // see 16.2
// see 16.2 // see 16.2
// see 16.2 // see 16.2
// see 16.2 see 16.2
constexpr float fmod(float x, float y); //
constexpr double fmod(double x, double y);
constexpr long double fmod(long double x, long double y);
constexpr float fmodf(float x, float y);
constexpr long double fmodl(long double x, long double y);
constexpr float remainder(float x, float y); // see 16.2
constexpr double remainder(double x, double y);
constexpr long double remainder(long double x, long double y);
constexpr float remainderf(float x, float y);
constexpr long double remainderl(long double x, long double y);
constexpr float remquo(float x, float y, int* quo); // see 16.2
constexpr double remquo(double x, double y, int* quo);
constexpr long double remquo(long double x, long double 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 long long int llround(float x);
constexpr long long int llround(double x);
constexpr long long int llround(long double x);
constexpr long long int llroundf(float x);
constexpr long long int llroundl(long double x);
constexpr float trunc(float x); //
constexpr double trunc(double x);
constexpr long double trunc(long double x); //
constexpr float truncf(float x);
constexpr long double truncl(long double x);
constexpr float copysign(float x, float y); // see 16.2
constexpr double copysign(double x, double y);
constexpr long double copysign(long double x, long double 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);
// see 16.2
// see 16.2
// see 16.2
// see 16.2
// see 16.2
constexpr float nextafter(float x, float y); // see 16.2
constexpr double nextafter(double x, double y);
constexpr long double nextafter(long double x, long double y);
constexpr float nextafterf(float x, float y);
constexpr long double nextafterl(long double x, long double y);
// see 16.2
constexpr float nexttoward(float x, long double y); // see 16.2
constexpr double nexttoward(double x, long double y);
constexpr long double nexttoward(long double x, long double y);
constexpr float nexttowardf(float x, long double y);
constexpr long double nexttowardl(long double x, long double y);
// see 16.2
constexpr float fdim(float x, float y); // see 16.2
constexpr double fdim(double x, double y);
constexpr long double fdim(long double x, long double y);
constexpr float fdimf(float x, float y);
constexpr long double fdiml(long double x, long double y);
constexpr float fmax(float x, float y); // see 16.2
constexpr double fmax(double x, double y);
constexpr long double fmax(long double x, long double y);
constexpr float fmaxf(float x, float y);
constexpr long double fmaxl(long double x, long double y);
constexpr float fmin(float x, float y); // see 16.2
constexpr double fmin(double x, double y);
constexpr long double fmin(long double x, long double y);
constexpr float fminf(float x, float y);
constexpr long double fminl(long double x, long double y);
// see 16.2
// see 16.2
// see 16.2
constexpr float fma(float x, float y, float z); // see 16.2
constexpr double fma(double x, double y, double z);
constexpr long double fma(long double x, long double y, long double z);
constexpr float fmaf(float x, float y, float z);
constexpr long double fmal(long double x, long double y, long double z);
// see 16.2
// 28.7.4, linear interpolation
constexpr float lerp(float a, float b, float t) noexcept;
constexpr double lerp(double a, double b, double t) noexcept;
constexpr long double lerp(long double a, long double b, long double t) noexcept;
// 28.7.5, classification / comparison functions
constexpr int fpclassify(float x);
constexpr int fpclassify(double x);
constexpr int fpclassify(long double x);
constexpr bool isfinite(float x);
constexpr bool isfinite(double x);
constexpr bool isfinite(long double x);
constexpr bool isinf(float x);
constexpr bool isinf(double x);
constexpr bool isinf(long double x);
constexpr bool isnan(float x);
constexpr bool isnan(double x);
constexpr bool isnan(long double x);
constexpr bool isnormal(float x);
constexpr bool isnormal(double x);
constexpr bool isnormal(long double x);
constexpr bool signbit(float x);
constexpr bool signbit(double x);
constexpr bool signbit(long double x);
constexpr bool isgreater(float x, float y);
constexpr bool isgreater(double x, double y);
constexpr bool isgreater(long double x, long double y);
constexpr bool isgreaterequal(float x, float y);
constexpr bool isgreaterequal(double x, double y);
constexpr bool isgreaterequal(long double x, long double y);
constexpr bool isless(float x, float y);
constexpr bool isless(double x, double y);
constexpr bool isless(long double x, long double y);
constexpr bool islessequal(float x, float y);
constexpr bool islessequal(double x, double y);
constexpr bool islessequal(long double x, long double y);
constexpr bool islessgreater(float x, float y);
constexpr bool islessgreater(double x, double y);
constexpr bool islessgreater(long double x, long double y);
constexpr bool isunordered(float x, float y);
constexpr bool isunordered(double x, double y);
constexpr bool isunordered(long double x, long double y);
// 28.7.6, mathematical special functions
// 28.7.6.2, associated Laguerre polynomials
double assoc_laguerre(unsigned n, unsigned m, double x);
float assoc_laguerref(unsigned n, unsigned m, float x);
long double assoc_laguerrel(unsigned n, unsigned m, long double x);
// 28.7.6.3, associated Legendre functions
double assoc_legendre(unsigned l, unsigned m, double x);
float assoc_legendref(unsigned l, unsigned m, float x);
long double assoc_legendrel(unsigned l, unsigned m, long double x);
// 28.7.6.4, beta function
double beta(double x, double y);
float betaf(float x, float y);
long double betal(long double x, long double y);
// 28.7.6.5, complete elliptic integral of the first kind
double comp_ellint_1(double k);
float comp_ellint_1f(float k);
long double comp_ellint_1l(long double k);
// 28.7.6.6, complete elliptic integral of the second kind
double comp_ellint_2(double k);
float comp_ellint_2f(float k);
long double comp_ellint_2l(long double k);
// 28.7.6.7, complete elliptic integral of the third kind
double comp_ellint_3(double k, double nu);
float comp_ellint_3f(float k, float nu);
long double comp_ellint_3l(long double k, long double nu);
// 28.7.6.8, regular modified cylindrical Bessel functions
double cyl_bessel_i(double nu, double x);
float cyl_bessel_if(float nu, float x);
long double cyl_bessel_il(long double nu, long double x);
// 28.7.6.9, cylindrical Bessel functions of the first kind
double cyl_bessel_j(double nu, double x);
float cyl_bessel_jf(float nu, float x);
long double cyl_bessel_jl(long double nu, long double x);
// 28.7.6.10, irregular modified cylindrical Bessel functions
double cyl_bessel_k(double nu, double x);
float cyl_bessel_kf(float nu, float x);
long double cyl_bessel_kl(long double nu, long double x);
// 28.7.6.11, cylindrical Neumann functions;
// cylindrical Bessel functions of the second kind
double cyl_neumann(double nu, double x);
float cyl_neumannf(float nu, float x);
long double cyl_neumannl(long double nu, long double x);
// 28.7.6.12, incomplete elliptic integral of the first kind
double ellint_1(double k, double phi);
float ellint_1f(float k, float phi);
long double ellint_1l(long double k, long double phi);
// 28.7.6.13, incomplete elliptic integral of the second kind
double ellint_2(double k, double phi);
float ellint_2f(float k, float phi);
long double ellint_2l(long double k, long double phi);
// 28.7.6.14, incomplete elliptic integral of the third kind
double ellint_3(double k, double nu, double phi);
float ellint_3f(float k, float nu, float phi);
long double ellint_3l(long double k, long double nu, long double phi);
// 28.7.6.15, exponential integral
double expint(double x);
float expintf(float x);
long double expintl(long double x);
// 28.7.6.16, Hermite polynomials
double hermite(unsigned n, double x);
float hermitef(unsigned n, float x);
long double hermitel(unsigned n, long double x);
// 28.7.6.17, Laguerre polynomials
double laguerre(unsigned n, double x);
float laguerref(unsigned n, float x);
long double laguerrel(unsigned n, long double x);
// 28.7.6.18, Legendre polynomials
double legendre(unsigned l, double x);
float legendref(unsigned l, float x);
long double legendrel(unsigned l, long double x);
// 28.7.6.19, Riemann zeta function
double riemann_zeta(double x);
float riemann_zetaf(float x);
long double riemann_zetal(long double x);
// 28.7.6.20, spherical Bessel functions of the first kind double sph_bessel(unsigned n, double x);
float sph_besself(unsigned n, float x);
long double sph_bessell(unsigned n, long double x);
// 28.7.6.21, spherical associated Legendre functions
double sph_legendre(unsigned l, unsigned m, double theta);
float sph_legendref(unsigned l, unsigned m, float theta);
long double  sph_legendrel(unsigned l, unsigned m, long double theta);
// 28.7.6.22, spherical Neumann functions;
// spherical Bessel functions of the second kind
double sph_neumann(unsigned n, double x);
float sph_neumannf(unsigned n, float x);
long double sph_neumannl(unsigned n, long double x);
}
//  The contents and meaning of the header <cmath> are the same as the C standard library header <math.h>, with the addition of a three-dimensional hypotenuse function (28.7.3), a linear interpolation function (28.7.4), and the mathematical special functions described in 28.7.6.
// [Note 1: Several functions have additional overloads in this document, but they have the same behavior as in the C standard library (16.2).
//  For each set of overloaded functions within <cmath>, with the exception of abs, there shall be additional overloads sufficient to ensure:
// — If any argument of arithmetic type corresponding to a double parameter has type long double, then all arguments of arithmetic type (6.8.2) corresponding to double parameters are effectively cast to long double.
// — Otherwise, if any argument of arithmetic type corresponding to a double parameter has type double or an integer type, then all arguments of arithmetic type corresponding to double parameters are effectively cast to double.
// — [Note 2: Otherwise, all arguments of arithmetic type corresponding to double parameters have type float.
//  [Note 1: The headers <cstdlib> (17.2.2) and <cmath> (28.7.1) declare the functions described in this subclause.
constexpr int abs(int j);
constexpr long int abs(long int j);
constexpr long long int abs(long long int j);
constexpr float abs(float j);
constexpr double abs(double j);
constexpr long double abs(long double j);
// [Note 3: abs is exempted from these rules in order to stay compatible with C.
//  See also: ISO C 7.12
// 28.7.2 Absolute values [c.math.abs]
// Effects: The abs functions have the semantics specified in the C standard library for the functions abs, labs, llabs, fabsf, fabs, and fabsl.
// Remarks: If abs() is called with an argument of type X for which is_unsigned_v<X> is true and if X cannot be converted to int by integral promotion (7.3.7), the program is ill-formed.
//  Returns: 􏰙x2 + y2 + z2.
// 28.7.4 Linear interpolation [c.math.lerp]
// [Note 2: Arguments that can be promoted to int are permitted for compatibility with C.
//  See also: ISO C 7.12.7.2, 7.22.6.1
// 28.7.3 Three-dimensional hypotenuse [c.math.hypot3]
float hypot(float x, float y, float z);
double hypot(double x, double y, double z);
long double hypot(long double x, long double y, long double z);
// Returns: a + t(b − a).
constexpr float lerp(float a, float b, float t) noexcept;
constexpr double lerp(double a, double b, double t) noexcept;
constexpr long double lerp(long double a, long double b, long double t) noexcept;
// Remarks: Let r be the value returned. If isfinite(a) && isfinite(b), then: // — If t == 0, then r == a.
// — If t == 1, then r == b.
// — If t >= 0 && t <= 1, then isfinite(r).
// — If isfinite(t) && a == b, then r == a.
// — If isfinite(t) || !isnan(t) && b-a != 0, then !isnan(r). LetCMP(x,y)be1ifx>y,-1ifx<y,and0otherwise. Foranyt1andt2,theproductof
//  The classification / comparison functions behave the same as the C macros with the corresponding names defined in the C standard library. Each function is overloaded for the three floating-point types.
// See also: ISO C 7.12.3, 7.12.4
// 28.7.6 Mathematical special functions [sf.cmath]
// 28.7.6.1 General [sf.cmath.general]
//  If any argument value to any of the functions specified in 28.7.6 is a NaN (Not a Number), the function shall return a NaN but it shall not report a domain error. Otherwise, the function shall report a domain error for just those argument values for which: CMP (lerp(a, b, t2), lerp(a, b, t1)), CMP (t2, t1), and CMP (b, a) is non-negative.
// 28.7.5 Classification / comparison functions [c.math.fpclass]
// infinity.
// — the function description’s Returns: element explicitly specifies a domain and those argument values fall outside the specified domain, or
// — the corresponding mathematical function value has a nonzero imaginary component, or
// — the corresponding mathematical function is not mathematically defined.244
//  Unless otherwise specified, each function is defined for all finite values, for negative infinity, and for positive
// Returns: where n is n, m is m, and x is x.
// 28.7.6.2Associated Laguerre polynomials [sf.cmath.assoc.laguerre]
// Effects: These functions compute the associated Laguerre polynomials of their respective arguments n, m, and x.
double assoc_laguerre(unsigned n, unsigned m, double x);
float assoc_laguerref(unsigned n, unsigned m, float x);
t
long double  assoc_laguerrel(unsigned n, unsigned m, long double x);
// m m dm
// Ln(x)=(−1) dxm Ln+m(x), forx≥0,
//  28.7.6.3 Associated Legendre functions [sf.cmath.assoc.legendre]
// Remarks: The effect of calling each of these functions is implementation-defined if n >= 128 or if m >= 128.
// Effects: These functions compute the associated Legendre functions of their respective arguments l, m, and x.
// Returns: m 2 m/2 dm Pl (x)=(1−x ) dxm Pl(x), for|x|≤1,
double assoc_legendre(unsigned l, unsigned m, double x);
float assoc_legendref(unsigned l, unsigned m, float x);
long double  assoc_legendrel(unsigned l, unsigned m, long double x);
//  where l is l, m is m, and x is x.
// Remarks: The effect of calling each of these functions is implementation-defined if l >= 128.
// 244) A mathematical function is mathematically defined for a given set of argument values (a) if it is explicitly defined for that  set of argument values, or (b) if its limiting value exists and does not depend on the direction of approach.
// Returns: where x is x and y is y. B(x,y)=Γ(x)Γ(y), forx>0,y>0, Γ(x+y)
// 28.7.6.4 Beta function [sf.cmath.beta]
// Effects: These functions compute the beta function of their respective arguments x and y.
double beta(double x, double y);
float betaf(float x, float y);
long double  betal(long double x, long double y);
// Effects: These functions compute the complete elliptic integral of the first kind of their respective arguments k.
// 28.7.6.5 Complete elliptic integral of the first kind  [sf.cmath.comp.ellint.1]
double comp_ellint_1(double k);
float comp_ellint_1f(float k);
long double  comp_ellint_1l(long double k);
// Returns: where k is k. See also 28.7.6.12. K(k) = F(k,π/2) , for |k| ≤ 1,
// Effects: These functions compute the complete elliptic integral of the second kind of their respective arguments k.
// 28.7.6.6 Complete elliptic integral of the second kind [sf.cmath.comp.ellint.2]
double comp_ellint_2(double k);
float comp_ellint_2f(float k);
long double  comp_ellint_2l(long double k);
// 28.7.6.7 Complete elliptic integral of the third kind [sf.cmath.comp.ellint.3]
// Returns: where k is k. See also 28.7.6.13. E(k) = E(k,π/2) , for |k| ≤ 1,
// Effects: These functions compute the complete elliptic integral of the third kind of their respective arguments k and nu.
// Returns:−ν 􏰓∞ Iν(x)=i Jν(ix)= k=0
double comp_ellint_3(double k, double nu);
float comp_ellint_3f(float k, float nu);
long double  comp_ellint_3l(long double k, long double nu);
// Returns:where k is k and ν is nu. See also 28.7.6.14.Π(ν,k) = Π(ν,k,π/2) , for |k| ≤ 1,
// 28.7.6.8 Regular modified cylindrical Bessel functions [sf.cmath.cyl.bessel.i]
double cyl_bessel_i(double nu, double x);
float cyl_bessel_if(float nu, float x);
long double  cyl_bessel_il(long double nu, long double x);
// Effects: These functions compute the regular modified cylindrical Bessel functions of their respective arguments nu and x.(x/2)ν +2k k!Γ(ν+k+1) ,forx≥0,where ν is nu and x is x.
// Remarks: The effect of calling each of these functions is implementation-defined if nu >= 128. See also 28.7.6.9.
// 28.7.6.9 Cylindrical Bessel functions of the first kind [sf.cmath.cyl.bessel.j]
// Effects: These functions compute the cylindrical Bessel functions of the first kind of their respective arguments nu and x.
// Returns:∞ (−1)k (x/2)ν +2k
double cyl_bessel_j(double nu, double x);
float cyl_bessel_jf(float nu, float x);
long double  cyl_bessel_jl(long double nu, long double x);
// k!Γ(ν+k+1) , forx≥0,
// Remarks: The effect of calling each of these functions is implementation-defined if nu >= 128. Jν(x)=
// 28.7.6.10 Irregular modified cylindrical Bessel functions [sf.cmath.cyl.bessel.k]
// where ν is nu and x is x.
double cyl_bessel_k(double nu, double x);
float cyl_bessel_kf(float nu, float x);
long double  cyl_bessel_kl(long double nu, long double x);
// k=0
// Effects: These functions compute the irregular modified cylindrical Bessel functions of their respective arguments nu and x.
// Returns: Kν (x) = (π/2)iν+1(Jν (ix) + iNν (ix)) = πI (x)−I(x)  −ν ν for x ≥ 0 and non-integral ν for x ≥ 0 and integral ν
//  28.7.6.11 Cylindrical Neumann functions [sf.cmath.cyl.neumann]
// where ν is nu and x is x.
// Remarks: The effect of calling each of these functions is implementation-defined if nu >= 128. See also 28.7.6.8, 28.7.6.9, 28.7.6.11.
// Effects: These functions compute the cylindrical Neumann functions, also known as the cylindrical Bessel functions of the second kind, of their respective arguments nu and x.
double cyl_neumann(double nu, double x);
float cyl_neumannf(float nu, float x);
long double  cyl_neumannl(long double nu, long double x);
// Returns:
// Remarks: The effect of calling each of these functions is implementation-defined if nu >= 128. where ν is nu and x is x. See also 28.7.6.9.
// Returns: 􏰔φ 0
// 28.7.6.12 Incomplete elliptic integral of the first kind [sf.cmath.ellint.1]
// Effects: These functions compute the incomplete elliptic integral of the first kind of their respective arguments k and phi (phi measured in radians).
double ellint_1(double k, double phi);
float ellint_1f(float k, float phi);
long double  ellint_1l(long double k, long double phi);
// F(k, φ) = dθ 􏰙 2 2 , for |k| ≤ 1,   1−k sin θ Incomplete elliptic integral of the second kind where k is k and φ is phi.
// 28.7.6.13 incomplete elliptic integral of the second kind [sf.cmath.ellint.2]
double ellint_2(double k, double phi);
float ellint_2f(float k, float phi);
long double  ellint_2l(long double k, long double phi);
// Effects: These functions compute the incomplete elliptic integral of the second kind of their respective arguments k and phi (phi measured in radians).
// Returns: where k is k and φ is phi. E(k,φ)= 􏰔φ􏰙 2 2 1−k sin θdθ, for|k|≤1, 0
//  28.7.6.14 Incomplete elliptic integral of the third kind [sf.cmath.ellint.3]
// Effects: These functions compute the incomplete elliptic integral of the third kind of their respective arguments k, nu, and phi (phi measured in radians).
// Returns: 􏰔φ 0 (1−νsinθ) 1−ksinθ
double ellint_3(double k, double nu, double phi);
float ellint_3f(float k, float nu, float phi);
long double  ellint_3l(long double k, long double nu, long double phi);
// Π(ν, k, φ) = where ν is nu, k is k, and φ is phi. dθ 2 􏰙 2 2 , for |k| ≤ 1,
//  28.7.6.15 Exponential integral [sf.cmath.expint]
double  expint(double x);
float expintf(float x);
long double  expintl(long double x);
// Effects: These functions compute the exponential integral of their respective arguments x.
// Returns: where x is x. 􏰔 ∞ e−t t dt Ei(x)=−
//  28.7.6.16 Hermite polynomials [sf.cmath.hermite]
double hermite(unsigned n, double x);
float hermitef(unsigned n, float x);
long double  hermitel(unsigned n, long double x);
// Effects: These functions compute the Hermite polynomials of their respective arguments n and x.
// Returns: where n is n and x is x.n x2 dn −x2 Hn(x) = (−1) e dxn e
//  Remarks: The effect of calling each of these functions is implementation-defined if n >= 128.
// Returns: ex dn Ln(x)= n!dxn (xne−x), forx≥0,
// 28.7.6.17 Laguerre polynomials [sf.cmath.laguerre]
// Effects: These functions compute the Laguerre polynomials of their respective arguments n and x.
// Returns: where x is x.􏰓 −x
double laguerre(unsigned n, double x);
float laguerref(unsigned n, float x);
long double  laguerrel(unsigned n, long double x);
//   28.7.6.18 Legendre polynomials [sf.cmath.legendre]
// where n is n and x is x.
// Remarks: The effect of calling each of these functions is implementation-defined if n >= 128.
double legendre(unsigned l, double x);
float legendref(unsigned l, float x);
long double  legendrel(unsigned l, long double x);
// Effects: These functions compute the Legendre polynomials of their respective arguments l and x.
// Returns: 1 dl Pl(x)=2ll!dxl (x2−1)l , for|x|≤1,  where l is l and x is x.
// Remarks: The effect of calling each of these functions is implementation-defined if l >= 128.
// 28.7.6.19 Riemann zeta function [sf.cmath.riemann.zeta]
double riemann_zeta(double x);
float riemann_zetaf(float x);
long double  riemann_zetal(long double x);
// Effects: These functions compute the Riemann zeta function of their respective arguments x. ζ(x) = 1 ∞ 􏰓(−1)k−1k−x, k, forx>1 k=1
//for 0 ≤ x ≤ 1 2xπx−1sin( 2 )Γ(1−x)ζ(1−x), forx<0
// where n is n and x is x. See also 28.7.6.9. 1−21−x πx k=1
// 28.7.6.20 Spherical Bessel functions of the first kind [sf.cmath.sph.bessel]
// Effects: These functions compute the spherical Bessel functions of the first kind of their respective arguments n and x.
// Returns: jn(x)=(π/2x)1/2Jn+1/2(x), forx≥0,
// Remarks: The effect of calling each of these functions is implementation-defined if n >= 128.
double sph_bessel(unsigned n, double x);
float sph_besself(unsigned n, float x);
long double  sph_bessell(unsigned n, long double x);
// Returns: where Ylm(θ, 0) (2l + 1) (l − m)!􏰎1/2 Ylm(θ, φ) = (−1)m Pml (cos θ)eimφ ,
// Effects: These functions compute the spherical associated Legendre functions of their respective arguments l, m, and theta (theta measured in radians).
// 28.7.6.21 Spherical associated Legendre functions [sf.cmath.sph.legendre]
double sph_legendre(unsigned l, unsigned m, double theta);
float sph_legendref(unsigned l, unsigned m, float theta);
long double  sph_legendrel(unsigned l, unsigned m, long double theta);
//  4π (l + m)! for |m| ≤ l, and l is l, m is m, and θ is theta.
// Remarks: The effect of calling each of these functions is implementation-defined if l >= 128. See also 28.7.6.3.
// 28.7.6.22 Spherical Neumann functions [sf.cmath.sph.neumann]
double sph_neumann(unsigned n, double x);
float sph_neumannf(unsigned n, float x);
long double  sph_neumannl(unsigned n, long double x);
// Effects: These functions compute the spherical Neumann functions, also known as the spherical Bessel functions of the second kind, of their respective arguments n and x.
// Returns: nn(x)=(π/2x)1/2Nn+1/2(x), forx≥0,
// Remarks: The effect of calling each of these functions is implementation-defined if n >= 128.
// where n is n and x is x. See also 28.7.6.11.
int main() {
    cout  <<  n4910 << endl;
    return EXIT_SUCCESS;
}
root@8d37178807ec:/home/n4910# vi p1339.cpp
root@8d37178807ec:/home/n4910# astyle <  p1339.cpp
// C++N4910 Committee Draft, Standard for Programming Language C++
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/n4910.pdf
const char * n4910 = "28.7 Mathematical functions for floating-point types [c.math] C++N4910:2022 (670) p1339.cpp";
// Debian clang version 14.0.5-++20220610033153+c12386ae247c-
// g++ (GCC) 12.1.0 Copyright (C) 2022 Free Software Foundation, Inc.
// Edited by Dr. OGAWA Kiyoshi. Compile procedure and results record.
// C++N4910:2022 Standard Working Draft on ISO/IEC 14882(0) sample code compile list
// https://qiita.com/kaizen_nagoya/items/fc957ddddd402004bb91

#include "N4910.h"

using namespace std;

// 28.7.1 Header <cmath> synopsis  [cmath.syn]
namespace std {
using float_t = see_below;
using double_t = see_below;
}
namespace std {
float acos(float x); // see 16.2
double acos(double x);
long double acos(long double x);
float acosf(float x);
long double acosl(long double x);
float asin(float x); // see 16.2
double asin(double x);
long double asin(long double x);
float asinf(float x);
long double asinl(long double x);
float atan(float x);
double atan(double x);
long double atan(long double x);
float atanf(float x);
long double atanl(long double x);
float atan2(float y, float x);
double atan2(double y, double x);
long double atan2(long double y, long double x); // see 16.2
float atan2f(float y, float x);
long double atan2l(long double y, long double x);
float cos(float x);
double cos(double x);
long double cos(long double x);
float cosf(float x);
long double cosl(long double x);
float sin(float x);
double sin(double x);
long double sin(long double x);
float sinf(float x);
long double sinl(long double x);
float tan(float x);
double tan(double x);
long double tan(long double x);
float tanf(float x);
long double tanl(long double x);
float acosh(float x);
double acosh(double x);
long double acosh(long double x);
float acoshf(float x);
long double acoshl(long double x);
float asinh(float x);
double asinh(double x);
long double asinh(long double x);
float asinhf(float x);
long double asinhl(long double x);
float atanh(float x);
double atanh(double x);
long double atanh(long double x);
float atanhf(float x);
long double atanhl(long double x);
float cosh(float x);
double cosh(double x);
long double cosh(long double x);
// see 16.2
// see 16.2
// see 16.2 // see 16.2
// see 16.2 // see 16.2
// see 16.2 // see 16.2
// see 16.2 // see 16.2
// see 16.2 // see 16.2
// see 16.2 // see 16.2
// see 16.2 // see 16.2
// see 16.2 // see 16.2
// see 16.2
float coshf(float x);
long double coshl(long double x);
float sinh(float x);
double sinh(double x);
long double sinh(long double x);
float sinhf(float x);
long double sinhl(long double x);
float tanh(float x);
double tanh(double x);
long double tanh(long double x);
float tanhf(float x);
long double tanhl(long double x);
float exp(float x);
double exp(double x);
long double exp(long double x);
float expf(float x);
long double expl(long double x);
float exp2(float x);
double exp2(double x);
long double exp2(long double x);
float exp2f(float x);
long double exp2l(long double x);
float expm1(float x);
double expm1(double x);
long double expm1(long double x);
float expm1f(float x);
long double expm1l(long double x);
// see 16.2 // see 16.2
// see 16.2 // see 16.2
// see 16.2 // see 16.2
// see 16.2 // see 16.2
// see 16.2 // see 16.2
constexpr float frexp(float value, int* exp);
constexpr double frexp(double value, int* exp);
constexpr long double frexp(long double value, int* exp); // see 16.2
constexpr float frexpf(float value, int* exp);
constexpr long double frexpl(long double value, int* exp);
constexpr int ilogb(float x);
constexpr int ilogb(double x);
constexpr int ilogb(long double x);
constexpr int ilogbf(float x);
constexpr int ilogbl(long double x);
constexpr float ldexp(float x, int exp);
constexpr double ldexp(double x, int exp);
constexpr long double ldexp(long double x, int exp); // see 16.2
constexpr float ldexpf(float x, int exp);
constexpr long double ldexpl(long double x, int exp);
float log(float x);
double log(double x);
long double log(long double x);
float logf(float x);
long double logl(long double x);
float log10(float x);
double log10(double x);
long double log10(long double x);
float log10f(float x);
long double log10l(long double x);
// see 16.2 // see 16.2
// see 16.2 // see 16.2
// see 16.2
// see 16.2 // see 16.2
// see 16.2
float log1p(float x);
double log1p(double x);
long double log1p(long double x);
float log1pf(float x);
long double log1pl(long double x);
float log2(float x);
double log2(double x);
long double log2(long double x);
float log2f(float x);
long double log2l(long double x);
// see 16.2 // see 16.2
// see 16.2 // see 16.2
constexpr float logb(float x);
constexpr double logb(double x);
constexpr long double logb(long double x);
constexpr float logbf(float x);
constexpr long double logbl(long double x);
// see 16.2 // see 16.2
constexpr float modf(float value, float* iptr); // see 16.2
constexpr double modf(double value, double* iptr);
constexpr long double modf(long double value, long double* iptr); // see 16.2
constexpr float modff(float value, float* iptr);
constexpr long double modfl(long double value, long double* iptr);
constexpr float scalbn(float x, int n); // see 16.2
constexpr double scalbn(double x, int n);
constexpr long double scalbn(long double x, int n); // see 16.2
constexpr float scalbnf(float x, int n);
constexpr long double scalbnl(long double x, int n);
constexpr float scalbln(float x, long int n); // see 16.2
constexpr double scalbln(double x, long int n);
constexpr long double scalbln(long double x, long int n); // see 16.2
constexpr float scalblnf(float x, long int n);
constexpr long double scalblnl(long double x, long int n);
float cbrt(float x);
double cbrt(double x);
long double cbrt(long double x);
float cbrtf(float x);
long double cbrtl(long double x);
// see 16.2 // see 16.2
// 28.7.2, absolute values
constexpr int abs(int j);
constexpr long int abs(long int j);
constexpr long long int abs(long long int j);
constexpr float abs(float j);
constexpr double abs(double j);
constexpr long double abs(long double j);
constexpr float fabs(float x);
constexpr double fabs(double x);
constexpr long double fabs(long double x);
constexpr float fabsf(float x);
constexpr long double fabsl(long double x);
// see 16.2 // see 16.2
float hypot(float x, float y); // see 16.2
double hypot(double x, double y);
long double hypot(long double x, long double y); // see 16.2
float hypotf(float x, float y);
long double hypotl(long double x, long double y);
// 28.7.3, three-dimensional hypotenuse
float hypot(float x, float y, float z);
double hypot(double x, double y, double z);
long double hypot(long double x, long double y, long double z);
float pow(float x, float y); // see 16.2
double pow(double x, double y);
long double pow(long double x, long double y);
float powf(float x, float y);
long double powl(long double x, long double y);
// see 16.2
float sqrt(float x);
double sqrt(double x);
long double sqrt(long double x);
float sqrtf(float x);
long double sqrtl(long double x);
float erf(float x);
double erf(double x);
long double erf(long double x);
float erff(float x);
long double erfl(long double x);
float erfc(float x);
double erfc(double x);
long double erfc(long double x);
float erfcf(float x);
long double erfcl(long double x);
float lgamma(float x);
double lgamma(double x);
long double lgamma(long double x);
float lgammaf(float x);
long double lgammal(long double x);
float tgamma(float x);
double tgamma(double x);
long double tgamma(long double x);
float tgammaf(float x);
long double tgammal(long double x);
// see 16.2 // see 16.2
// see 16.2 // see 16.2
// see 16.2 // see 16.2
// see 16.2 // see 16.2
// see 16.2 // see 16.2
constexpr float ceil(float x);
constexpr double ceil(double x);
constexpr long double ceil(long double x);
constexpr float ceilf(float x);
constexpr long double ceill(long double x);
constexpr float floor(float x);
constexpr double floor(double x);
constexpr long double floor(long double x);
constexpr float floorf(float x);
constexpr long double floorl(long double x);
// see 16.2 // see 16.2
// see 16.2 // see 16.2
float nearbyint(float x); // see 16.2
double nearbyint(double x);
long double nearbyint(long double x); // see 16.2
float nearbyintf(float x);
long double nearbyintl(long double x);
float rint(float x);
double rint(double x);
long double rint(long double x);
float rintf(float x);
long double rintl(long double x);
// see 16.2 // see 16.2
long int lrint(float x);
long int lrint(double x);
long int lrint(long double x);
long int lrintf(float x);
long int lrintl(long double x);
long long int llrint(float x);
long long int llrint(double x);
long long int llrint(long double x);
long long int llrintf(float x);
long long int llrintl(long double x);
// see 16.2 // see 16.2
// see 16.2 // see 16.2
constexpr float round(float x);
constexpr double round(double x);
constexpr long double round(long double x);
constexpr float roundf(float x);
constexpr long double roundl(long double x);
constexpr long int lround(float x);
constexpr long int lround(double x);
constexpr long int lround(long double x);
constexpr long int lroundf(float x);
constexpr long int lroundl(long double x);
// see 16.2 // see 16.2
// see 16.2 // see 16.2
// see 16.2 // see 16.2
// see 16.2 see 16.2
constexpr float fmod(float x, float y); //
constexpr double fmod(double x, double y);
constexpr long double fmod(long double x, long double y);
constexpr float fmodf(float x, float y);
constexpr long double fmodl(long double x, long double y);
constexpr float remainder(float x, float y); // see 16.2
constexpr double remainder(double x, double y);
constexpr long double remainder(long double x, long double y);
constexpr float remainderf(float x, float y);
constexpr long double remainderl(long double x, long double y);
constexpr float remquo(float x, float y, int* quo); // see 16.2
constexpr double remquo(double x, double y, int* quo);
constexpr long double remquo(long double x, long double 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 long long int llround(float x);
constexpr long long int llround(double x);
constexpr long long int llround(long double x);
constexpr long long int llroundf(float x);
constexpr long long int llroundl(long double x);
constexpr float trunc(float x); //
constexpr double trunc(double x);
constexpr long double trunc(long double x); //
constexpr float truncf(float x);
constexpr long double truncl(long double x);
constexpr float copysign(float x, float y); // see 16.2
constexpr double copysign(double x, double y);
constexpr long double copysign(long double x, long double 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);
// see 16.2
// see 16.2
// see 16.2
// see 16.2
// see 16.2
constexpr float nextafter(float x, float y); // see 16.2
constexpr double nextafter(double x, double y);
constexpr long double nextafter(long double x, long double y);
constexpr float nextafterf(float x, float y);
constexpr long double nextafterl(long double x, long double y);
// see 16.2
constexpr float nexttoward(float x, long double y); // see 16.2
constexpr double nexttoward(double x, long double y);
constexpr long double nexttoward(long double x, long double y);
constexpr float nexttowardf(float x, long double y);
constexpr long double nexttowardl(long double x, long double y);
// see 16.2
constexpr float fdim(float x, float y); // see 16.2
constexpr double fdim(double x, double y);
constexpr long double fdim(long double x, long double y);
constexpr float fdimf(float x, float y);
constexpr long double fdiml(long double x, long double y);
constexpr float fmax(float x, float y); // see 16.2
constexpr double fmax(double x, double y);
constexpr long double fmax(long double x, long double y);
constexpr float fmaxf(float x, float y);
constexpr long double fmaxl(long double x, long double y);
constexpr float fmin(float x, float y); // see 16.2
constexpr double fmin(double x, double y);
constexpr long double fmin(long double x, long double y);
constexpr float fminf(float x, float y);
constexpr long double fminl(long double x, long double y);
// see 16.2
// see 16.2
// see 16.2
constexpr float fma(float x, float y, float z); // see 16.2
constexpr double fma(double x, double y, double z);
constexpr long double fma(long double x, long double y, long double z);
constexpr float fmaf(float x, float y, float z);
constexpr long double fmal(long double x, long double y, long double z);
// see 16.2
// 28.7.4, linear interpolation
constexpr float lerp(float a, float b, float t) noexcept;
constexpr double lerp(double a, double b, double t) noexcept;
constexpr long double lerp(long double a, long double b, long double t) noexcept;
// 28.7.5, classification / comparison functions
constexpr int fpclassify(float x);
constexpr int fpclassify(double x);
constexpr int fpclassify(long double x);
constexpr bool isfinite(float x);
constexpr bool isfinite(double x);
constexpr bool isfinite(long double x);
constexpr bool isinf(float x);
constexpr bool isinf(double x);
constexpr bool isinf(long double x);
constexpr bool isnan(float x);
constexpr bool isnan(double x);
constexpr bool isnan(long double x);
constexpr bool isnormal(float x);
constexpr bool isnormal(double x);
constexpr bool isnormal(long double x);
constexpr bool signbit(float x);
constexpr bool signbit(double x);
constexpr bool signbit(long double x);
constexpr bool isgreater(float x, float y);
constexpr bool isgreater(double x, double y);
constexpr bool isgreater(long double x, long double y);
constexpr bool isgreaterequal(float x, float y);
constexpr bool isgreaterequal(double x, double y);
constexpr bool isgreaterequal(long double x, long double y);
constexpr bool isless(float x, float y);
constexpr bool isless(double x, double y);
constexpr bool isless(long double x, long double y);
constexpr bool islessequal(float x, float y);
constexpr bool islessequal(double x, double y);
constexpr bool islessequal(long double x, long double y);
constexpr bool islessgreater(float x, float y);
constexpr bool islessgreater(double x, double y);
constexpr bool islessgreater(long double x, long double y);
constexpr bool isunordered(float x, float y);
constexpr bool isunordered(double x, double y);
constexpr bool isunordered(long double x, long double y);
// 28.7.6, mathematical special functions
// 28.7.6.2, associated Laguerre polynomials
double assoc_laguerre(unsigned n, unsigned m, double x);
float assoc_laguerref(unsigned n, unsigned m, float x);
long double assoc_laguerrel(unsigned n, unsigned m, long double x);
// 28.7.6.3, associated Legendre functions
double assoc_legendre(unsigned l, unsigned m, double x);
float assoc_legendref(unsigned l, unsigned m, float x);
long double assoc_legendrel(unsigned l, unsigned m, long double x);
// 28.7.6.4, beta function
double beta(double x, double y);
float betaf(float x, float y);
long double betal(long double x, long double y);
// 28.7.6.5, complete elliptic integral of the first kind
double comp_ellint_1(double k);
float comp_ellint_1f(float k);
long double comp_ellint_1l(long double k);
// 28.7.6.6, complete elliptic integral of the second kind
double comp_ellint_2(double k);
float comp_ellint_2f(float k);
long double comp_ellint_2l(long double k);
// 28.7.6.7, complete elliptic integral of the third kind
double comp_ellint_3(double k, double nu);
float comp_ellint_3f(float k, float nu);
long double comp_ellint_3l(long double k, long double nu);
// 28.7.6.8, regular modified cylindrical Bessel functions
double cyl_bessel_i(double nu, double x);
float cyl_bessel_if(float nu, float x);
long double cyl_bessel_il(long double nu, long double x);
// 28.7.6.9, cylindrical Bessel functions of the first kind
double cyl_bessel_j(double nu, double x);
float cyl_bessel_jf(float nu, float x);
long double cyl_bessel_jl(long double nu, long double x);
// 28.7.6.10, irregular modified cylindrical Bessel functions
double cyl_bessel_k(double nu, double x);
float cyl_bessel_kf(float nu, float x);
long double cyl_bessel_kl(long double nu, long double x);
// 28.7.6.11, cylindrical Neumann functions;
// cylindrical Bessel functions of the second kind
double cyl_neumann(double nu, double x);
float cyl_neumannf(float nu, float x);
long double cyl_neumannl(long double nu, long double x);
// 28.7.6.12, incomplete elliptic integral of the first kind
double ellint_1(double k, double phi);
float ellint_1f(float k, float phi);
long double ellint_1l(long double k, long double phi);
// 28.7.6.13, incomplete elliptic integral of the second kind
double ellint_2(double k, double phi);
float ellint_2f(float k, float phi);
long double ellint_2l(long double k, long double phi);
// 28.7.6.14, incomplete elliptic integral of the third kind
double ellint_3(double k, double nu, double phi);
float ellint_3f(float k, float nu, float phi);
long double ellint_3l(long double k, long double nu, long double phi);
// 28.7.6.15, exponential integral
double expint(double x);
float expintf(float x);
long double expintl(long double x);
// 28.7.6.16, Hermite polynomials
double hermite(unsigned n, double x);
float hermitef(unsigned n, float x);
long double hermitel(unsigned n, long double x);
// 28.7.6.17, Laguerre polynomials
double laguerre(unsigned n, double x);
float laguerref(unsigned n, float x);
long double laguerrel(unsigned n, long double x);
// 28.7.6.18, Legendre polynomials
double legendre(unsigned l, double x);
float legendref(unsigned l, float x);
long double legendrel(unsigned l, long double x);
// 28.7.6.19, Riemann zeta function
double riemann_zeta(double x);
float riemann_zetaf(float x);
long double riemann_zetal(long double x);
// 28.7.6.20, spherical Bessel functions of the first kind
double sph_bessel(unsigned n, double x);
float sph_besself(unsigned n, float x);
long double sph_bessell(unsigned n, long double x);
// 28.7.6.21, spherical associated Legendre functions
double sph_legendre(unsigned l, unsigned m, double theta);
float sph_legendref(unsigned l, unsigned m, float theta);
long double  sph_legendrel(unsigned l, unsigned m, long double theta);
// 28.7.6.22, spherical Neumann functions;
// spherical Bessel functions of the second kind
double sph_neumann(unsigned n, double x);
float sph_neumannf(unsigned n, float x);
long double sph_neumannl(unsigned n, long double x);
}
//  The contents and meaning of the header <cmath> are the same as the C standard library header <math.h>, with the addition of a three-dimensional hypotenuse function (28.7.3), a linear interpolation function (28.7.4), and the mathematical special functions described in 28.7.6.
// [Note 1: Several functions have additional overloads in this document, but they have the same behavior as in the C standard library (16.2).
//  For each set of overloaded functions within <cmath>, with the exception of abs, there shall be additional overloads sufficient to ensure:
// — If any argument of arithmetic type corresponding to a double parameter has type long double, then all arguments of arithmetic type (6.8.2) corresponding to double parameters are effectively cast to long double.
// — Otherwise, if any argument of arithmetic type corresponding to a double parameter has type double or an integer type, then all arguments of arithmetic type corresponding to double parameters are effectively cast to double.
// — [Note 2: Otherwise, all arguments of arithmetic type corresponding to double parameters have type float.
//  [Note 1: The headers <cstdlib> (17.2.2) and <cmath> (28.7.1) declare the functions described in this subclause.
constexpr int abs(int j);
constexpr long int abs(long int j);
constexpr long long int abs(long long int j);
constexpr float abs(float j);
constexpr double abs(double j);
constexpr long double abs(long double j);
// [Note 3: abs is exempted from these rules in order to stay compatible with C.
//  See also: ISO C 7.12
// 28.7.2 Absolute values [c.math.abs]
// Effects: The abs functions have the semantics specified in the C standard library for the functions abs, labs, llabs, fabsf, fabs, and fabsl.
// Remarks: If abs() is called with an argument of type X for which is_unsigned_v<X> is true and if X cannot be converted to int by integral promotion (7.3.7), the program is ill-formed.
//  Returns: 􏰙x2 + y2 + z2.
// 28.7.4 Linear interpolation [c.math.lerp]
// [Note 2: Arguments that can be promoted to int are permitted for compatibility with C.
//  See also: ISO C 7.12.7.2, 7.22.6.1
// 28.7.3 Three-dimensional hypotenuse [c.math.hypot3]
float hypot(float x, float y, float z);
double hypot(double x, double y, double z);
long double hypot(long double x, long double y, long double z);
// Returns: a + t(b − a).
constexpr float lerp(float a, float b, float t) noexcept;
constexpr double lerp(double a, double b, double t) noexcept;
constexpr long double lerp(long double a, long double b, long double t) noexcept;
// Remarks: Let r be the value returned. If isfinite(a) && isfinite(b), then: // — If t == 0, then r == a.
// — If t == 1, then r == b.
// — If t >= 0 && t <= 1, then isfinite(r).
// — If isfinite(t) && a == b, then r == a.
// — If isfinite(t) || !isnan(t) && b-a != 0, then !isnan(r). LetCMP(x,y)be1ifx>y,-1ifx<y,and0otherwise. Foranyt1andt2,theproductof
//  The classification / comparison functions behave the same as the C macros with the corresponding names defined in the C standard library. Each function is overloaded for the three floating-point types.
// See also: ISO C 7.12.3, 7.12.4
// 28.7.6 Mathematical special functions [sf.cmath]
// 28.7.6.1 General [sf.cmath.general]
//  If any argument value to any of the functions specified in 28.7.6 is a NaN (Not a Number), the function shall return a NaN but it shall not report a domain error. Otherwise, the function shall report a domain error for just those argument values for which: CMP (lerp(a, b, t2), lerp(a, b, t1)), CMP (t2, t1), and CMP (b, a) is non-negative.
// 28.7.5 Classification / comparison functions [c.math.fpclass]
// infinity.
// — the function description’s Returns: element explicitly specifies a domain and those argument values fall outside the specified domain, or
// — the corresponding mathematical function value has a nonzero imaginary component, or
// — the corresponding mathematical function is not mathematically defined.244
//  Unless otherwise specified, each function is defined for all finite values, for negative infinity, and for positive
// Returns: where n is n, m is m, and x is x.
// 28.7.6.2Associated Laguerre polynomials [sf.cmath.assoc.laguerre]
// Effects: These functions compute the associated Laguerre polynomials of their respective arguments n, m, and x.
double assoc_laguerre(unsigned n, unsigned m, double x);
float assoc_laguerref(unsigned n, unsigned m, float x);
t
long double  assoc_laguerrel(unsigned n, unsigned m, long double x);
// m m dm
// Ln(x)=(−1) dxm Ln+m(x), forx≥0,
//  28.7.6.3 Associated Legendre functions [sf.cmath.assoc.legendre]
// Remarks: The effect of calling each of these functions is implementation-defined if n >= 128 or if m >= 128.
// Effects: These functions compute the associated Legendre functions of their respective arguments l, m, and x.
// Returns: m 2 m/2 dm Pl (x)=(1−x ) dxm Pl(x), for|x|≤1,
double assoc_legendre(unsigned l, unsigned m, double x);
float assoc_legendref(unsigned l, unsigned m, float x);
long double  assoc_legendrel(unsigned l, unsigned m, long double x);
//  where l is l, m is m, and x is x.
// Remarks: The effect of calling each of these functions is implementation-defined if l >= 128.
// 244) A mathematical function is mathematically defined for a given set of argument values (a) if it is explicitly defined for that  set of argument values, or (b) if its limiting value exists and does not depend on the direction of approach.
// Returns: where x is x and y is y. B(x,y)=Γ(x)Γ(y), forx>0,y>0, Γ(x+y)
// 28.7.6.4 Beta function [sf.cmath.beta]
// Effects: These functions compute the beta function of their respective arguments x and y.
double beta(double x, double y);
float betaf(float x, float y);
long double  betal(long double x, long double y);
// Effects: These functions compute the complete elliptic integral of the first kind of their respective arguments k.
// 28.7.6.5 Complete elliptic integral of the first kind  [sf.cmath.comp.ellint.1]
double comp_ellint_1(double k);
float comp_ellint_1f(float k);
long double  comp_ellint_1l(long double k);
// Returns: where k is k. See also 28.7.6.12. K(k) = F(k,π/2) , for |k| ≤ 1,
// Effects: These functions compute the complete elliptic integral of the second kind of their respective arguments k.
// 28.7.6.6 Complete elliptic integral of the second kind [sf.cmath.comp.ellint.2]
double comp_ellint_2(double k);
float comp_ellint_2f(float k);
long double  comp_ellint_2l(long double k);
// 28.7.6.7 Complete elliptic integral of the third kind [sf.cmath.comp.ellint.3]
// Returns: where k is k. See also 28.7.6.13. E(k) = E(k,π/2) , for |k| ≤ 1,
// Effects: These functions compute the complete elliptic integral of the third kind of their respective arguments k and nu.
// Returns:−ν 􏰓∞ Iν(x)=i Jν(ix)= k=0
double comp_ellint_3(double k, double nu);
float comp_ellint_3f(float k, float nu);
long double  comp_ellint_3l(long double k, long double nu);
// Returns:where k is k and ν is nu. See also 28.7.6.14.Π(ν,k) = Π(ν,k,π/2) , for |k| ≤ 1,
// 28.7.6.8 Regular modified cylindrical Bessel functions [sf.cmath.cyl.bessel.i]
double cyl_bessel_i(double nu, double x);
float cyl_bessel_if(float nu, float x);
long double  cyl_bessel_il(long double nu, long double x);
// Effects: These functions compute the regular modified cylindrical Bessel functions of their respective arguments nu and x.(x/2)ν +2k k!Γ(ν+k+1) ,forx≥0,where ν is nu and x is x.
// Remarks: The effect of calling each of these functions is implementation-defined if nu >= 128. See also 28.7.6.9.
// 28.7.6.9 Cylindrical Bessel functions of the first kind [sf.cmath.cyl.bessel.j]
// Effects: These functions compute the cylindrical Bessel functions of the first kind of their respective arguments nu and x.
// Returns:∞ (−1)k (x/2)ν +2k
double cyl_bessel_j(double nu, double x);
float cyl_bessel_jf(float nu, float x);
long double  cyl_bessel_jl(long double nu, long double x);
// k!Γ(ν+k+1) , forx≥0,
// Remarks: The effect of calling each of these functions is implementation-defined if nu >= 128. Jν(x)=
// 28.7.6.10 Irregular modified cylindrical Bessel functions [sf.cmath.cyl.bessel.k]
// where ν is nu and x is x.
double cyl_bessel_k(double nu, double x);
float cyl_bessel_kf(float nu, float x);
long double  cyl_bessel_kl(long double nu, long double x);
// k=0
// Effects: These functions compute the irregular modified cylindrical Bessel functions of their respective arguments nu and x.
// Returns: Kν (x) = (π/2)iν+1(Jν (ix) + iNν (ix)) = πI (x)−I(x)  −ν ν for x ≥ 0 and non-integral ν for x ≥ 0 and integral ν
//  28.7.6.11 Cylindrical Neumann functions [sf.cmath.cyl.neumann]
// where ν is nu and x is x.
// Remarks: The effect of calling each of these functions is implementation-defined if nu >= 128. See also 28.7.6.8, 28.7.6.9, 28.7.6.11.
// Effects: These functions compute the cylindrical Neumann functions, also known as the cylindrical Bessel functions of the second kind, of their respective arguments nu and x.
double cyl_neumann(double nu, double x);
float cyl_neumannf(float nu, float x);
long double  cyl_neumannl(long double nu, long double x);
// Returns:
// Remarks: The effect of calling each of these functions is implementation-defined if nu >= 128. where ν is nu and x is x. See also 28.7.6.9.
// Returns: 􏰔φ 0
// 28.7.6.12 Incomplete elliptic integral of the first kind [sf.cmath.ellint.1]
// Effects: These functions compute the incomplete elliptic integral of the first kind of their respective arguments k and phi (phi measured in radians).
double ellint_1(double k, double phi);
float ellint_1f(float k, float phi);
long double  ellint_1l(long double k, long double phi);
// F(k, φ) = dθ 􏰙 2 2 , for |k| ≤ 1,   1−k sin θ Incomplete elliptic integral of the second kind where k is k and φ is phi.
// 28.7.6.13 incomplete elliptic integral of the second kind [sf.cmath.ellint.2]
double ellint_2(double k, double phi);
float ellint_2f(float k, float phi);
long double  ellint_2l(long double k, long double phi);
// Effects: These functions compute the incomplete elliptic integral of the second kind of their respective arguments k and phi (phi measured in radians).
// Returns: where k is k and φ is phi. E(k,φ)= 􏰔φ􏰙 2 2 1−k sin θdθ, for|k|≤1, 0
//  28.7.6.14 Incomplete elliptic integral of the third kind [sf.cmath.ellint.3]
// Effects: These functions compute the incomplete elliptic integral of the third kind of their respective arguments k, nu, and phi (phi measured in radians).
// Returns: 􏰔φ 0 (1−νsinθ) 1−ksinθ
double ellint_3(double k, double nu, double phi);
float ellint_3f(float k, float nu, float phi);
long double  ellint_3l(long double k, long double nu, long double phi);
// Π(ν, k, φ) = where ν is nu, k is k, and φ is phi. dθ 2 􏰙 2 2 , for |k| ≤ 1,
//  28.7.6.15 Exponential integral [sf.cmath.expint]
double  expint(double x);
float expintf(float x);
long double  expintl(long double x);
// Effects: These functions compute the exponential integral of their respective arguments x.
// Returns: where x is x. 􏰔 ∞ e−t t dt Ei(x)=−
//  28.7.6.16 Hermite polynomials [sf.cmath.hermite]
double hermite(unsigned n, double x);
float hermitef(unsigned n, float x);
long double  hermitel(unsigned n, long double x);
// Effects: These functions compute the Hermite polynomials of their respective arguments n and x.
// Returns: where n is n and x is x.n x2 dn −x2 Hn(x) = (−1) e dxn e
//  Remarks: The effect of calling each of these functions is implementation-defined if n >= 128.
// Returns: ex dn Ln(x)= n!dxn (xne−x), forx≥0,
// 28.7.6.17 Laguerre polynomials [sf.cmath.laguerre]
// Effects: These functions compute the Laguerre polynomials of their respective arguments n and x.
// Returns: where x is x.􏰓 −x
double laguerre(unsigned n, double x);
float laguerref(unsigned n, float x);
long double  laguerrel(unsigned n, long double x);
//   28.7.6.18 Legendre polynomials [sf.cmath.legendre]
// where n is n and x is x.
// Remarks: The effect of calling each of these functions is implementation-defined if n >= 128.
double legendre(unsigned l, double x);
float legendref(unsigned l, float x);
long double  legendrel(unsigned l, long double x);
// Effects: These functions compute the Legendre polynomials of their respective arguments l and x.
// Returns: 1 dl Pl(x)=2ll!dxl (x2−1)l , for|x|≤1,  where l is l and x is x.
// Remarks: The effect of calling each of these functions is implementation-defined if l >= 128.
// 28.7.6.19 Riemann zeta function [sf.cmath.riemann.zeta]
double riemann_zeta(double x);
float riemann_zetaf(float x);
long double  riemann_zetal(long double x);
// Effects: These functions compute the Riemann zeta function of their respective arguments x. ζ(x) = 1 ∞ 􏰓(−1)k−1k−x, k, forx>1 k=1
//for 0 ≤ x ≤ 1 2xπx−1sin( 2 )Γ(1−x)ζ(1−x), forx<0
// where n is n and x is x. See also 28.7.6.9. 1−21−x πx k=1
// 28.7.6.20 Spherical Bessel functions of the first kind [sf.cmath.sph.bessel]
// Effects: These functions compute the spherical Bessel functions of the first kind of their respective arguments n and x.
// Returns: jn(x)=(π/2x)1/2Jn+1/2(x), forx≥0,
// Remarks: The effect of calling each of these functions is implementation-defined if n >= 128.
double sph_bessel(unsigned n, double x);
float sph_besself(unsigned n, float x);
long double  sph_bessell(unsigned n, long double x);
// Returns: where Ylm(θ, 0) (2l + 1) (l − m)!􏰎1/2 Ylm(θ, φ) = (−1)m Pml (cos θ)eimφ ,
// Effects: These functions compute the spherical associated Legendre functions of their respective arguments l, m, and theta (theta measured in radians).
// 28.7.6.21 Spherical associated Legendre functions [sf.cmath.sph.legendre]
double sph_legendre(unsigned l, unsigned m, double theta);
float sph_legendref(unsigned l, unsigned m, float theta);
long double  sph_legendrel(unsigned l, unsigned m, long double theta);
//  4π (l + m)! for |m| ≤ l, and l is l, m is m, and θ is theta.
// Remarks: The effect of calling each of these functions is implementation-defined if l >= 128. See also 28.7.6.3.
// 28.7.6.22 Spherical Neumann functions [sf.cmath.sph.neumann]
double sph_neumann(unsigned n, double x);
float sph_neumannf(unsigned n, float x);
long double  sph_neumannl(unsigned n, long double x);
// Effects: These functions compute the spherical Neumann functions, also known as the spherical Bessel functions of the second kind, of their respective arguments n and x.
// Returns: nn(x)=(π/2x)1/2Nn+1/2(x), forx≥0,
// Remarks: The effect of calling each of these functions is implementation-defined if n >= 128.
// where n is n and x is x. See also 28.7.6.11.
int main() {
    cout  <<  n4910 << endl;
    return EXIT_SUCCESS;
}
```

## 編纂・実行結果(compile and go)

```ubuntu:bash
$ clang++ p1339.cpp -std=03 -o p1339l -I. -Wall
In file included from p1339.cpp:10:
In file included from ./N4910.h:11:
In file included from /usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/atomic:38:
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/c++0x_warning.h:32:2: error: This file requires compiler and library support for the ISO C++ 2011 standard. This support must be enabled with the -std=c++11 or -std=gnu++11 compiler options.
#error This file requires compiler and library support \
 ^
p1339.cpp:16:17: warning: alias declarations are a C++11 extension [-Wc++11-extensions]
using float_t = see_below;
                ^
p1339.cpp:16:17: error: unknown type name 'see_below'
p1339.cpp:17:18: warning: alias declarations are a C++11 extension [-Wc++11-extensions]
using double_t = see_below;
                 ^
p1339.cpp:17:18: error: unknown type name 'see_below'
p1339.cpp:21:8: error: declaration conflicts with target of using declaration already in scope
double acos(double x);
       ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:53:13: note: target of using declaration
__MATHCALL (acos,, (_Mdouble_ __x));
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/cmath:83:11: note: using declaration
  using ::acos;
          ^
p1339.cpp:26:8: error: declaration conflicts with target of using declaration already in scope
double asin(double x);
       ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:55:13: note: target of using declaration
__MATHCALL (asin,, (_Mdouble_ __x));
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/cmath:102:11: note: using declaration
  using ::asin;
          ^
p1339.cpp:30:10: error: declaration conflicts with target of using declaration already in scope
  double atan(double x);
         ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:57:13: note: target of using declaration
__MATHCALL (atan,, (_Mdouble_ __x));
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/cmath:121:11: note: using declaration
  using ::atan;
          ^
p1339.cpp:35:8: error: declaration conflicts with target of using declaration already in scope
double atan2(double y, double x);
       ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:59:13: note: target of using declaration
__MATHCALL (atan2,, (_Mdouble_ __y, _Mdouble_ __x));
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/cmath:140:11: note: using declaration
  using ::atan2;
          ^
p1339.cpp:40:8: error: declaration conflicts with target of using declaration already in scope
double cos(double x);
       ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:62:17: note: target of using declaration
__MATHCALL_VEC (cos,, (_Mdouble_ __x));
                ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/cmath:180:11: note: using declaration
  using ::cos;
          ^
p1339.cpp:45:8: error: declaration conflicts with target of using declaration already in scope
double sin(double x);
       ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:64:17: note: target of using declaration
__MATHCALL_VEC (sin,, (_Mdouble_ __x));
                ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/cmath:421:11: note: using declaration
  using ::sin;
          ^
p1339.cpp:50:8: error: declaration conflicts with target of using declaration already in scope
double tan(double x);
       ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:66:13: note: target of using declaration
__MATHCALL (tan,, (_Mdouble_ __x));
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/cmath:478:11: note: using declaration
  using ::tan;
          ^
p1339.cpp:70:8: error: declaration conflicts with target of using declaration already in scope
double cosh(double x);
       ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:71:13: note: target of using declaration
__MATHCALL (cosh,, (_Mdouble_ __x));
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/cmath:199:11: note: using declaration
  using ::cosh;
          ^
p1339.cpp:86:8: error: declaration conflicts with target of using declaration already in scope
double sinh(double x);
       ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:73:13: note: target of using declaration
__MATHCALL (sinh,, (_Mdouble_ __x));
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/cmath:440:11: note: using declaration
  using ::sinh;
          ^
p1339.cpp:91:8: error: declaration conflicts with target of using declaration already in scope
double tanh(double x);
       ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:75:13: note: target of using declaration
__MATHCALL (tanh,, (_Mdouble_ __x));
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/cmath:497:11: note: using declaration
  using ::tanh;
          ^
p1339.cpp:96:8: error: declaration conflicts with target of using declaration already in scope
double exp(double x);
       ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:95:17: note: target of using declaration
__MATHCALL_VEC (exp,, (_Mdouble_ __x));
                ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/cmath:218:11: note: using declaration
  using ::exp;
          ^
p1339.cpp:115:1: error: unknown type name 'constexpr'
constexpr float frexp(float value, int* exp);
^
p1339.cpp:116:1: error: unknown type name 'constexpr'
constexpr double frexp(double value, int* exp);
^
p1339.cpp:117:1: error: unknown type name 'constexpr'
constexpr long double frexp(long double value, int* exp); // see 16.2 
^
p1339.cpp:118:1: error: unknown type name 'constexpr'
constexpr float frexpf(float value, int* exp);
^
p1339.cpp:119:1: error: unknown type name 'constexpr'
constexpr long double frexpl(long double value, int* exp);
^
fatal error: too many errors emitted, stopping now [-ferror-limit=]
2 warnings and 20 errors generated.
$ clang++ p1339.cpp -std=2b -o p1339l -I. -Wall
p1339.cpp:16:17: error: unknown type name 'see_below'
using float_t = see_below;
                ^
p1339.cpp:17:18: error: unknown type name 'see_below'
using double_t = see_below;
                 ^
p1339.cpp:20:7: error: non-constexpr declaration of 'acos' follows constexpr declaration
float acos(float x); // see 16.2 
      ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/cmath:87:3: note: previous declaration is here
  acos(float __x)
  ^
p1339.cpp:21:8: error: declaration conflicts with target of using declaration already in scope
double acos(double x);
       ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:53:13: note: target of using declaration
__MATHCALL (acos,, (_Mdouble_ __x));
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/cmath:83:11: note: using declaration
  using ::acos;
          ^
p1339.cpp:22:13: error: non-constexpr declaration of 'acos' follows constexpr declaration
long double acos(long double x); 
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/cmath:91:3: note: previous declaration is here
  acos(long double __x)
  ^
p1339.cpp:25:7: error: non-constexpr declaration of 'asin' follows constexpr declaration
float asin(float x); // see 16.2 
      ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/cmath:106:3: note: previous declaration is here
  asin(float __x)
  ^
p1339.cpp:26:8: error: declaration conflicts with target of using declaration already in scope
double asin(double x);
       ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:55:13: note: target of using declaration
__MATHCALL (asin,, (_Mdouble_ __x));
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/cmath:102:11: note: using declaration
  using ::asin;
          ^
p1339.cpp:27:13: error: non-constexpr declaration of 'asin' follows constexpr declaration
long double asin(long double x); float asinf(float x);
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/cmath:110:3: note: previous declaration is here
  asin(long double __x)
  ^
p1339.cpp:29:9: error: non-constexpr declaration of 'atan' follows constexpr declaration
  float atan(float x);
        ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/cmath:125:3: note: previous declaration is here
  atan(float __x)
  ^
p1339.cpp:30:10: error: declaration conflicts with target of using declaration already in scope
  double atan(double x);
         ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:57:13: note: target of using declaration
__MATHCALL (atan,, (_Mdouble_ __x));
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/cmath:121:11: note: using declaration
  using ::atan;
          ^
p1339.cpp:31:15: error: non-constexpr declaration of 'atan' follows constexpr declaration
  long double atan(long double x);
              ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/cmath:129:3: note: previous declaration is here
  atan(long double __x)
  ^
p1339.cpp:34:7: error: non-constexpr declaration of 'atan2' follows constexpr declaration
float atan2(float y, float x);
      ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/cmath:144:3: note: previous declaration is here
  atan2(float __y, float __x)
  ^
p1339.cpp:35:8: error: declaration conflicts with target of using declaration already in scope
double atan2(double y, double x);
       ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:59:13: note: target of using declaration
__MATHCALL (atan2,, (_Mdouble_ __y, _Mdouble_ __x));
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/cmath:140:11: note: using declaration
  using ::atan2;
          ^
p1339.cpp:36:13: error: non-constexpr declaration of 'atan2' follows constexpr declaration
long double atan2(long double y, long double x); // see 16.2 
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/cmath:148:3: note: previous declaration is here
  atan2(long double __y, long double __x)
  ^
p1339.cpp:39:7: error: non-constexpr declaration of 'cos' follows constexpr declaration
float cos(float x);
      ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/cmath:184:3: note: previous declaration is here
  cos(float __x)
  ^
p1339.cpp:40:8: error: declaration conflicts with target of using declaration already in scope
double cos(double x);
       ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:62:17: note: target of using declaration
__MATHCALL_VEC (cos,, (_Mdouble_ __x));
                ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/cmath:180:11: note: using declaration
  using ::cos;
          ^
p1339.cpp:41:13: error: non-constexpr declaration of 'cos' follows constexpr declaration
long double cos(long double x);
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/cmath:188:3: note: previous declaration is here
  cos(long double __x)
  ^
p1339.cpp:44:7: error: non-constexpr declaration of 'sin' follows constexpr declaration
float sin(float x);
      ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/cmath:425:3: note: previous declaration is here
  sin(float __x)
  ^
p1339.cpp:45:8: error: declaration conflicts with target of using declaration already in scope
double sin(double x);
       ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:64:17: note: target of using declaration
__MATHCALL_VEC (sin,, (_Mdouble_ __x));
                ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/cmath:421:11: note: using declaration
  using ::sin;
          ^
fatal error: too many errors emitted, stopping now [-ferror-limit=]
20 errors generated.

$ g++ p1339.cpp -std=03 -o p1339g -I. -Wall
In file included from /usr/local/include/c++/12.1.0/atomic:38,
                 from N4910.h:11,
                 from p1339.cpp:10:
/usr/local/include/c++/12.1.0/bits/c++0x_warning.h:32:2: error: #error This file requires compiler and library support for the ISO C++ 2011 standard. This support must be enabled with the -std=c++11 or -std=gnu++11 compiler options.
   32 | #error This file requires compiler and library support \
      |  ^~~~~
p1339.cpp:115:1: warning: identifier 'constexpr' is a keyword in C++11 [-Wc++11-compat]
  115 | constexpr float frexp(float value, int* exp);
      | ^~~~~~~~~
p1339.cpp:364:49: warning: identifier 'noexcept' is a keyword in C++11 [-Wc++11-compat]
  364 | constexpr float lerp(float a, float b, float t) noexcept;
      |                                                 ^~~~~~~~
p1339.cpp:16:7: error: expected nested-name-specifier before 'float_t'
   16 | using float_t = see_below;
      |       ^~~~~~~
p1339.cpp:17:7: error: expected nested-name-specifier before 'double_t'
   17 | using double_t = see_below;
      |       ^~~~~~~~
p1339.cpp:21:21: error: 'double std::acos(double)' conflicts with a previous declaration
   21 | double acos(double x);
      |                     ^
In file included from /usr/include/features.h:461,
                 from /usr/local/include/c++/12.1.0/x86_64-linux-gnu/bits/os_defines.h:39,
                 from /usr/local/include/c++/12.1.0/x86_64-linux-gnu/bits/c++config.h:655,
                 from /usr/local/include/c++/12.1.0/cstddef:49,
                 from N4910.h:1:
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:53:1: note: previous declaration 'double acos(double)'
   53 | __MATHCALL (acos,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:26:21: error: 'double std::asin(double)' conflicts with a previous declaration
   26 | double asin(double x);
      |                     ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:55:1: note: previous declaration 'double asin(double)'
   55 | __MATHCALL (asin,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:30:23: error: 'double std::atan(double)' conflicts with a previous declaration
   30 |   double atan(double x);
      |                       ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:57:1: note: previous declaration 'double atan(double)'
   57 | __MATHCALL (atan,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:35:32: error: 'double std::atan2(double, double)' conflicts with a previous declaration
   35 | double atan2(double y, double x);
      |                                ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:59:1: note: previous declaration 'double atan2(double, double)'
   59 | __MATHCALL (atan2,, (_Mdouble_ __y, _Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:40:20: error: 'double std::cos(double)' conflicts with a previous declaration
   40 | double cos(double x);
      |                    ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:62:1: note: previous declaration 'double cos(double)'
   62 | __MATHCALL_VEC (cos,, (_Mdouble_ __x));
      | ^~~~~~~~~~~~~~
p1339.cpp:45:20: error: 'double std::sin(double)' conflicts with a previous declaration
   45 | double sin(double x);
      |                    ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:64:1: note: previous declaration 'double sin(double)'
   64 | __MATHCALL_VEC (sin,, (_Mdouble_ __x));
      | ^~~~~~~~~~~~~~
p1339.cpp:50:20: error: 'double std::tan(double)' conflicts with a previous declaration
   50 | double tan(double x);
      |                    ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:66:1: note: previous declaration 'double tan(double)'
   66 | __MATHCALL (tan,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:70:21: error: 'double std::cosh(double)' conflicts with a previous declaration
   70 | double cosh(double x);
      |                     ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:71:1: note: previous declaration 'double cosh(double)'
   71 | __MATHCALL (cosh,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:86:21: error: 'double std::sinh(double)' conflicts with a previous declaration
   86 | double sinh(double x);
      |                     ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:73:1: note: previous declaration 'double sinh(double)'
   73 | __MATHCALL (sinh,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:91:21: error: 'double std::tanh(double)' conflicts with a previous declaration
   91 | double tanh(double x);
      |                     ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:75:1: note: previous declaration 'double tanh(double)'
   75 | __MATHCALL (tanh,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:96:20: error: 'double std::exp(double)' conflicts with a previous declaration
   96 | double exp(double x);
      |                    ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:95:1: note: previous declaration 'double exp(double)'
   95 | __MATHCALL_VEC (exp,, (_Mdouble_ __x));
      | ^~~~~~~~~~~~~~
p1339.cpp:115:1: error: 'constexpr' does not name a type
  115 | constexpr float frexp(float value, int* exp);
      | ^~~~~~~~~
p1339.cpp:115:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:116:1: error: 'constexpr' does not name a type
  116 | constexpr double frexp(double value, int* exp);
      | ^~~~~~~~~
p1339.cpp:116:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:117:1: error: 'constexpr' does not name a type
  117 | constexpr long double frexp(long double value, int* exp); // see 16.2
      | ^~~~~~~~~
p1339.cpp:117:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:118:1: error: 'constexpr' does not name a type
  118 | constexpr float frexpf(float value, int* exp);
      | ^~~~~~~~~
p1339.cpp:118:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:119:1: error: 'constexpr' does not name a type
  119 | constexpr long double frexpl(long double value, int* exp);
      | ^~~~~~~~~
p1339.cpp:119:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:120:1: error: 'constexpr' does not name a type
  120 | constexpr int ilogb(float x);
      | ^~~~~~~~~
p1339.cpp:120:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:121:1: error: 'constexpr' does not name a type
  121 | constexpr int ilogb(double x);
      | ^~~~~~~~~
p1339.cpp:121:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:122:1: error: 'constexpr' does not name a type
  122 | constexpr int ilogb(long double x);
      | ^~~~~~~~~
p1339.cpp:122:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:123:1: error: 'constexpr' does not name a type
  123 | constexpr int ilogbf(float x);
      | ^~~~~~~~~
p1339.cpp:123:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:124:1: error: 'constexpr' does not name a type
  124 | constexpr int ilogbl(long double x);
      | ^~~~~~~~~
p1339.cpp:124:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:125:1: error: 'constexpr' does not name a type
  125 | constexpr float ldexp(float x, int exp);
      | ^~~~~~~~~
p1339.cpp:125:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:126:1: error: 'constexpr' does not name a type
  126 | constexpr double ldexp(double x, int exp);
      | ^~~~~~~~~
p1339.cpp:126:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:127:1: error: 'constexpr' does not name a type
  127 | constexpr long double ldexp(long double x, int exp); // see 16.2
      | ^~~~~~~~~
p1339.cpp:127:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:128:1: error: 'constexpr' does not name a type
  128 | constexpr float ldexpf(float x, int exp);
      | ^~~~~~~~~
p1339.cpp:128:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:129:1: error: 'constexpr' does not name a type
  129 | constexpr long double ldexpl(long double x, int exp);
      | ^~~~~~~~~
p1339.cpp:129:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:131:20: error: 'double std::log(double)' conflicts with a previous declaration
  131 | double log(double x);
      |                    ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:104:1: note: previous declaration 'double log(double)'
  104 | __MATHCALL_VEC (log,, (_Mdouble_ __x));
      | ^~~~~~~~~~~~~~
p1339.cpp:136:22: error: 'double std::log10(double)' conflicts with a previous declaration
  136 | double log10(double x);
      |                      ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:107:1: note: previous declaration 'double log10(double)'
  107 | __MATHCALL (log10,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:157:1: error: 'constexpr' does not name a type
  157 | constexpr float logb(float x);
      | ^~~~~~~~~
p1339.cpp:157:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:158:1: error: 'constexpr' does not name a type
  158 | constexpr double logb(double x);
      | ^~~~~~~~~
p1339.cpp:158:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:159:1: error: 'constexpr' does not name a type
  159 | constexpr long double logb(long double x);
      | ^~~~~~~~~
p1339.cpp:159:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:160:1: error: 'constexpr' does not name a type
  160 | constexpr float logbf(float x);
      | ^~~~~~~~~
p1339.cpp:160:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:161:1: error: 'constexpr' does not name a type
  161 | constexpr long double logbl(long double x);
      | ^~~~~~~~~
p1339.cpp:161:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:163:1: error: 'constexpr' does not name a type
  163 | constexpr float modf(float value, float* iptr); // see 16.2
      | ^~~~~~~~~
p1339.cpp:163:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:164:1: error: 'constexpr' does not name a type
  164 | constexpr double modf(double value, double* iptr);
      | ^~~~~~~~~
p1339.cpp:164:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:165:1: error: 'constexpr' does not name a type
  165 | constexpr long double modf(long double value, long double* iptr); // see 16.2
      | ^~~~~~~~~
p1339.cpp:165:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:166:1: error: 'constexpr' does not name a type
  166 | constexpr float modff(float value, float* iptr);
      | ^~~~~~~~~
p1339.cpp:166:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:167:1: error: 'constexpr' does not name a type
  167 | constexpr long double modfl(long double value, long double* iptr);
      | ^~~~~~~~~
p1339.cpp:167:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:168:1: error: 'constexpr' does not name a type
  168 | constexpr float scalbn(float x, int n); // see 16.2
      | ^~~~~~~~~
p1339.cpp:168:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:169:1: error: 'constexpr' does not name a type
  169 | constexpr double scalbn(double x, int n);
      | ^~~~~~~~~
p1339.cpp:169:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:170:1: error: 'constexpr' does not name a type
  170 | constexpr long double scalbn(long double x, int n); // see 16.2
      | ^~~~~~~~~
p1339.cpp:170:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:171:1: error: 'constexpr' does not name a type
  171 | constexpr float scalbnf(float x, int n);
      | ^~~~~~~~~
p1339.cpp:171:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:172:1: error: 'constexpr' does not name a type
  172 | constexpr long double scalbnl(long double x, int n);
      | ^~~~~~~~~
p1339.cpp:172:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:173:1: error: 'constexpr' does not name a type
  173 | constexpr float scalbln(float x, long int n); // see 16.2
      | ^~~~~~~~~
p1339.cpp:173:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:174:1: error: 'constexpr' does not name a type
  174 | constexpr double scalbln(double x, long int n);
      | ^~~~~~~~~
p1339.cpp:174:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:175:1: error: 'constexpr' does not name a type
  175 | constexpr long double scalbln(long double x, long int n); // see 16.2
      | ^~~~~~~~~
p1339.cpp:175:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:176:1: error: 'constexpr' does not name a type
  176 | constexpr float scalblnf(float x, long int n);
      | ^~~~~~~~~
p1339.cpp:176:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:177:1: error: 'constexpr' does not name a type
  177 | constexpr long double scalblnl(long double x, long int n);
      | ^~~~~~~~~
p1339.cpp:177:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:185:1: error: 'constexpr' does not name a type
  185 | constexpr int abs(int j);
      | ^~~~~~~~~
p1339.cpp:185:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:186:1: error: 'constexpr' does not name a type
  186 | constexpr long int abs(long int j);
      | ^~~~~~~~~
p1339.cpp:186:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:187:1: error: 'constexpr' does not name a type
  187 | constexpr long long int abs(long long int j);
      | ^~~~~~~~~
p1339.cpp:187:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:188:1: error: 'constexpr' does not name a type
  188 | constexpr float abs(float j);
      | ^~~~~~~~~
p1339.cpp:188:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:189:1: error: 'constexpr' does not name a type
  189 | constexpr double abs(double j);
      | ^~~~~~~~~
p1339.cpp:189:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:190:1: error: 'constexpr' does not name a type
  190 | constexpr long double abs(long double j);
      | ^~~~~~~~~
p1339.cpp:190:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:191:1: error: 'constexpr' does not name a type
  191 | constexpr float fabs(float x);
      | ^~~~~~~~~
p1339.cpp:191:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:192:1: error: 'constexpr' does not name a type
  192 | constexpr double fabs(double x);
      | ^~~~~~~~~
p1339.cpp:192:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:193:1: error: 'constexpr' does not name a type
  193 | constexpr long double fabs(long double x);
      | ^~~~~~~~~
p1339.cpp:193:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:194:1: error: 'constexpr' does not name a type
  194 | constexpr float fabsf(float x);
      | ^~~~~~~~~
p1339.cpp:194:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:195:1: error: 'constexpr' does not name a type
  195 | constexpr long double fabsl(long double x);
      | ^~~~~~~~~
p1339.cpp:195:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:207:30: error: 'double std::pow(double, double)' conflicts with a previous declaration
  207 | double pow(double x, double y);
      |                              ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:140:1: note: previous declaration 'double pow(double, double'
  140 | __MATHCALL_VEC (pow,, (_Mdouble_ __x, _Mdouble_ __y));
      | ^~~~~~~~~~~~~~
p1339.cpp:213:21: error: 'double std::sqrt(double)' conflicts with a previous declaration
  213 | double sqrt(double x);
      |                     ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:143:1: note: previous declaration 'double sqrt(double)'
  143 | __MATHCALL (sqrt,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:242:1: error: 'constexpr' does not name a type
  242 | constexpr float ceil(float x);
      | ^~~~~~~~~
p1339.cpp:242:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:243:1: error: 'constexpr' does not name a type
  243 | constexpr double ceil(double x);
      | ^~~~~~~~~
p1339.cpp:243:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:244:1: error: 'constexpr' does not name a type
  244 | constexpr long double ceil(long double x);
      | ^~~~~~~~~
p1339.cpp:244:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:245:1: error: 'constexpr' does not name a type
  245 | constexpr float ceilf(float x);
      | ^~~~~~~~~
p1339.cpp:245:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:246:1: error: 'constexpr' does not name a type
  246 | constexpr long double ceill(long double x);
      | ^~~~~~~~~
p1339.cpp:246:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:247:1: error: 'constexpr' does not name a type
  247 | constexpr float floor(float x);
      | ^~~~~~~~~
p1339.cpp:247:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:248:1: error: 'constexpr' does not name a type
  248 | constexpr double floor(double x);
      | ^~~~~~~~~
p1339.cpp:248:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:249:1: error: 'constexpr' does not name a type
  249 | constexpr long double floor(long double x);
      | ^~~~~~~~~
p1339.cpp:249:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:250:1: error: 'constexpr' does not name a type
  250 | constexpr float floorf(float x);
      | ^~~~~~~~~
p1339.cpp:250:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:251:1: error: 'constexpr' does not name a type
  251 | constexpr long double floorl(long double x);
      | ^~~~~~~~~
p1339.cpp:251:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:277:1: error: 'constexpr' does not name a type
  277 | constexpr float round(float x);
      | ^~~~~~~~~
p1339.cpp:277:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:278:1: error: 'constexpr' does not name a type
  278 | constexpr double round(double x);
      | ^~~~~~~~~
p1339.cpp:278:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:279:1: error: 'constexpr' does not name a type
  279 | constexpr long double round(long double x);
      | ^~~~~~~~~
p1339.cpp:279:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:280:1: error: 'constexpr' does not name a type
  280 | constexpr float roundf(float x);
      | ^~~~~~~~~
p1339.cpp:280:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:281:1: error: 'constexpr' does not name a type
  281 | constexpr long double roundl(long double x);
      | ^~~~~~~~~
p1339.cpp:281:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:282:1: error: 'constexpr' does not name a type
  282 | constexpr long int lround(float x);
      | ^~~~~~~~~
p1339.cpp:282:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:283:1: error: 'constexpr' does not name a type
  283 | constexpr long int lround(double x);
      | ^~~~~~~~~
p1339.cpp:283:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:284:1: error: 'constexpr' does not name a type
  284 | constexpr long int lround(long double x);
      | ^~~~~~~~~
p1339.cpp:284:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:285:1: error: 'constexpr' does not name a type
  285 | constexpr long int lroundf(float x);
      | ^~~~~~~~~
p1339.cpp:285:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:286:1: error: 'constexpr' does not name a type
  286 | constexpr long int lroundl(long double x);
      | ^~~~~~~~~
p1339.cpp:286:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:291:1: error: 'constexpr' does not name a type
  291 | constexpr float fmod(float x, float y); //
      | ^~~~~~~~~
p1339.cpp:291:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:292:1: error: 'constexpr' does not name a type
  292 | constexpr double fmod(double x, double y);
      | ^~~~~~~~~
p1339.cpp:292:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:293:1: error: 'constexpr' does not name a type
  293 | constexpr long double fmod(long double x, long double y);
      | ^~~~~~~~~
p1339.cpp:293:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:294:1: error: 'constexpr' does not name a type
  294 | constexpr float fmodf(float x, float y);
      | ^~~~~~~~~
p1339.cpp:294:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:295:1: error: 'constexpr' does not name a type
  295 | constexpr long double fmodl(long double x, long double y);
      | ^~~~~~~~~
p1339.cpp:295:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:296:1: error: 'constexpr' does not name a type
  296 | constexpr float remainder(float x, float y); // see 16.2
      | ^~~~~~~~~
p1339.cpp:296:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:297:1: error: 'constexpr' does not name a type
  297 | constexpr double remainder(double x, double y);
      | ^~~~~~~~~
p1339.cpp:297:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:298:1: error: 'constexpr' does not name a type
  298 | constexpr long double remainder(long double x, long double y);
      | ^~~~~~~~~
p1339.cpp:298:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:299:1: error: 'constexpr' does not name a type
  299 | constexpr float remainderf(float x, float y);
      | ^~~~~~~~~
p1339.cpp:299:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:300:1: error: 'constexpr' does not name a type
  300 | constexpr long double remainderl(long double x, long double y);
      | ^~~~~~~~~
p1339.cpp:300:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:301:1: error: 'constexpr' does not name a type
  301 | constexpr float remquo(float x, float y, int* quo); // see 16.2
      | ^~~~~~~~~
p1339.cpp:301:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:302:1: error: 'constexpr' does not name a type
  302 | constexpr double remquo(double x, double y, int* quo);
      | ^~~~~~~~~
p1339.cpp:302:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:303:1: error: 'constexpr' does not name a type
  303 | constexpr long double remquo(long double x, long double y, int* quo); constexpr float remquof(float x, float y, int* quo);
      | ^~~~~~~~~
p1339.cpp:303:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:303:71: error: 'constexpr' does not name a type
  303 | constexpr long double remquo(long double x, long double y, int* quo); constexpr float remquof(float x, float y, int* quo);
      |                                                                       ^~~~~~~~~
p1339.cpp:303:71: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:304:1: error: 'constexpr' does not name a type
  304 | constexpr long double remquol(long double x, long double y, int* quo);
      | ^~~~~~~~~
p1339.cpp:304:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:305:1: error: 'constexpr' does not name a type
  305 | constexpr long long int llround(float x);
      | ^~~~~~~~~
p1339.cpp:305:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:306:1: error: 'constexpr' does not name a type
  306 | constexpr long long int llround(double x);
      | ^~~~~~~~~
p1339.cpp:306:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:307:1: error: 'constexpr' does not name a type
  307 | constexpr long long int llround(long double x);
      | ^~~~~~~~~
p1339.cpp:307:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:308:1: error: 'constexpr' does not name a type
  308 | constexpr long long int llroundf(float x);
      | ^~~~~~~~~
p1339.cpp:308:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:309:1: error: 'constexpr' does not name a type
  309 | constexpr long long int llroundl(long double x);
      | ^~~~~~~~~
p1339.cpp:309:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:310:1: error: 'constexpr' does not name a type
  310 | constexpr float trunc(float x); //
      | ^~~~~~~~~
p1339.cpp:310:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:311:1: error: 'constexpr' does not name a type
  311 | constexpr double trunc(double x);
      | ^~~~~~~~~
p1339.cpp:311:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:312:1: error: 'constexpr' does not name a type
  312 | constexpr long double trunc(long double x); //
      | ^~~~~~~~~
p1339.cpp:312:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:313:1: error: 'constexpr' does not name a type
  313 | constexpr float truncf(float x);
      | ^~~~~~~~~
p1339.cpp:313:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:314:1: error: 'constexpr' does not name a type
  314 | constexpr long double truncl(long double x);
      | ^~~~~~~~~
p1339.cpp:314:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:315:1: error: 'constexpr' does not name a type
  315 | constexpr float copysign(float x, float y); // see 16.2
      | ^~~~~~~~~
p1339.cpp:315:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:316:1: error: 'constexpr' does not name a type
  316 | constexpr double copysign(double x, double y);
      | ^~~~~~~~~
p1339.cpp:316:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:317:1: error: 'constexpr' does not name a type
  317 | constexpr long double copysign(long double x, long double y);
      | ^~~~~~~~~
p1339.cpp:317:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:318:1: error: 'constexpr' does not name a type
  318 | constexpr float copysignf(float x, float y);
      | ^~~~~~~~~
p1339.cpp:318:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:319:1: error: 'constexpr' does not name a type
  319 | constexpr long double copysignl(long double x, long double y);
      | ^~~~~~~~~
p1339.cpp:319:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:328:1: error: 'constexpr' does not name a type
  328 | constexpr float nextafter(float x, float y); // see 16.2
      | ^~~~~~~~~
p1339.cpp:328:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:329:1: error: 'constexpr' does not name a type
  329 | constexpr double nextafter(double x, double y);
      | ^~~~~~~~~
p1339.cpp:329:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:330:1: error: 'constexpr' does not name a type
  330 | constexpr long double nextafter(long double x, long double y);
      | ^~~~~~~~~
p1339.cpp:330:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:331:1: error: 'constexpr' does not name a type
  331 | constexpr float nextafterf(float x, float y);
      | ^~~~~~~~~
p1339.cpp:331:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:332:1: error: 'constexpr' does not name a type
  332 | constexpr long double nextafterl(long double x, long double y);
      | ^~~~~~~~~
p1339.cpp:332:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:334:1: error: 'constexpr' does not name a type
  334 | constexpr float nexttoward(float x, long double y); // see 16.2
      | ^~~~~~~~~
p1339.cpp:334:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:335:1: error: 'constexpr' does not name a type
  335 | constexpr double nexttoward(double x, long double y);
      | ^~~~~~~~~
p1339.cpp:335:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:336:1: error: 'constexpr' does not name a type
  336 | constexpr long double nexttoward(long double x, long double y);
      | ^~~~~~~~~
p1339.cpp:336:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:337:1: error: 'constexpr' does not name a type
  337 | constexpr float nexttowardf(float x, long double y);
      | ^~~~~~~~~
p1339.cpp:337:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:338:1: error: 'constexpr' does not name a type
  338 | constexpr long double nexttowardl(long double x, long double y);
      | ^~~~~~~~~
p1339.cpp:338:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:340:1: error: 'constexpr' does not name a type
  340 | constexpr float fdim(float x, float y); // see 16.2
      | ^~~~~~~~~
p1339.cpp:340:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:341:1: error: 'constexpr' does not name a type
  341 | constexpr double fdim(double x, double y);
      | ^~~~~~~~~
p1339.cpp:341:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:342:1: error: 'constexpr' does not name a type
  342 | constexpr long double fdim(long double x, long double y);
      | ^~~~~~~~~
p1339.cpp:342:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:343:1: error: 'constexpr' does not name a type
  343 | constexpr float fdimf(float x, float y);
      | ^~~~~~~~~
p1339.cpp:343:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:344:1: error: 'constexpr' does not name a type
  344 | constexpr long double fdiml(long double x, long double y);
      | ^~~~~~~~~
p1339.cpp:344:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:345:1: error: 'constexpr' does not name a type
  345 | constexpr float fmax(float x, float y); // see 16.2
      | ^~~~~~~~~
p1339.cpp:345:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:346:1: error: 'constexpr' does not name a type
  346 | constexpr double fmax(double x, double y);
      | ^~~~~~~~~
p1339.cpp:346:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:347:1: error: 'constexpr' does not name a type
  347 | constexpr long double fmax(long double x, long double y);
      | ^~~~~~~~~
p1339.cpp:347:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:348:1: error: 'constexpr' does not name a type
  348 | constexpr float fmaxf(float x, float y);
      | ^~~~~~~~~
p1339.cpp:348:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:349:1: error: 'constexpr' does not name a type
  349 | constexpr long double fmaxl(long double x, long double y);
      | ^~~~~~~~~
p1339.cpp:349:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:350:1: error: 'constexpr' does not name a type
  350 | constexpr float fmin(float x, float y); // see 16.2
      | ^~~~~~~~~
p1339.cpp:350:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:351:1: error: 'constexpr' does not name a type
  351 | constexpr double fmin(double x, double y);
      | ^~~~~~~~~
p1339.cpp:351:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:352:1: error: 'constexpr' does not name a type
  352 | constexpr long double fmin(long double x, long double y);
      | ^~~~~~~~~
p1339.cpp:352:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:353:1: error: 'constexpr' does not name a type
  353 | constexpr float fminf(float x, float y);
      | ^~~~~~~~~
p1339.cpp:353:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:354:1: error: 'constexpr' does not name a type
  354 | constexpr long double fminl(long double x, long double y);
      | ^~~~~~~~~
p1339.cpp:354:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:358:1: error: 'constexpr' does not name a type
  358 | constexpr float fma(float x, float y, float z); // see 16.2
      | ^~~~~~~~~
p1339.cpp:358:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:359:1: error: 'constexpr' does not name a type
  359 | constexpr double fma(double x, double y, double z);
      | ^~~~~~~~~
p1339.cpp:359:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:360:1: error: 'constexpr' does not name a type
  360 | constexpr long double fma(long double x, long double y, long double z); constexpr float fmaf(float x, float y, float z);
      | ^~~~~~~~~
p1339.cpp:360:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:360:73: error: 'constexpr' does not name a type
  360 | constexpr long double fma(long double x, long double y, long double z); constexpr float fmaf(float x, float y, float z);
      |                                                                         ^~~~~~~~~
p1339.cpp:360:73: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:361:1: error: 'constexpr' does not name a type
  361 | constexpr long double fmal(long double x, long double y, long double z);
      | ^~~~~~~~~
p1339.cpp:361:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:364:1: error: 'constexpr' does not name a type
  364 | constexpr float lerp(float a, float b, float t) noexcept;
      | ^~~~~~~~~
p1339.cpp:364:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:365:1: error: 'constexpr' does not name a type
  365 | constexpr double lerp(double a, double b, double t) noexcept;
      | ^~~~~~~~~
p1339.cpp:365:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:366:1: error: 'constexpr' does not name a type
  366 | constexpr long double lerp(long double a, long double b, long double t) noexcept;
      | ^~~~~~~~~
p1339.cpp:366:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:368:1: error: 'constexpr' does not name a type
  368 | constexpr int fpclassify(float x);
      | ^~~~~~~~~
p1339.cpp:368:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:369:1: error: 'constexpr' does not name a type
  369 | constexpr int fpclassify(double x);
      | ^~~~~~~~~
p1339.cpp:369:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:370:1: error: 'constexpr' does not name a type
  370 | constexpr int fpclassify(long double x);
      | ^~~~~~~~~
p1339.cpp:370:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:371:1: error: 'constexpr' does not name a type
  371 | constexpr bool isfinite(float x);
      | ^~~~~~~~~
p1339.cpp:371:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:372:1: error: 'constexpr' does not name a type
  372 | constexpr bool isfinite(double x);
      | ^~~~~~~~~
p1339.cpp:372:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:373:1: error: 'constexpr' does not name a type
  373 | constexpr bool isfinite(long double x);
      | ^~~~~~~~~
p1339.cpp:373:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:374:1: error: 'constexpr' does not name a type
  374 | constexpr bool isinf(float x);
      | ^~~~~~~~~
p1339.cpp:374:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:375:1: error: 'constexpr' does not name a type
  375 | constexpr bool isinf(double x);
      | ^~~~~~~~~
p1339.cpp:375:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:376:1: error: 'constexpr' does not name a type
  376 | constexpr bool isinf(long double x);
      | ^~~~~~~~~
p1339.cpp:376:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:377:1: error: 'constexpr' does not name a type
  377 | constexpr bool isnan(float x);
      | ^~~~~~~~~
p1339.cpp:377:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:378:1: error: 'constexpr' does not name a type
  378 | constexpr bool isnan(double x);
      | ^~~~~~~~~
p1339.cpp:378:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:379:1: error: 'constexpr' does not name a type
  379 | constexpr bool isnan(long double x);
      | ^~~~~~~~~
p1339.cpp:379:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:380:1: error: 'constexpr' does not name a type
  380 | constexpr bool isnormal(float x);
      | ^~~~~~~~~
p1339.cpp:380:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:381:1: error: 'constexpr' does not name a type
  381 | constexpr bool isnormal(double x);
      | ^~~~~~~~~
p1339.cpp:381:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:382:1: error: 'constexpr' does not name a type
  382 | constexpr bool isnormal(long double x);
      | ^~~~~~~~~
p1339.cpp:382:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:383:1: error: 'constexpr' does not name a type
  383 | constexpr bool signbit(float x);
      | ^~~~~~~~~
p1339.cpp:383:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:384:1: error: 'constexpr' does not name a type
  384 | constexpr bool signbit(double x);
      | ^~~~~~~~~
p1339.cpp:384:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:385:1: error: 'constexpr' does not name a type
  385 | constexpr bool signbit(long double x);
      | ^~~~~~~~~
p1339.cpp:385:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:386:1: error: 'constexpr' does not name a type
  386 | constexpr bool isgreater(float x, float y);
      | ^~~~~~~~~
p1339.cpp:386:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:387:1: error: 'constexpr' does not name a type
  387 | constexpr bool isgreater(double x, double y);
      | ^~~~~~~~~
p1339.cpp:387:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:388:1: error: 'constexpr' does not name a type
  388 | constexpr bool isgreater(long double x, long double y);
      | ^~~~~~~~~
p1339.cpp:388:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:389:1: error: 'constexpr' does not name a type
  389 | constexpr bool isgreaterequal(float x, float y);
      | ^~~~~~~~~
p1339.cpp:389:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:390:1: error: 'constexpr' does not name a type
  390 | constexpr bool isgreaterequal(double x, double y);
      | ^~~~~~~~~
p1339.cpp:390:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:391:1: error: 'constexpr' does not name a type
  391 | constexpr bool isgreaterequal(long double x, long double y);
      | ^~~~~~~~~
p1339.cpp:391:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:392:1: error: 'constexpr' does not name a type
  392 | constexpr bool isless(float x, float y);
      | ^~~~~~~~~
p1339.cpp:392:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:393:1: error: 'constexpr' does not name a type
  393 | constexpr bool isless(double x, double y);
      | ^~~~~~~~~
p1339.cpp:393:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:394:1: error: 'constexpr' does not name a type
  394 | constexpr bool isless(long double x, long double y);
      | ^~~~~~~~~
p1339.cpp:394:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:395:1: error: 'constexpr' does not name a type
  395 | constexpr bool islessequal(float x, float y);
      | ^~~~~~~~~
p1339.cpp:395:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:396:1: error: 'constexpr' does not name a type
  396 | constexpr bool islessequal(double x, double y);
      | ^~~~~~~~~
p1339.cpp:396:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:397:1: error: 'constexpr' does not name a type
  397 | constexpr bool islessequal(long double x, long double y);
      | ^~~~~~~~~
p1339.cpp:397:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:398:1: error: 'constexpr' does not name a type
  398 | constexpr bool islessgreater(float x, float y);
      | ^~~~~~~~~
p1339.cpp:398:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:399:1: error: 'constexpr' does not name a type
  399 | constexpr bool islessgreater(double x, double y);
      | ^~~~~~~~~
p1339.cpp:399:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:400:1: error: 'constexpr' does not name a type
  400 | constexpr bool islessgreater(long double x, long double y);
      | ^~~~~~~~~
p1339.cpp:400:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:401:1: error: 'constexpr' does not name a type
  401 | constexpr bool isunordered(float x, float y);
      | ^~~~~~~~~
p1339.cpp:401:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:402:1: error: 'constexpr' does not name a type
  402 | constexpr bool isunordered(double x, double y);
      | ^~~~~~~~~
p1339.cpp:402:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:403:1: error: 'constexpr' does not name a type
  403 | constexpr bool isunordered(long double x, long double y);
      | ^~~~~~~~~
p1339.cpp:403:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:499:6: error: 'constexpr' does not name a type
  499 |      constexpr int abs(int j);
      |      ^~~~~~~~~
p1339.cpp:499:6: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:500:6: error: 'constexpr' does not name a type
  500 |      constexpr long int abs(long int j);
      |      ^~~~~~~~~
p1339.cpp:500:6: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:501:6: error: 'constexpr' does not name a type
  501 |      constexpr long long int abs(long long int j);
      |      ^~~~~~~~~
p1339.cpp:501:6: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:502:6: error: 'constexpr' does not name a type
  502 |      constexpr float abs(float j);
      |      ^~~~~~~~~
p1339.cpp:502:6: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:503:6: error: 'constexpr' does not name a type
  503 |      constexpr double abs(double j);
      |      ^~~~~~~~~
p1339.cpp:503:6: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:504:6: error: 'constexpr' does not name a type
  504 |      constexpr long double abs(long double j);
      |      ^~~~~~~~~
p1339.cpp:504:6: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:519:1: error: 'constexpr' does not name a type
  519 | constexpr float lerp(float a, float b, float t) noexcept;
      | ^~~~~~~~~
p1339.cpp:519:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:520:1: error: 'constexpr' does not name a type
  520 | constexpr double lerp(double a, double b, double t) noexcept;
      | ^~~~~~~~~
p1339.cpp:520:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:521:1: error: 'constexpr' does not name a type
  521 | constexpr long double lerp(long double a, long double b, long double t) noexcept;
      | ^~~~~~~~~
p1339.cpp:521:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1339.cpp:542:56: error: 't' does not name a type; did you mean 'tm'?
  542 | float assoc_laguerref(unsigned n, unsigned m, float x);t
      |                                                        ^
      |                                                        tm

$ g++ p1339.cpp -std=2b -o p1339g -I. -Wall
p1339.cpp:16:17: error: 'see_below' does not name a type
   16 | using float_t = see_below;
      |                 ^~~~~~~~~
p1339.cpp:17:18: error: 'see_below' does not name a type
   17 | using double_t = see_below;
      |                  ^~~~~~~~~
p1339.cpp:20:7: error: redeclaration 'float std::acos(float)' differs in 'constexpr' from previous declaration
   20 | float acos(float x); // see 16.2
      |       ^~~~
In file included from /usr/local/include/c++/12.1.0/complex:44,
                 from N4910.h:9,
                 from p1339.cpp:10:
/usr/local/include/c++/12.1.0/cmath:87:3: note: previous declaration 'constexpr float std::acos(float)'
   87 |   acos(float __x)
      |   ^~~~
p1339.cpp:21:21: error: 'double std::acos(double)' conflicts with a previous declaration
   21 | double acos(double x);
      |                     ^
In file included from /usr/include/features.h:461,
                 from /usr/local/include/c++/12.1.0/x86_64-linux-gnu/bits/os_defines.h:39,
                 from /usr/local/include/c++/12.1.0/x86_64-linux-gnu/bits/c++config.h:655,
                 from /usr/local/include/c++/12.1.0/cstddef:49,
                 from N4910.h:1:
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:53:1: note: previous declaration 'double acos(double)'
   53 | __MATHCALL (acos,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:22:13: error: redeclaration 'long double std::acos(long double)' differs in 'constexpr' from previous declaration
   22 | long double acos(long double x);
      |             ^~~~
/usr/local/include/c++/12.1.0/cmath:91:3: note: previous declaration 'constexpr long double std::acos(long double)'
   91 |   acos(long double __x)
      |   ^~~~
p1339.cpp:25:7: error: redeclaration 'float std::asin(float)' differs in 'constexpr' from previous declaration
   25 | float asin(float x); // see 16.2
      |       ^~~~
/usr/local/include/c++/12.1.0/cmath:106:3: note: previous declaration 'constexpr float std::asin(float)'
  106 |   asin(float __x)
      |   ^~~~
p1339.cpp:26:21: error: 'double std::asin(double)' conflicts with a previous declaration
   26 | double asin(double x);
      |                     ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:55:1: note: previous declaration 'double asin(double)'
   55 | __MATHCALL (asin,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:27:13: error: redeclaration 'long double std::asin(long double)' differs in 'constexpr' from previous declaration
   27 | long double asin(long double x); float asinf(float x);
      |             ^~~~
/usr/local/include/c++/12.1.0/cmath:110:3: note: previous declaration 'constexpr long double std::asin(long double)'
  110 |   asin(long double __x)
      |   ^~~~
p1339.cpp:29:9: error: redeclaration 'float std::atan(float)' differs in 'constexpr' from previous declaration
   29 |   float atan(float x);
      |         ^~~~
/usr/local/include/c++/12.1.0/cmath:125:3: note: previous declaration 'constexpr float std::atan(float)'
  125 |   atan(float __x)
      |   ^~~~
p1339.cpp:30:23: error: 'double std::atan(double)' conflicts with a previous declaration
   30 |   double atan(double x);
      |                       ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:57:1: note: previous declaration 'double atan(double)'
   57 | __MATHCALL (atan,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:31:15: error: redeclaration 'long double std::atan(long double)' differs in 'constexpr' from previous declaration
   31 |   long double atan(long double x);
      |               ^~~~
/usr/local/include/c++/12.1.0/cmath:129:3: note: previous declaration 'constexpr long double std::atan(long double)'
  129 |   atan(long double __x)
      |   ^~~~
p1339.cpp:34:7: error: redeclaration 'float std::atan2(float, float)' differs in 'constexpr' from previous declaration
   34 | float atan2(float y, float x);
      |       ^~~~~
/usr/local/include/c++/12.1.0/cmath:144:3: note: previous declaration 'constexpr float std::atan2(float, float)'
  144 |   atan2(float __y, float __x)
      |   ^~~~~
p1339.cpp:35:32: error: 'double std::atan2(double, double)' conflicts with a previous declaration
   35 | double atan2(double y, double x);
      |                                ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:59:1: note: previous declaration 'double atan2(double, double)'
   59 | __MATHCALL (atan2,, (_Mdouble_ __y, _Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:36:13: error: redeclaration 'long double std::atan2(long double, long double)' differs in 'constexpr' from previous declaration
   36 | long double atan2(long double y, long double x); // see 16.2
      |             ^~~~~
/usr/local/include/c++/12.1.0/cmath:148:3: note: previous declaration 'constexpr long double std::atan2(long double, long double)'
  148 |   atan2(long double __y, long double __x)
      |   ^~~~~
p1339.cpp:39:7: error: redeclaration 'float std::cos(float)' differs in 'constexpr' from previous declaration
   39 | float cos(float x);
      |       ^~~
/usr/local/include/c++/12.1.0/cmath:184:3: note: previous declaration 'constexpr float std::cos(float)'
  184 |   cos(float __x)
      |   ^~~
p1339.cpp:40:20: error: 'double std::cos(double)' conflicts with a previous declaration
   40 | double cos(double x);
      |                    ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:62:1: note: previous declaration 'double cos(double)'
   62 | __MATHCALL_VEC (cos,, (_Mdouble_ __x));
      | ^~~~~~~~~~~~~~
p1339.cpp:41:13: error: redeclaration 'long double std::cos(long double)' differs in 'constexpr' from previous declaration
   41 | long double cos(long double x);
      |             ^~~
/usr/local/include/c++/12.1.0/cmath:188:3: note: previous declaration 'constexpr long double std::cos(long double)'
  188 |   cos(long double __x)
      |   ^~~
p1339.cpp:44:7: error: redeclaration 'float std::sin(float)' differs in 'constexpr' from previous declaration
   44 | float sin(float x);
      |       ^~~
/usr/local/include/c++/12.1.0/cmath:425:3: note: previous declaration 'constexpr float std::sin(float)'
  425 |   sin(float __x)
      |   ^~~
p1339.cpp:45:20: error: 'double std::sin(double)' conflicts with a previous declaration
   45 | double sin(double x);
      |                    ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:64:1: note: previous declaration 'double sin(double)'
   64 | __MATHCALL_VEC (sin,, (_Mdouble_ __x));
      | ^~~~~~~~~~~~~~
p1339.cpp:46:13: error: redeclaration 'long double std::sin(long double)' differs in 'constexpr' from previous declaration
   46 | long double sin(long double x);
      |             ^~~
/usr/local/include/c++/12.1.0/cmath:429:3: note: previous declaration 'constexpr long double std::sin(long double)'
  429 |   sin(long double __x)
      |   ^~~
p1339.cpp:49:7: error: redeclaration 'float std::tan(float)' differs in 'constexpr' from previous declaration
   49 | float tan(float x);
      |       ^~~
/usr/local/include/c++/12.1.0/cmath:482:3: note: previous declaration 'constexpr float std::tan(float)'
  482 |   tan(float __x)
      |   ^~~
p1339.cpp:50:20: error: 'double std::tan(double)' conflicts with a previous declaration
   50 | double tan(double x);
      |                    ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:66:1: note: previous declaration 'double tan(double)'
   66 | __MATHCALL (tan,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:51:13: error: redeclaration 'long double std::tan(long double)' differs in 'constexpr' from previous declaration
   51 | long double tan(long double x);
      |             ^~~
/usr/local/include/c++/12.1.0/cmath:486:3: note: previous declaration 'constexpr long double std::tan(long double)'
  486 |   tan(long double __x)
      |   ^~~
p1339.cpp:54:7: error: redeclaration 'float std::acosh(float)' differs in 'constexpr' from previous declaration
   54 | float acosh(float x);
      |       ^~~~~
/usr/local/include/c++/12.1.0/cmath:1214:3: note: previous declaration 'constexpr float std::acosh(float)'
 1214 |   acosh(float __x)
      |   ^~~~~
p1339.cpp:55:22: error: 'double std::acosh(double)' conflicts with a previous declaration
   55 | double acosh(double x);
      |                      ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:85:1: note: previous declaration 'double acosh(double)'
   85 | __MATHCALL (acosh,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:56:13: error: redeclaration 'long double std::acosh(long double)' differs in 'constexpr' from previous declaration
   56 | long double acosh(long double x);
      |             ^~~~~
/usr/local/include/c++/12.1.0/cmath:1218:3: note: previous declaration 'constexpr long double std::acosh(long double)'
 1218 |   acosh(long double __x)
      |   ^~~~~
p1339.cpp:57:21: error: 'float std::acoshf(float)' conflicts with a previous declaration
   57 | float acoshf(float x);
      |                     ^
In file included from /usr/local/include/c++/12.1.0/cmath:45:
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:85:1: note: previous declaration 'float acoshf(float)'
   85 | __MATHCALL (acosh,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:58:33: error: 'long double std::acoshl(long double)' conflicts with a previous declaration
   58 | long double acoshl(long double x);
      |                                 ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:85:1: note: previous declaration 'long double acoshl(long double)'
   85 | __MATHCALL (acosh,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:59:7: error: redeclaration 'float std::asinh(float)' differs in 'constexpr' from previous declaration
   59 | float asinh(float x);
      |       ^~~~~
/usr/local/include/c++/12.1.0/cmath:1232:3: note: previous declaration 'constexpr float std::asinh(float)'
 1232 |   asinh(float __x)
      |   ^~~~~
p1339.cpp:60:22: error: 'double std::asinh(double)' conflicts with a previous declaration
   60 | double asinh(double x);
      |                      ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:87:1: note: previous declaration 'double asinh(double)'
   87 | __MATHCALL (asinh,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:61:13: error: redeclaration 'long double std::asinh(long double)' differs in 'constexpr' from previous declaration
   61 | long double asinh(long double x);
      |             ^~~~~
/usr/local/include/c++/12.1.0/cmath:1236:3: note: previous declaration 'constexpr long double std::asinh(long double)'
 1236 |   asinh(long double __x)
      |   ^~~~~
p1339.cpp:62:21: error: 'float std::asinhf(float)' conflicts with a previous declaration
   62 | float asinhf(float x);
      |                     ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:87:1: note: previous declaration 'float asinhf(float)'
   87 | __MATHCALL (asinh,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:63:33: error: 'long double std::asinhl(long double)' conflicts with a previous declaration
   63 | long double asinhl(long double x);
      |                                 ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:87:1: note: previous declaration 'long double asinhl(long double)'
   87 | __MATHCALL (asinh,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:64:7: error: redeclaration 'float std::atanh(float)' differs in 'constexpr' from previous declaration
   64 | float atanh(float x);
      |       ^~~~~
/usr/local/include/c++/12.1.0/cmath:1250:3: note: previous declaration 'constexpr float std::atanh(float)'
 1250 |   atanh(float __x)
      |   ^~~~~
p1339.cpp:65:22: error: 'double std::atanh(double)' conflicts with a previous declaration
   65 | double atanh(double x);
      |                      ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:89:1: note: previous declaration 'double atanh(double)'
   89 | __MATHCALL (atanh,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:66:13: error: redeclaration 'long double std::atanh(long double)' differs in 'constexpr' from previous declaration
   66 | long double atanh(long double x);
      |             ^~~~~
/usr/local/include/c++/12.1.0/cmath:1254:3: note: previous declaration 'constexpr long double std::atanh(long double)'
 1254 |   atanh(long double __x)
      |   ^~~~~
p1339.cpp:67:21: error: 'float std::atanhf(float)' conflicts with a previous declaration
   67 | float atanhf(float x);
      |                     ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:89:1: note: previous declaration 'float atanhf(float)'
   89 | __MATHCALL (atanh,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:68:33: error: 'long double std::atanhl(long double)' conflicts with a previous declaration
   68 | long double atanhl(long double x);
      |                                 ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:89:1: note: previous declaration 'long double atanhl(long double)'
   89 | __MATHCALL (atanh,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:69:7: error: redeclaration 'float std::cosh(float)' differs in 'constexpr' from previous declaration
   69 | float cosh(float x);
      |       ^~~~
/usr/local/include/c++/12.1.0/cmath:203:3: note: previous declaration 'constexpr float std::cosh(float)'
  203 |   cosh(float __x)
      |   ^~~~
p1339.cpp:70:21: error: 'double std::cosh(double)' conflicts with a previous declaration
   70 | double cosh(double x);
      |                     ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:71:1: note: previous declaration 'double cosh(double)'
   71 | __MATHCALL (cosh,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:71:13: error: redeclaration 'long double std::cosh(long double)' differs in 'constexpr' from previous declaration
   71 | long double cosh(long double x);
      |             ^~~~
/usr/local/include/c++/12.1.0/cmath:207:3: note: previous declaration 'constexpr long double std::cosh(long double)'
  207 |   cosh(long double __x)
      |   ^~~~
p1339.cpp:85:7: error: redeclaration 'float std::sinh(float)' differs in 'constexpr' from previous declaration
   85 | float sinh(float x);
      |       ^~~~
/usr/local/include/c++/12.1.0/cmath:444:3: note: previous declaration 'constexpr float std::sinh(float)'
  444 |   sinh(float __x)
      |   ^~~~
p1339.cpp:86:21: error: 'double std::sinh(double)' conflicts with a previous declaration
   86 | double sinh(double x);
      |                     ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:73:1: note: previous declaration 'double sinh(double)'
   73 | __MATHCALL (sinh,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:87:13: error: redeclaration 'long double std::sinh(long double)' differs in 'constexpr' from previous declaration
   87 | long double sinh(long double x);
      |             ^~~~
/usr/local/include/c++/12.1.0/cmath:448:3: note: previous declaration 'constexpr long double std::sinh(long double)'
  448 |   sinh(long double __x)
      |   ^~~~
p1339.cpp:90:7: error: redeclaration 'float std::tanh(float)' differs in 'constexpr' from previous declaration
   90 | float tanh(float x);
      |       ^~~~
/usr/local/include/c++/12.1.0/cmath:501:3: note: previous declaration 'constexpr float std::tanh(float)'
  501 |   tanh(float __x)
      |   ^~~~
p1339.cpp:91:21: error: 'double std::tanh(double)' conflicts with a previous declaration
   91 | double tanh(double x);
      |                     ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:75:1: note: previous declaration 'double tanh(double)'
   75 | __MATHCALL (tanh,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:92:13: error: redeclaration 'long double std::tanh(long double)' differs in 'constexpr' from previous declaration
   92 | long double tanh(long double x);
      |             ^~~~
/usr/local/include/c++/12.1.0/cmath:505:3: note: previous declaration 'constexpr long double std::tanh(long double)'
  505 |   tanh(long double __x)
      |   ^~~~
p1339.cpp:95:7: error: redeclaration 'float std::exp(float)' differs in 'constexpr' from previous declaration
   95 | float exp(float x);
      |       ^~~
/usr/local/include/c++/12.1.0/cmath:222:3: note: previous declaration 'constexpr float std::exp(float)'
  222 |   exp(float __x)
      |   ^~~
p1339.cpp:96:20: error: 'double std::exp(double)' conflicts with a previous declaration
   96 | double exp(double x);
      |                    ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:95:1: note: previous declaration 'double exp(double)'
   95 | __MATHCALL_VEC (exp,, (_Mdouble_ __x));
      | ^~~~~~~~~~~~~~
p1339.cpp:97:13: error: redeclaration 'long double std::exp(long double)' differs in 'constexpr' from previous declaration
   97 | long double exp(long double x);
      |             ^~~
/usr/local/include/c++/12.1.0/cmath:226:3: note: previous declaration 'constexpr long double std::exp(long double)'
  226 |   exp(long double __x)
      |   ^~~
p1339.cpp:100:7: error: redeclaration 'float std::exp2(float)' differs in 'constexpr' from previous declaration
  100 | float exp2(float x);
      |       ^~~~
/usr/local/include/c++/12.1.0/cmath:1342:3: note: previous declaration 'constexpr float std::exp2(float)'
 1342 |   exp2(float __x)
      |   ^~~~
p1339.cpp:101:21: error: 'double std::exp2(double)' conflicts with a previous declaration
  101 | double exp2(double x);
      |                     ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:130:1: note: previous declaration 'double exp2(double)'
  130 | __MATHCALL (exp2,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:102:13: error: redeclaration 'long double std::exp2(long double)' differs in 'constexpr' from previous declaration
  102 | long double exp2(long double x);
      |             ^~~~
/usr/local/include/c++/12.1.0/cmath:1346:3: note: previous declaration 'constexpr long double std::exp2(long double)'
 1346 |   exp2(long double __x)
      |   ^~~~
p1339.cpp:103:20: error: 'float std::exp2f(float)' conflicts with a previous declaration
  103 | float exp2f(float x);
      |                    ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:130:1: note: previous declaration 'float exp2f(float)'
  130 | __MATHCALL (exp2,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:104:32: error: 'long double std::exp2l(long double)' conflicts with a previous declaration
  104 | long double exp2l(long double x);
      |                                ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:130:1: note: previous declaration 'long double exp2l(long double)'
  130 | __MATHCALL (exp2,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:105:7: error: redeclaration 'float std::expm1(float)' differs in 'constexpr' from previous declaration
  105 | float expm1(float x);
      |       ^~~~~
/usr/local/include/c++/12.1.0/cmath:1360:3: note: previous declaration 'constexpr float std::expm1(float)'
 1360 |   expm1(float __x)
      |   ^~~~~
p1339.cpp:106:22: error: 'double std::expm1(double)' conflicts with a previous declaration
  106 | double expm1(double x);
      |                      ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:119:1: note: previous declaration 'double expm1(double)'
  119 | __MATHCALL (expm1,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:107:13: error: redeclaration 'long double std::expm1(long double)' differs in 'constexpr' from previous declaration
  107 | long double expm1(long double x);
      |             ^~~~~
/usr/local/include/c++/12.1.0/cmath:1364:3: note: previous declaration 'constexpr long double std::expm1(long double)'
 1364 |   expm1(long double __x)
      |   ^~~~~
p1339.cpp:108:21: error: 'float std::expm1f(float)' conflicts with a previous declaration
  108 | float expm1f(float x);
      |                     ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:119:1: note: previous declaration 'float expm1f(float)'
  119 | __MATHCALL (expm1,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:109:33: error: 'long double std::expm1l(long double)' conflicts with a previous declaration
  109 | long double expm1l(long double x);
      |                                 ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:119:1: note: previous declaration 'long double expm1l(long double)'
  119 | __MATHCALL (expm1,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:115:17: error: redeclaration 'constexpr float std::frexp(float, int*)' differs in 'constexpr' from previous declaration
  115 | constexpr float frexp(float value, int* exp);
      |                 ^~~~~
/usr/local/include/c++/12.1.0/cmath:300:3: note: previous declaration 'float std::frexp(float, int*)'
  300 |   frexp(float __x, int* __exp)
      |   ^~~~~
p1339.cpp:116:46: error: 'constexpr double std::frexp(double, int*)' conflicts with a previous declaration
  116 | constexpr double frexp(double value, int* exp);
      |                                              ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:98:1: note: previous declaration 'double frexp(double, int*)'
   98 | __MATHCALL (frexp,, (_Mdouble_ __x, int *__exponent));
      | ^~~~~~~~~~
p1339.cpp:117:23: error: redeclaration 'constexpr long double std::frexp(long double, int*)' differs in 'constexpr' from previous declaration
  117 | constexpr long double frexp(long double value, int* exp); // see 16.2
      |                       ^~~~~
/usr/local/include/c++/12.1.0/cmath:304:3: note: previous declaration 'long double std::frexp(long double, int*)'
  304 |   frexp(long double __x, int* __exp)
      |   ^~~~~
p1339.cpp:121:29: error: 'constexpr int std::ilogb(double)' conflicts with a previous declaration
  121 | constexpr int ilogb(double x);
      |                             ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:280:1: note: previous declaration 'int ilogb(double)'
  280 | __MATHDECL (int,ilogb,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:123:29: error: 'constexpr int std::ilogbf(float)' conflicts with a previous declaration
  123 | constexpr int ilogbf(float x);
      |                             ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:280:1: note: previous declaration 'int ilogbf(float)'
  280 | __MATHDECL (int,ilogb,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:124:35: error: 'constexpr int std::ilogbl(long double)' conflicts with a previous declaration
  124 | constexpr int ilogbl(long double x);
      |                                   ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:280:1: note: previous declaration 'int ilogbl(long double)'
  280 | __MATHDECL (int,ilogb,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:126:41: error: 'constexpr double std::ldexp(double, int)' conflicts with a previous declaration
  126 | constexpr double ldexp(double x, int exp);
      |                                         ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:101:1: note: previous declaration 'double ldexp(double, int)'
  101 | __MATHCALL (ldexp,, (_Mdouble_ __x, int __exponent));
      | ^~~~~~~~~~
p1339.cpp:130:7: error: redeclaration 'float std::log(float)' differs in 'constexpr' from previous declaration
  130 | float log(float x);
      |       ^~~
/usr/local/include/c++/12.1.0/cmath:338:3: note: previous declaration 'constexpr float std::log(float)'
  338 |   log(float __x)
      |   ^~~
p1339.cpp:131:20: error: 'double std::log(double)' conflicts with a previous declaration
  131 | double log(double x);
      |                    ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:104:1: note: previous declaration 'double log(double)'
  104 | __MATHCALL_VEC (log,, (_Mdouble_ __x));
      | ^~~~~~~~~~~~~~
p1339.cpp:132:13: error: redeclaration 'long double std::log(long double)' differs in 'constexpr' from previous declaration
  132 | long double log(long double x);
      |             ^~~
/usr/local/include/c++/12.1.0/cmath:342:3: note: previous declaration 'constexpr long double std::log(long double)'
  342 |   log(long double __x)
      |   ^~~
p1339.cpp:135:7: error: redeclaration 'float std::log10(float)' differs in 'constexpr' from previous declaration
  135 | float log10(float x);
      |       ^~~~~
/usr/local/include/c++/12.1.0/cmath:357:3: note: previous declaration 'constexpr float std::log10(float)'
  357 |   log10(float __x)
      |   ^~~~~
p1339.cpp:136:22: error: 'double std::log10(double)' conflicts with a previous declaration
  136 | double log10(double x);
      |                      ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:107:1: note: previous declaration 'double log10(double)'
  107 | __MATHCALL (log10,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:137:13: error: redeclaration 'long double std::log10(long double)' differs in 'constexpr' from previous declaration
  137 | long double log10(long double x);
      |             ^~~~~
/usr/local/include/c++/12.1.0/cmath:361:3: note: previous declaration 'constexpr long double std::log10(long double)'
  361 |   log10(long double __x)
      |   ^~~~~
p1339.cpp:145:7: error: redeclaration 'float std::log1p(float)' differs in 'constexpr' from previous declaration
  145 | float log1p(float x);
      |       ^~~~~
/usr/local/include/c++/12.1.0/cmath:1551:3: note: previous declaration 'constexpr float std::log1p(float)'
 1551 |   log1p(float __x)
      |   ^~~~~
p1339.cpp:146:22: error: 'double std::log1p(double)' conflicts with a previous declaration
  146 | double log1p(double x);
      |                      ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:122:1: note: previous declaration 'double log1p(double)'
  122 | __MATHCALL (log1p,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:147:13: error: redeclaration 'long double std::log1p(long double)' differs in 'constexpr' from previous declaration
  147 | long double log1p(long double x);
      |             ^~~~~
/usr/local/include/c++/12.1.0/cmath:1555:3: note: previous declaration 'constexpr long double std::log1p(long double)'
 1555 |   log1p(long double __x)
      |   ^~~~~
p1339.cpp:148:21: error: 'float std::log1pf(float)' conflicts with a previous declaration
  148 | float log1pf(float x);
      |                     ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:122:1: note: previous declaration 'float log1pf(float)'
  122 | __MATHCALL (log1p,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:149:33: error: 'long double std::log1pl(long double)' conflicts with a previous declaration
  149 | long double log1pl(long double x);
      |                                 ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:122:1: note: previous declaration 'long double log1pl(long double)'
  122 | __MATHCALL (log1p,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:150:7: error: redeclaration 'float std::log2(float)' differs in 'constexpr' from previous declaration
  150 | float log2(float x);
      |       ^~~~
/usr/local/include/c++/12.1.0/cmath:1570:3: note: previous declaration 'constexpr float std::log2(float)'
 1570 |   log2(float __x)
      |   ^~~~
p1339.cpp:151:21: error: 'double std::log2(double)' conflicts with a previous declaration
  151 | double log2(double x);
      |                     ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:133:1: note: previous declaration 'double log2(double)'
  133 | __MATHCALL (log2,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:152:13: error: redeclaration 'long double std::log2(long double)' differs in 'constexpr' from previous declaration
  152 | long double log2(long double x);
      |             ^~~~
/usr/local/include/c++/12.1.0/cmath:1574:3: note: previous declaration 'constexpr long double std::log2(long double)'
 1574 |   log2(long double __x)
      |   ^~~~
p1339.cpp:153:20: error: 'float std::log2f(float)' conflicts with a previous declaration
  153 | float log2f(float x);
      |                    ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:133:1: note: previous declaration 'float log2f(float)'
  133 | __MATHCALL (log2,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:154:32: error: 'long double std::log2l(long double)' conflicts with a previous declaration
  154 | long double log2l(long double x);
      |                                ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:133:1: note: previous declaration 'long double log2l(long double)'
  133 | __MATHCALL (log2,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:158:31: error: 'constexpr double std::logb(double)' conflicts with a previous declaration
  158 | constexpr double logb(double x);
      |                               ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:125:1: note: previous declaration 'double logb(double)'
  125 | __MATHCALL (logb,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:160:30: error: 'constexpr float std::logbf(float)' conflicts with a previous declaration
  160 | constexpr float logbf(float x);
      |                              ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:125:1: note: previous declaration 'float logbf(float)'
  125 | __MATHCALL (logb,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:161:42: error: 'constexpr long double std::logbl(long double)' conflicts with a previous declaration
  161 | constexpr long double logbl(long double x);
      |                                          ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:125:1: note: previous declaration 'long double logbl(long double)'
  125 | __MATHCALL (logb,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:163:17: error: redeclaration 'constexpr float std::modf(float, float*)' differs in 'constexpr' from previous declaration
  163 | constexpr float modf(float value, float* iptr); // see 16.2
      |                 ^~~~
/usr/local/include/c++/12.1.0/cmath:376:3: note: previous declaration 'float std::modf(float, float*)'
  376 |   modf(float __x, float* __iptr)
      |   ^~~~
p1339.cpp:164:49: error: 'constexpr double std::modf(double, double*)' conflicts with a previous declaration
  164 | constexpr double modf(double value, double* iptr);
      |                                                 ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:110:1: note: previous declaration 'double modf(double, double*)'
  110 | __MATHCALL (modf,, (_Mdouble_ __x, _Mdouble_ *__iptr)) __nonnull ((2));
      | ^~~~~~~~~~
p1339.cpp:165:23: error: redeclaration 'constexpr long double std::modf(long double, long double*)' differs in 'constexpr' from previous declaration
  165 | constexpr long double modf(long double value, long double* iptr); // see 16.2
      |                       ^~~~
/usr/local/include/c++/12.1.0/cmath:380:3: note: previous declaration 'long double std::modf(long double, long double*)'
  380 |   modf(long double __x, long double* __iptr)
      |   ^~~~
p1339.cpp:169:40: error: 'constexpr double std::scalbn(double, int)' conflicts with a previous declaration
  169 | constexpr double scalbn(double x, int n);
      |                                        ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:276:1: note: previous declaration 'double scalbn(double, int'
  276 | __MATHCALL (scalbn,, (_Mdouble_ __x, int __n));
      | ^~~~~~~~~~
p1339.cpp:171:39: error: 'constexpr float std::scalbnf(float, int)' conflicts with a previous declaration
  171 | constexpr float scalbnf(float x, int n);
      |                                       ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:276:1: note: previous declaration 'float scalbnf(float, int)'
  276 | __MATHCALL (scalbn,, (_Mdouble_ __x, int __n));
      | ^~~~~~~~~~
p1339.cpp:172:51: error: 'constexpr long double std::scalbnl(long double, int)' conflicts with a previous declaration
  172 | constexpr long double scalbnl(long double x, int n);
      |                                                   ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:276:1: note: previous declaration 'long double scalbnl(long double, int)'
  276 | __MATHCALL (scalbn,, (_Mdouble_ __x, int __n));
      | ^~~~~~~~~~
p1339.cpp:174:46: error: 'constexpr double std::scalbln(double, long int)' conflicts with a previous declaration
  174 | constexpr double scalbln(double x, long int n);
      |                                              ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:290:1: note: previous declaration 'double scalbln(double, long int)'
  290 | __MATHCALL (scalbln,, (_Mdouble_ __x, long int __n));
      | ^~~~~~~~~~
p1339.cpp:176:45: error: 'constexpr float std::scalblnf(float, long int)' conflicts with a previous declaration
  176 | constexpr float scalblnf(float x, long int n);
      |                                             ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:290:1: note: previous declaration 'float scalblnf(float, long int)'
  290 | __MATHCALL (scalbln,, (_Mdouble_ __x, long int __n));
      | ^~~~~~~~~~
p1339.cpp:177:57: error: 'constexpr long double std::scalblnl(long double, long int)' conflicts with a previous declaration
  177 | constexpr long double scalblnl(long double x, long int n);
      |                                                         ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:290:1: note: previous declaration 'long double scalblnl(long double, long int)'
  290 | __MATHCALL (scalbln,, (_Mdouble_ __x, long int __n));
      | ^~~~~~~~~~
p1339.cpp:178:7: error: redeclaration 'float std::cbrt(float)' differs in 'constexpr' from previous declaration
  178 | float cbrt(float x);
      |       ^~~~
/usr/local/include/c++/12.1.0/cmath:1268:3: note: previous declaration 'constexpr float std::cbrt(float)'
 1268 |   cbrt(float __x)
      |   ^~~~
p1339.cpp:179:21: error: 'double std::cbrt(double)' conflicts with a previous declaration
  179 | double cbrt(double x);
      |                     ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:152:1: note: previous declaration 'double cbrt(double)'
  152 | __MATHCALL (cbrt,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:180:13: error: redeclaration 'long double std::cbrt(long double)' differs in 'constexpr' from previous declaration
  180 | long double cbrt(long double x);
      |             ^~~~
/usr/local/include/c++/12.1.0/cmath:1272:3: note: previous declaration 'constexpr long double std::cbrt(long double)'
 1272 |   cbrt(long double __x)
      |   ^~~~
p1339.cpp:181:20: error: 'float std::cbrtf(float)' conflicts with a previous declaration
  181 | float cbrtf(float x);
      |                    ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:152:1: note: previous declaration 'float cbrtf(float)'
  152 | __MATHCALL (cbrt,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:182:32: error: 'long double std::cbrtl(long double)' conflicts with a previous declaration
  182 | long double cbrtl(long double x);
      |                                ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:152:1: note: previous declaration 'long double cbrtl(long double)'
  152 | __MATHCALL (cbrt,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:185:24: error: 'constexpr int std::abs(int)' conflicts with a previous declaration
  185 | constexpr int abs(int j);
      |                        ^
In file included from /usr/local/include/c++/12.1.0/cstdlib:75,
                 from /usr/local/include/c++/12.1.0/ext/string_conversions.h:41,
                 from /usr/local/include/c++/12.1.0/bits/basic_string.h:3960,
                 from /usr/local/include/c++/12.1.0/string:53,
                 from /usr/local/include/c++/12.1.0/bits/locale_classes.h:40,
                 from /usr/local/include/c++/12.1.0/bits/ios_base.h:41,
                 from /usr/local/include/c++/12.1.0/ios:42,
                 from /usr/local/include/c++/12.1.0/ostream:38,
                 from /usr/local/include/c++/12.1.0/iostream:39,
                 from N4910.h:2:
/usr/include/stdlib.h:840:12: note: previous declaration 'int abs(int)'
  840 | extern int abs (int __x) __THROW __attribute__ ((__const__)) __wur;
      |            ^~~
p1339.cpp:186:20: error: redeclaration 'constexpr long int std::abs(long int)' differs in 'constexpr' from previous declaration
  186 | constexpr long int abs(long int j);
      |                    ^~~
In file included from /usr/local/include/c++/12.1.0/cstdlib:77:
/usr/local/include/c++/12.1.0/bits/std_abs.h:56:3: note: previous declaration 'long int std::abs(long int)'
   56 |   abs(long __i) { return __builtin_labs(__i); }
      |   ^~~
p1339.cpp:187:25: error: redeclaration 'constexpr long long int std::abs(long long int)' differs in 'constexpr' from previous declaration
  187 | constexpr long long int abs(long long int j);
      |                         ^~~
/usr/local/include/c++/12.1.0/bits/std_abs.h:61:3: note: previous declaration 'long long int std::abs(long long int)'
   61 |   abs(long long __x) { return __builtin_llabs (__x); }
      |   ^~~
p1339.cpp:192:31: error: 'constexpr double std::fabs(double)' conflicts with a previous declaration
  192 | constexpr double fabs(double x);
      |                               ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:162:1: note: previous declaration 'double fabs(double)'
  162 | __MATHCALLX (fabs,, (_Mdouble_ __x), (__const__));
      | ^~~~~~~~~~~
p1339.cpp:197:7: error: redeclaration 'float std::hypot(float, float)' differs in 'constexpr' from previous declaration
  197 | float hypot(float x, float y); // see 16.2
      |       ^~~~~
/usr/local/include/c++/12.1.0/cmath:1458:3: note: previous declaration 'constexpr float std::hypot(float, float)'
 1458 |   hypot(float __x, float __y)
      |   ^~~~~
p1339.cpp:198:32: error: 'double std::hypot(double, double)' conflicts with a previous declaration
  198 | double hypot(double x, double y);
      |                                ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:147:1: note: previous declaration 'double hypot(double, double)'
  147 | __MATHCALL (hypot,, (_Mdouble_ __x, _Mdouble_ __y));
      | ^~~~~~~~~~
p1339.cpp:199:13: error: redeclaration 'long double std::hypot(long double, long double)' differs in 'constexpr' from previous declaration
  199 | long double hypot(long double x, long double y); // see 16.2
      |             ^~~~~
/usr/local/include/c++/12.1.0/cmath:1462:3: note: previous declaration 'constexpr long double std::hypot(long double, long double)'
 1462 |   hypot(long double __x, long double __y)
      |   ^~~~~
p1339.cpp:200:30: error: 'float std::hypotf(float, float)' conflicts with a previous declaration
  200 | float hypotf(float x, float y);
      |                              ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:147:1: note: previous declaration 'float hypotf(float, float'
  147 | __MATHCALL (hypot,, (_Mdouble_ __x, _Mdouble_ __y));
      | ^~~~~~~~~~
p1339.cpp:201:48: error: 'long double std::hypotl(long double, long double)' conflicts with a previous declaration
  201 | long double hypotl(long double x, long double y);
      |                                                ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:147:1: note: previous declaration 'long double hypotl(long double, long double)'
  147 | __MATHCALL (hypot,, (_Mdouble_ __x, _Mdouble_ __y));
      | ^~~~~~~~~~
p1339.cpp:206:7: error: redeclaration 'float std::pow(float, float)' differs in 'constexpr' from previous declaration
  206 | float pow(float x, float y); // see 16.2
      |       ^~~
/usr/local/include/c++/12.1.0/cmath:388:3: note: previous declaration 'constexpr float std::pow(float, float)'
  388 |   pow(float __x, float __y)
      |   ^~~
p1339.cpp:207:30: error: 'double std::pow(double, double)' conflicts with a previous declaration
  207 | double pow(double x, double y);
      |                              ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:140:1: note: previous declaration 'double pow(double, double'
  140 | __MATHCALL_VEC (pow,, (_Mdouble_ __x, _Mdouble_ __y));
      | ^~~~~~~~~~~~~~
p1339.cpp:208:13: error: redeclaration 'long double std::pow(long double, long double)' differs in 'constexpr' from previous declaration
  208 | long double pow(long double x, long double y);
      |             ^~~
/usr/local/include/c++/12.1.0/cmath:392:3: note: previous declaration 'constexpr long double std::pow(long double, long double)'
  392 |   pow(long double __x, long double __y)
      |   ^~~
p1339.cpp:212:7: error: redeclaration 'float std::sqrt(float)' differs in 'constexpr' from previous declaration
  212 | float sqrt(float x);
      |       ^~~~
/usr/local/include/c++/12.1.0/cmath:463:3: note: previous declaration 'constexpr float std::sqrt(float)'
  463 |   sqrt(float __x)
      |   ^~~~
p1339.cpp:213:21: error: 'double std::sqrt(double)' conflicts with a previous declaration
  213 | double sqrt(double x);
      |                     ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:143:1: note: previous declaration 'double sqrt(double)'
  143 | __MATHCALL (sqrt,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:214:13: error: redeclaration 'long double std::sqrt(long double)' differs in 'constexpr' from previous declaration
  214 | long double sqrt(long double x);
      |             ^~~~
/usr/local/include/c++/12.1.0/cmath:467:3: note: previous declaration 'constexpr long double std::sqrt(long double)'
  467 |   sqrt(long double __x)
      |   ^~~~
p1339.cpp:217:7: error: redeclaration 'float std::erf(float)' differs in 'constexpr' from previous declaration
  217 | float erf(float x);
      |       ^~~
/usr/local/include/c++/12.1.0/cmath:1306:3: note: previous declaration 'constexpr float std::erf(float)'
 1306 |   erf(float __x)
      |   ^~~
p1339.cpp:218:20: error: 'double std::erf(double)' conflicts with a previous declaration
  218 | double erf(double x);
      |                    ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:228:1: note: previous declaration 'double erf(double)'
  228 | __MATHCALL (erf,, (_Mdouble_));
      | ^~~~~~~~~~
p1339.cpp:219:13: error: redeclaration 'long double std::erf(long double)' differs in 'constexpr' from previous declaration
  219 | long double erf(long double x);
      |             ^~~
/usr/local/include/c++/12.1.0/cmath:1310:3: note: previous declaration 'constexpr long double std::erf(long double)'
 1310 |   erf(long double __x)
      |   ^~~
p1339.cpp:220:19: error: 'float std::erff(float)' conflicts with a previous declaration
  220 | float erff(float x);
      |                   ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:228:1: note: previous declaration 'float erff(float)'
  228 | __MATHCALL (erf,, (_Mdouble_));
      | ^~~~~~~~~~
p1339.cpp:221:31: error: 'long double std::erfl(long double)' conflicts with a previous declaration
  221 | long double erfl(long double x);
      |                               ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:228:1: note: previous declaration 'long double erfl(long double)'
  228 | __MATHCALL (erf,, (_Mdouble_));
      | ^~~~~~~~~~
p1339.cpp:222:7: error: redeclaration 'float std::erfc(float)' differs in 'constexpr' from previous declaration
  222 | float erfc(float x);
      |       ^~~~
/usr/local/include/c++/12.1.0/cmath:1324:3: note: previous declaration 'constexpr float std::erfc(float)'
 1324 |   erfc(float __x)
      |   ^~~~
p1339.cpp:223:21: error: 'double std::erfc(double)' conflicts with a previous declaration
  223 | double erfc(double x);
      |                     ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:229:1: note: previous declaration 'double erfc(double)'
  229 | __MATHCALL (erfc,, (_Mdouble_));
      | ^~~~~~~~~~
p1339.cpp:224:13: error: redeclaration 'long double std::erfc(long double)' differs in 'constexpr' from previous declaration
  224 | long double erfc(long double x);
      |             ^~~~
/usr/local/include/c++/12.1.0/cmath:1328:3: note: previous declaration 'constexpr long double std::erfc(long double)'
 1328 |   erfc(long double __x)
      |   ^~~~
p1339.cpp:225:20: error: 'float std::erfcf(float)' conflicts with a previous declaration
  225 | float erfcf(float x);
      |                    ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:229:1: note: previous declaration 'float erfcf(float)'
  229 | __MATHCALL (erfc,, (_Mdouble_));
      | ^~~~~~~~~~
p1339.cpp:226:32: error: 'long double std::erfcl(long double)' conflicts with a previous declaration
  226 | long double erfcl(long double x);
      |                                ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:229:1: note: previous declaration 'long double erfcl(long double)'
  229 | __MATHCALL (erfc,, (_Mdouble_));
      | ^~~~~~~~~~
p1339.cpp:227:7: error: redeclaration 'float std::lgamma(float)' differs in 'constexpr' from previous declaration
  227 | float lgamma(float x);
      |       ^~~~~~
/usr/local/include/c++/12.1.0/cmath:1497:3: note: previous declaration 'constexpr float std::lgamma(float)'
 1497 |   lgamma(float __x)
      |   ^~~~~~
p1339.cpp:228:23: error: 'double std::lgamma(double)' conflicts with a previous declaration
  228 | double lgamma(double x);
      |                       ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:230:1: note: previous declaration 'double lgamma(double)'
  230 | __MATHCALL (lgamma,, (_Mdouble_));
      | ^~~~~~~~~~
p1339.cpp:229:13: error: redeclaration 'long double std::lgamma(long double)' differs in 'constexpr' from previous declaration
  229 | long double lgamma(long double x);
      |             ^~~~~~
/usr/local/include/c++/12.1.0/cmath:1501:3: note: previous declaration 'constexpr long double std::lgamma(long double)'
 1501 |   lgamma(long double __x)
      |   ^~~~~~
p1339.cpp:230:22: error: 'float std::lgammaf(float)' conflicts with a previous declaration
  230 | float lgammaf(float x);
      |                      ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:230:1: note: previous declaration 'float lgammaf(float)'
  230 | __MATHCALL (lgamma,, (_Mdouble_));
      | ^~~~~~~~~~
p1339.cpp:231:34: error: 'long double std::lgammal(long double)' conflicts with a previous declaration
  231 | long double lgammal(long double x);
      |                                  ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:230:1: note: previous declaration 'long double lgammal(long double)'
  230 | __MATHCALL (lgamma,, (_Mdouble_));
      | ^~~~~~~~~~
p1339.cpp:232:7: error: redeclaration 'float std::tgamma(float)' differs in 'constexpr' from previous declaration
  232 | float tgamma(float x);
      |       ^~~~~~
/usr/local/include/c++/12.1.0/cmath:1810:3: note: previous declaration 'constexpr float std::tgamma(float)'
 1810 |   tgamma(float __x)
      |   ^~~~~~
p1339.cpp:233:23: error: 'double std::tgamma(double)' conflicts with a previous declaration
  233 | double tgamma(double x);
      |                       ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:235:1: note: previous declaration 'double tgamma(double)'
  235 | __MATHCALL (tgamma,, (_Mdouble_));
      | ^~~~~~~~~~
p1339.cpp:234:13: error: redeclaration 'long double std::tgamma(long double)' differs in 'constexpr' from previous declaration
  234 | long double tgamma(long double x);
      |             ^~~~~~
/usr/local/include/c++/12.1.0/cmath:1814:3: note: previous declaration 'constexpr long double std::tgamma(long double)'
 1814 |   tgamma(long double __x)
      |   ^~~~~~
p1339.cpp:235:22: error: 'float std::tgammaf(float)' conflicts with a previous declaration
  235 | float tgammaf(float x);
      |                      ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:235:1: note: previous declaration 'float tgammaf(float)'
  235 | __MATHCALL (tgamma,, (_Mdouble_));
      | ^~~~~~~~~~
p1339.cpp:236:34: error: 'long double std::tgammal(long double)' conflicts with a previous declaration
  236 | long double tgammal(long double x);
      |                                  ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:235:1: note: previous declaration 'long double tgammal(long double)'
  235 | __MATHCALL (tgamma,, (_Mdouble_));
      | ^~~~~~~~~~
p1339.cpp:243:31: error: 'constexpr double std::ceil(double)' conflicts with a previous declaration
  243 | constexpr double ceil(double x);
      |                               ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:159:1: note: previous declaration 'double ceil(double)'
  159 | __MATHCALLX (ceil,, (_Mdouble_ __x), (__const__));
      | ^~~~~~~~~~~
p1339.cpp:248:32: error: 'constexpr double std::floor(double)' conflicts with a previous declaration
  248 | constexpr double floor(double x);
      |                                ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:165:1: note: previous declaration 'double floor(double)'
  165 | __MATHCALLX (floor,, (_Mdouble_ __x), (__const__));
      | ^~~~~~~~~~~
p1339.cpp:254:7: error: redeclaration 'float std::nearbyint(float)' differs in 'constexpr' from previous declaration
  254 | float nearbyint(float x); // see 16.2
      |       ^~~~~~~~~
/usr/local/include/c++/12.1.0/cmath:1642:3: note: previous declaration 'constexpr float std::nearbyint(float)'
 1642 |   nearbyint(float __x)
      |   ^~~~~~~~~
p1339.cpp:255:26: error: 'double std::nearbyint(double)' conflicts with a previous declaration
  255 | double nearbyint(double x);
      |                          ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:294:1: note: previous declaration 'double nearbyint(double)'
  294 | __MATHCALL (nearbyint,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:256:13: error: redeclaration 'long double std::nearbyint(long double)' differs in 'constexpr' from previous declaration
  256 | long double nearbyint(long double x); // see 16.2
      |             ^~~~~~~~~
/usr/local/include/c++/12.1.0/cmath:1646:3: note: previous declaration 'constexpr long double std::nearbyint(long double)'
 1646 |   nearbyint(long double __x)
      |   ^~~~~~~~~
p1339.cpp:257:25: error: 'float std::nearbyintf(float)' conflicts with a previous declaration
  257 | float nearbyintf(float x);
      |                         ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:294:1: note: previous declaration 'float nearbyintf(float)'
  294 | __MATHCALL (nearbyint,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:258:37: error: 'long double std::nearbyintl(long double)' conflicts with a previous declaration
  258 | long double nearbyintl(long double x);
      |                                     ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:294:1: note: previous declaration 'long double nearbyintl(long double)'
  294 | __MATHCALL (nearbyint,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:259:7: error: redeclaration 'float std::rint(float)' differs in 'constexpr' from previous declaration
  259 | float rint(float x);
      |       ^~~~
/usr/local/include/c++/12.1.0/cmath:1738:3: note: previous declaration 'constexpr float std::rint(float)'
 1738 |   rint(float __x)
      |   ^~~~
p1339.cpp:260:21: error: 'double std::rint(double)' conflicts with a previous declaration
  260 | double rint(double x);
      |                     ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:256:1: note: previous declaration 'double rint(double)'
  256 | __MATHCALL (rint,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:261:13: error: redeclaration 'long double std::rint(long double)' differs in 'constexpr' from previous declaration
  261 | long double rint(long double x);
      |             ^~~~
/usr/local/include/c++/12.1.0/cmath:1742:3: note: previous declaration 'constexpr long double std::rint(long double)'
 1742 |   rint(long double __x)
      |   ^~~~
p1339.cpp:262:20: error: 'float std::rintf(float)' conflicts with a previous declaration
  262 | float rintf(float x);
      |                    ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:256:1: note: previous declaration 'float rintf(float)'
  256 | __MATHCALL (rint,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:263:32: error: 'long double std::rintl(long double)' conflicts with a previous declaration
  263 | long double rintl(long double x);
      |                                ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:256:1: note: previous declaration 'long double rintl(long double)'
  256 | __MATHCALL (rint,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:265:10: error: redeclaration 'long int std::lrint(float)' differs in 'constexpr' from previous declaration
  265 | long int lrint(float x);
      |          ^~~~~
/usr/local/include/c++/12.1.0/cmath:1606:3: note: previous declaration 'constexpr long int std::lrint(float'
 1606 |   lrint(float __x)
      |   ^~~~~
p1339.cpp:266:24: error: 'long int std::lrint(double)' conflicts with a previous declaration
  266 | long int lrint(double x);
      |                        ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:314:1: note: previous declaration 'long int lrint(double)'
  314 | __MATHDECL (long int,lrint,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:267:10: error: redeclaration 'long int std::lrint(long double)' differs in 'constexpr' from previous declaration
  267 | long int lrint(long double x);
      |          ^~~~~
/usr/local/include/c++/12.1.0/cmath:1610:3: note: previous declaration 'constexpr long int std::lrint(long double)'
 1610 |   lrint(long double __x)
      |   ^~~~~
p1339.cpp:268:24: error: 'long int std::lrintf(float)' conflicts with a previous declaration
  268 | long int lrintf(float x);
      |                        ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:314:1: note: previous declaration 'long int lrintf(float)'
  314 | __MATHDECL (long int,lrint,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:269:30: error: 'long int std::lrintl(long double)' conflicts with a previous declaration
  269 | long int lrintl(long double x);
      |                              ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:314:1: note: previous declaration 'long int lrintl(long double)'
  314 | __MATHDECL (long int,lrint,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:270:15: error: redeclaration 'long long int std::llrint(float)' differs in 'constexpr' from previous declaration
  270 | long long int llrint(float x);
      |               ^~~~~~
/usr/local/include/c++/12.1.0/cmath:1515:3: note: previous declaration 'constexpr long long int std::llrint(float)'
 1515 |   llrint(float __x)
      |   ^~~~~~
p1339.cpp:271:30: error: 'long long int std::llrint(double)' conflicts with a previous declaration
  271 | long long int llrint(double x);
      |                              ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:316:1: note: previous declaration 'long long int llrint(double)'
  316 | __MATHDECL (long long int,llrint,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:272:15: error: redeclaration 'long long int std::llrint(long double)' differs in 'constexpr' from previous declaration
  272 | long long int llrint(long double x);
      |               ^~~~~~
/usr/local/include/c++/12.1.0/cmath:1519:3: note: previous declaration 'constexpr long long int std::llrint(long double)'
 1519 |   llrint(long double __x)
      |   ^~~~~~
p1339.cpp:273:30: error: 'long long int std::llrintf(float)' conflicts with a previous declaration
  273 | long long int llrintf(float x);
      |                              ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:316:1: note: previous declaration 'long long int llrintf(float)'
  316 | __MATHDECL (long long int,llrint,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:274:36: error: 'long long int std::llrintl(long double)' conflicts with a previous declaration
  274 | long long int llrintl(long double x);
      |                                    ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:316:1: note: previous declaration 'long long int llrintl(long double)'
  316 | __MATHDECL (long long int,llrint,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:278:32: error: 'constexpr double std::round(double)' conflicts with a previous declaration
  278 | constexpr double round(double x);
      |                                ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:298:1: note: previous declaration 'double round(double)'
  298 | __MATHCALLX (round,, (_Mdouble_ __x), (__const__));
      | ^~~~~~~~~~~
p1339.cpp:280:31: error: 'constexpr float std::roundf(float)' conflicts with a previous declaration
  280 | constexpr float roundf(float x);
      |                               ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:298:1: note: previous declaration 'float roundf(float)'
  298 | __MATHCALLX (round,, (_Mdouble_ __x), (__const__));
      | ^~~~~~~~~~~
p1339.cpp:281:43: error: 'constexpr long double std::roundl(long double)' conflicts with a previous declaration
  281 | constexpr long double roundl(long double x);
      |                                           ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:298:1: note: previous declaration 'long double roundl(long double)'
  298 | __MATHCALLX (round,, (_Mdouble_ __x), (__const__));
      | ^~~~~~~~~~~
p1339.cpp:283:35: error: 'constexpr long int std::lround(double)' conflicts with a previous declaration
  283 | constexpr long int lround(double x);
      |                                   ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:320:1: note: previous declaration 'long int lround(double)'
  320 | __MATHDECL (long int,lround,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:285:35: error: 'constexpr long int std::lroundf(float)' conflicts with a previous declaration
  285 | constexpr long int lroundf(float x);
      |                                   ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:320:1: note: previous declaration 'long int lroundf(float)'
  320 | __MATHDECL (long int,lround,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:286:41: error: 'constexpr long int std::lroundl(long double)' conflicts with a previous declaration
  286 | constexpr long int lroundl(long double x);
      |                                         ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:320:1: note: previous declaration 'long int lroundl(long double)'
  320 | __MATHDECL (long int,lround,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:292:41: error: 'constexpr double std::fmod(double, double)' conflicts with a previous declaration
  292 | constexpr double fmod(double x, double y);
      |                                         ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:168:1: note: previous declaration 'double fmod(double, double)'
  168 | __MATHCALL (fmod,, (_Mdouble_ __x, _Mdouble_ __y));
      | ^~~~~~~~~~
p1339.cpp:297:46: error: 'constexpr double std::remainder(double, double)' conflicts with a previous declaration
  297 | constexpr double remainder(double x, double y);
      |                                              ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:272:1: note: previous declaration 'double remainder(double, double)'
  272 | __MATHCALL (remainder,, (_Mdouble_ __x, _Mdouble_ __y));
      | ^~~~~~~~~~
p1339.cpp:299:44: error: 'constexpr float std::remainderf(float, float)' conflicts with a previous declaration
  299 | constexpr float remainderf(float x, float y);
      |                                            ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:272:1: note: previous declaration 'float remainderf(float, float)'
  272 | __MATHCALL (remainder,, (_Mdouble_ __x, _Mdouble_ __y));
      | ^~~~~~~~~~
p1339.cpp:300:62: error: 'constexpr long double std::remainderl(long double, long double)' conflicts with a previous declaration
  300 | constexpr long double remainderl(long double x, long double y);
      |                                                              ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:272:1: note: previous declaration 'long double remainderl(long double, long double)'
  272 | __MATHCALL (remainder,, (_Mdouble_ __x, _Mdouble_ __y));
      | ^~~~~~~~~~
p1339.cpp:301:17: error: redeclaration 'constexpr float std::remquo(float, float, int*)' differs in 'constexpr' from previous declaration
  301 | constexpr float remquo(float x, float y, int* quo); // see 16.2
      |                 ^~~~~~
/usr/local/include/c++/12.1.0/cmath:1718:3: note: previous declaration 'float std::remquo(float, float, int*)'
 1718 |   remquo(float __x, float __y, int* __pquo)
      |   ^~~~~~
p1339.cpp:302:53: error: 'constexpr double std::remquo(double, double, int*)' conflicts with a previous declaration
  302 | constexpr double remquo(double x, double y, int* quo);
      |                                                     ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:307:1: note: previous declaration 'double remquo(double, double, int*)'
  307 | __MATHCALL (remquo,, (_Mdouble_ __x, _Mdouble_ __y, int *__quo));
      | ^~~~~~~~~~
p1339.cpp:303:23: error: redeclaration 'constexpr long double std::remquo(long double, long double, int*)' differs in 'constexpr' from previous declaration
  303 | constexpr long double remquo(long double x, long double y, int* quo); constexpr float remquof(float x, float y, int* quo);
      |                       ^~~~~~
/usr/local/include/c++/12.1.0/cmath:1722:3: note: previous declaration 'long double std::remquo(long double, long double, int*)'
 1722 |   remquo(long double __x, long double __y, int* __pquo)
      |   ^~~~~~
p1339.cpp:303:121: error: 'constexpr float std::remquof(float, float, int*)' conflicts with a previous declaration
  303 | emquo(long double x, long double y, int* quo); constexpr float remquof(float x, float y, int* quo);
      |                                                                                                  ^

/usr/include/x86_64-linux-gnu/bits/mathcalls.h:307:1: note: previous declaration 'float remquof(float, float, int*)'
  307 | __MATHCALL (remquo,, (_Mdouble_ __x, _Mdouble_ __y, int *__quo));
      | ^~~~~~~~~~
p1339.cpp:304:69: error: 'constexpr long double std::remquol(long double, long double, int*)' conflicts with a previous declaration
  304 | constexpr long double remquol(long double x, long double y, int* quo);
      |                                                                     ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:307:1: note: previous declaration 'long double remquol(long double, long double, int*)'
  307 | __MATHCALL (remquo,, (_Mdouble_ __x, _Mdouble_ __y, int *__quo));
      | ^~~~~~~~~~
p1339.cpp:306:41: error: 'constexpr long long int std::llround(double)' conflicts with a previous declaration
  306 | constexpr long long int llround(double x);
      |                                         ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:322:1: note: previous declaration 'long long int llround(double)'
  322 | __MATHDECL (long long int,llround,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:308:41: error: 'constexpr long long int std::llroundf(float)' conflicts with a previous declaration
  308 | constexpr long long int llroundf(float x);
      |                                         ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:322:1: note: previous declaration 'long long int llroundf(float)'
  322 | __MATHDECL (long long int,llround,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:309:47: error: 'constexpr long long int std::llroundl(long double)' conflicts with a previous declaration
  309 | constexpr long long int llroundl(long double x);
      |                                               ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:322:1: note: previous declaration 'long long int llroundl(long double)'
  322 | __MATHDECL (long long int,llround,, (_Mdouble_ __x));
      | ^~~~~~~~~~
p1339.cpp:311:32: error: 'constexpr double std::trunc(double)' conflicts with a previous declaration
  311 | constexpr double trunc(double x);
      |                                ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:302:1: note: previous declaration 'double trunc(double)'
  302 | __MATHCALLX (trunc,, (_Mdouble_ __x), (__const__));
      | ^~~~~~~~~~~
p1339.cpp:313:31: error: 'constexpr float std::truncf(float)' conflicts with a previous declaration
  313 | constexpr float truncf(float x);
      |                               ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:302:1: note: previous declaration 'float truncf(float)'
  302 | __MATHCALLX (trunc,, (_Mdouble_ __x), (__const__));
      | ^~~~~~~~~~~
p1339.cpp:314:43: error: 'constexpr long double std::truncl(long double)' conflicts with a previous declaration
  314 | constexpr long double truncl(long double x);
      |                                           ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:302:1: note: previous declaration 'long double truncl(long double)'
  302 | __MATHCALLX (trunc,, (_Mdouble_ __x), (__const__));
      | ^~~~~~~~~~~
p1339.cpp:316:45: error: 'constexpr double std::copysign(double, double)' conflicts with a previous declaration
  316 | constexpr double copysign(double x, double y);
      |                                             ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:196:1: note: previous declaration 'double copysign(double, double)'
  196 | __MATHCALLX (copysign,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
      | ^~~~~~~~~~~
p1339.cpp:318:43: error: 'constexpr float std::copysignf(float, float)' conflicts with a previous declaration
  318 | constexpr float copysignf(float x, float y);
      |                                           ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:196:1: note: previous declaration 'float copysignf(float, float)'
  196 | __MATHCALLX (copysign,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
      | ^~~~~~~~~~~
p1339.cpp:319:61: error: 'constexpr long double std::copysignl(long double, long double)' conflicts with a previous declaration
  319 | constexpr long double copysignl(long double x, long double y);
      |                                                             ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:196:1: note: previous declaration 'long double copysignl(long double, long double)'
  196 | __MATHCALLX (copysign,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
      | ^~~~~~~~~~~
p1339.cpp:320:28: error: 'double std::nan(const char*)' conflicts with a previous declaration
  320 | double nan(const char* tagp);
      |                            ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:201:1: note: previous declaration 'double nan(const char*)'
  201 | __MATHCALL (nan,, (const char *__tagb));
      | ^~~~~~~~~~
p1339.cpp:321:28: error: 'float std::nanf(const char*)' conflicts with a previous declaration
  321 | float nanf(const char* tagp);
      |                            ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:201:1: note: previous declaration 'float nanf(const char*)'
  201 | __MATHCALL (nan,, (const char *__tagb));
      | ^~~~~~~~~~
p1339.cpp:322:34: error: 'long double std::nanl(const char*)' conflicts with a previous declaration
  322 | long double nanl(const char* tagp);
      |                                  ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:201:1: note: previous declaration 'long double nanl(const char*)'
  201 | __MATHCALL (nan,, (const char *__tagb));
      | ^~~~~~~~~~
p1339.cpp:329:46: error: 'constexpr double std::nextafter(double, double)' conflicts with a previous declaration
  329 | constexpr double nextafter(double x, double y);
      |                                              ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:259:1: note: previous declaration 'double nextafter(double, double)'
  259 | __MATHCALL (nextafter,, (_Mdouble_ __x, _Mdouble_ __y));
      | ^~~~~~~~~~
p1339.cpp:331:44: error: 'constexpr float std::nextafterf(float, float)' conflicts with a previous declaration
  331 | constexpr float nextafterf(float x, float y);
      |                                            ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:259:1: note: previous declaration 'float nextafterf(float, float)'
  259 | __MATHCALL (nextafter,, (_Mdouble_ __x, _Mdouble_ __y));
      | ^~~~~~~~~~
p1339.cpp:332:62: error: 'constexpr long double std::nextafterl(long double, long double)' conflicts with a previous declaration
  332 | constexpr long double nextafterl(long double x, long double y);
      |                                                              ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:259:1: note: previous declaration 'long double nextafterl(long double, long double)'
  259 | __MATHCALL (nextafter,, (_Mdouble_ __x, _Mdouble_ __y));
      | ^~~~~~~~~~
p1339.cpp:335:52: error: 'constexpr double std::nexttoward(double, long double)' conflicts with a previous declaration
  335 | constexpr double nexttoward(double x, long double y);
      |                                                    ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:261:1: note: previous declaration 'double nexttoward(double, long double)'
  261 | __MATHCALL (nexttoward,, (_Mdouble_ __x, long double __y));
      | ^~~~~~~~~~
p1339.cpp:337:51: error: 'constexpr float std::nexttowardf(float, long double)' conflicts with a previous declaration
  337 | constexpr float nexttowardf(float x, long double y);
      |                                                   ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:261:1: note: previous declaration 'float nexttowardf(float, long double)'
  261 | __MATHCALL (nexttoward,, (_Mdouble_ __x, long double __y));
      | ^~~~~~~~~~
p1339.cpp:338:63: error: 'constexpr long double std::nexttowardl(long double, long double)' conflicts with a previous declaration
  338 | constexpr long double nexttowardl(long double x, long double y);
      |                                                               ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:261:1: note: previous declaration 'long double nexttowardl(long double, long double)'
  261 | __MATHCALL (nexttoward,, (_Mdouble_ __x, long double __y));
      | ^~~~~~~~~~
p1339.cpp:341:41: error: 'constexpr double std::fdim(double, double)' conflicts with a previous declaration
  341 | constexpr double fdim(double x, double y);
      |                                         ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:326:1: note: previous declaration 'double fdim(double, double)'
  326 | __MATHCALL (fdim,, (_Mdouble_ __x, _Mdouble_ __y));
      | ^~~~~~~~~~
p1339.cpp:343:39: error: 'constexpr float std::fdimf(float, float)' conflicts with a previous declaration
  343 | constexpr float fdimf(float x, float y);
      |                                       ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:326:1: note: previous declaration 'float fdimf(float, float)'
  326 | __MATHCALL (fdim,, (_Mdouble_ __x, _Mdouble_ __y));
      | ^~~~~~~~~~
p1339.cpp:344:57: error: 'constexpr long double std::fdiml(long double, long double)' conflicts with a previous declaration
  344 | constexpr long double fdiml(long double x, long double y);
      |                                                         ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:326:1: note: previous declaration 'long double fdiml(long double, long double)'
  326 | __MATHCALL (fdim,, (_Mdouble_ __x, _Mdouble_ __y));
      | ^~~~~~~~~~
p1339.cpp:346:41: error: 'constexpr double std::fmax(double, double)' conflicts with a previous declaration
  346 | constexpr double fmax(double x, double y);
      |                                         ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:329:1: note: previous declaration 'double fmax(double, double)'
  329 | __MATHCALLX (fmax,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
      | ^~~~~~~~~~~
p1339.cpp:348:39: error: 'constexpr float std::fmaxf(float, float)' conflicts with a previous declaration
  348 | constexpr float fmaxf(float x, float y);
      |                                       ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:329:1: note: previous declaration 'float fmaxf(float, float)'
  329 | __MATHCALLX (fmax,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
      | ^~~~~~~~~~~
p1339.cpp:349:57: error: 'constexpr long double std::fmaxl(long double, long double)' conflicts with a previous declaration
  349 | constexpr long double fmaxl(long double x, long double y);
      |                                                         ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:329:1: note: previous declaration 'long double fmaxl(long double, long double)'
  329 | __MATHCALLX (fmax,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
      | ^~~~~~~~~~~
p1339.cpp:351:41: error: 'constexpr double std::fmin(double, double)' conflicts with a previous declaration
  351 | constexpr double fmin(double x, double y);
      |                                         ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:332:1: note: previous declaration 'double fmin(double, double)'
  332 | __MATHCALLX (fmin,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
      | ^~~~~~~~~~~
p1339.cpp:353:39: error: 'constexpr float std::fminf(float, float)' conflicts with a previous declaration
  353 | constexpr float fminf(float x, float y);
      |                                       ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:332:1: note: previous declaration 'float fminf(float, float)'
  332 | __MATHCALLX (fmin,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
      | ^~~~~~~~~~~
p1339.cpp:354:57: error: 'constexpr long double std::fminl(long double, long double)' conflicts with a previous declaration
  354 | constexpr long double fminl(long double x, long double y);
      |                                                         ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:332:1: note: previous declaration 'long double fminl(long double, long double)'
  332 | __MATHCALLX (fmin,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
      | ^~~~~~~~~~~
p1339.cpp:359:50: error: 'constexpr double std::fma(double, double, double)' conflicts with a previous declaration
  359 | constexpr double fma(double x, double y, double z);
      |                                                  ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:335:1: note: previous declaration 'double fma(double, double, double)'
  335 | __MATHCALL (fma,, (_Mdouble_ __x, _Mdouble_ __y, _Mdouble_ __z));
      | ^~~~~~~~~~
p1339.cpp:360:119: error: 'constexpr float std::fmaf(float, float, float)' conflicts with a previous declaration
  360 |  fma(long double x, long double y, long double z); constexpr float fmaf(float x, float y, float z);
      |                                                                                                  ^

/usr/include/x86_64-linux-gnu/bits/mathcalls.h:335:1: note: previous declaration 'float fmaf(float, float, float)'
  335 | __MATHCALL (fma,, (_Mdouble_ __x, _Mdouble_ __y, _Mdouble_ __z));
      | ^~~~~~~~~~
p1339.cpp:361:71: error: 'constexpr long double std::fmal(long double, long double, long double)' conflicts with a previous declaration
  361 | constexpr long double fmal(long double x, long double y, long double z);
      |                                                                       ^
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:335:1: note: previous declaration 'long double fmal(long double, long double, long double)'
  335 | __MATHCALL (fma,, (_Mdouble_ __x, _Mdouble_ __y, _Mdouble_ __z));
      | ^~~~~~~~~~
p1339.cpp:542:56: error: 't' does not name a type; did you mean 'tm'?
  542 | float assoc_laguerref(unsigned n, unsigned m, float x);t
      |                                                        ^
      |                                                        tm
```

## 検討事項(agenda)
コンパイルエラーを取るか、コンパイルエラーの理由を解説する。

<!-- リンクエラーの解説をする。clang++とg++の比較。意味のある出力。
コンパイルエラーを取るか、コンパイルエラーの理由を解説する。-->

# 参考資料(reference)


関連する自己参照以外は、こちらの先頭に移転。

C言語（C++)に対する誤解、曲解、無理解、爽快。

https://qiita.com/kaizen_nagoya/items/3f3992c9722c1cee2e3a

#include "N4910.h"

https://qiita.com/kaizen_nagoya/items/163a47cef7d6bb1c33a8

C++N4910資料の改善点

https://qiita.com/kaizen_nagoya/items/fb4ceb5d117a54641af3

dockerにclang

https://qiita.com/kaizen_nagoya/items/8829ffeee397eda50e80

docker gnu(gcc/g++) and llvm(clang/clang++)

https://qiita.com/kaizen_nagoya/items/059874ea39c4de64c0f7

コンパイル用shell script C版(clangとgcc)とC++版(clang++とg++)

https://qiita.com/kaizen_nagoya/items/74220c0577a512c2d7da


C++N4910:2022 tag follower 300人超えました。ありがとうございます。

https://qiita.com/kaizen_nagoya/items/a63fb96d351ac5c16ff7

astyle 使ってみた

https://qiita.com/kaizen_nagoya/items/3c9a87a781d53a1a23f3

DoCAP（ドゥーキャップ）って何ですか？

https://qiita.com/kaizen_nagoya/items/47e0e6509ab792c43327

小川メソッド　覚え（書きかけ）

https://qiita.com/kaizen_nagoya/items/3593d72eca551742df68

 ＜この記事は個人の過去の経験に基づく個人の感想です。現在所属する組織、業務とは関係がありません。＞

# 文書履歴(document history)
ver. 0.01 初稿 　20220818