From Jason Turner

[cmath.syn]

C++14 → C++17 20.6 KB 574 lines
Current Draft | LaTeX Source
Archived: C++14 | C++17
Markdown: C++14 | C++17
Explore in Adventure Game

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmpfepmxrbw/{from.md → to.md} +571 -0
tmp/tmpfepmxrbw/{from.md → to.md} RENAMED
@@ -0,0 +1,571 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ ### Header `<cmath>` synopsis <a id="cmath.syn">[[cmath.syn]]</a>
2
+
3
+ ``` cpp
4
+ namespace std {
5
+ using float_t = see below;
6
+ using double_t = see below;
7
+ }
8
+
9
+ #define HUGE_VAL see below
10
+ #define HUGE_VALF see below
11
+ #define HUGE_VALL see below
12
+ #define INFINITY see below
13
+ #define NAN see below
14
+ #define FP_INFINITE see below
15
+ #define FP_NAN see below
16
+ #define FP_NORMAL see below
17
+ #define FP_SUBNORMAL see below
18
+ #define FP_ZERO see below
19
+ #define FP_FAST_FMA see below
20
+ #define FP_FAST_FMAF see below
21
+ #define FP_FAST_FMAL see below
22
+ #define FP_ILOGB0 see below
23
+ #define FP_ILOGBNAN see below
24
+ #define MATH_ERRNO see below
25
+ #define MATH_ERREXCEPT see below
26
+
27
+ #define math_errhandling see below
28
+
29
+ namespace std {
30
+ float acos(float x); // see [library.c]
31
+ double acos(double x);
32
+ long double acos(long double x); // see [library.c]
33
+ float acosf(float x);
34
+ long double acosl(long double x);
35
+
36
+ float asin(float x); // see [library.c]
37
+ double asin(double x);
38
+ long double asin(long double x); // see [library.c]
39
+ float asinf(float x);
40
+ long double asinl(long double x);
41
+
42
+ float atan(float x); // see [library.c]
43
+ double atan(double x);
44
+ long double atan(long double x); // see [library.c]
45
+ float atanf(float x);
46
+ long double atanl(long double x);
47
+
48
+ float atan2(float y, float x); // see [library.c]
49
+ double atan2(double y, double x);
50
+ long double atan2(long double y, long double x); // see [library.c]
51
+ float atan2f(float y, float x);
52
+ long double atan2l(long double y, long double x);
53
+
54
+ float cos(float x); // see [library.c]
55
+ double cos(double x);
56
+ long double cos(long double x); // see [library.c]
57
+ float cosf(float x);
58
+ long double cosl(long double x);
59
+
60
+ float sin(float x); // see [library.c]
61
+ double sin(double x);
62
+ long double sin(long double x); // see [library.c]
63
+ float sinf(float x);
64
+ long double sinl(long double x);
65
+
66
+ float tan(float x); // see [library.c]
67
+ double tan(double x);
68
+ long double tan(long double x); // see [library.c]
69
+ float tanf(float x);
70
+ long double tanl(long double x);
71
+
72
+ float acosh(float x); // see [library.c]
73
+ double acosh(double x);
74
+ long double acosh(long double x); // see [library.c]
75
+ float acoshf(float x);
76
+ long double acoshl(long double x);
77
+
78
+ float asinh(float x); // see [library.c]
79
+ double asinh(double x);
80
+ long double asinh(long double x); // see [library.c]
81
+ float asinhf(float x);
82
+ long double asinhl(long double x);
83
+
84
+ float atanh(float x); // see [library.c]
85
+ double atanh(double x);
86
+ long double atanh(long double x); // see [library.c]
87
+ float atanhf(float x);
88
+ long double atanhl(long double x);
89
+
90
+ float cosh(float x); // see [library.c]
91
+ double cosh(double x);
92
+ long double cosh(long double x); // see [library.c]
93
+ float coshf(float x);
94
+ long double coshl(long double x);
95
+
96
+ float sinh(float x); // see [library.c]
97
+ double sinh(double x);
98
+ long double sinh(long double x); // see [library.c]
99
+ float sinhf(float x);
100
+ long double sinhl(long double x);
101
+
102
+ float tanh(float x); // see [library.c]
103
+ double tanh(double x);
104
+ long double tanh(long double x); // see [library.c]
105
+ float tanhf(float x);
106
+ long double tanhl(long double x);
107
+
108
+ float exp(float x); // see [library.c]
109
+ double exp(double x);
110
+ long double exp(long double x); // see [library.c]
111
+ float expf(float x);
112
+ long double expl(long double x);
113
+
114
+ float exp2(float x); // see [library.c]
115
+ double exp2(double x);
116
+ long double exp2(long double x); // see [library.c]
117
+ float exp2f(float x);
118
+ long double exp2l(long double x);
119
+
120
+ float expm1(float x); // see [library.c]
121
+ double expm1(double x);
122
+ long double expm1(long double x); // see [library.c]
123
+ float expm1f(float x);
124
+ long double expm1l(long double x);
125
+
126
+ float frexp(float value, int* exp); // see [library.c]
127
+ double frexp(double value, int* exp);
128
+ long double frexp(long double value, int* exp); // see [library.c]
129
+ float frexpf(float value, int* exp);
130
+ long double frexpl(long double value, int* exp);
131
+
132
+ int ilogb(float x); // see [library.c]
133
+ int ilogb(double x);
134
+ int ilogb(long double x); // see [library.c]
135
+ int ilogbf(float x);
136
+ int ilogbl(long double x);
137
+
138
+ float ldexp(float x, int exp); // see [library.c]
139
+ double ldexp(double x, int exp);
140
+ long double ldexp(long double x, int exp); // see [library.c]
141
+ float ldexpf(float x, int exp);
142
+ long double ldexpl(long double x, int exp);
143
+
144
+ float log(float x); // see [library.c]
145
+ double log(double x);
146
+ long double log(long double x); // see [library.c]
147
+ float logf(float x);
148
+ long double logl(long double x);
149
+
150
+ float log10(float x); // see [library.c]
151
+ double log10(double x);
152
+ long double log10(long double x); // see [library.c]
153
+ float log10f(float x);
154
+ long double log10l(long double x);
155
+
156
+ float log1p(float x); // see [library.c]
157
+ double log1p(double x);
158
+ long double log1p(long double x); // see [library.c]
159
+ float log1pf(float x);
160
+ long double log1pl(long double x);
161
+
162
+ float log2(float x); // see [library.c]
163
+ double log2(double x);
164
+ long double log2(long double x); // see [library.c]
165
+ float log2f(float x);
166
+ long double log2l(long double x);
167
+
168
+ float logb(float x); // see [library.c]
169
+ double logb(double x);
170
+ long double logb(long double x); // see [library.c]
171
+ float logbf(float x);
172
+ long double logbl(long double x);
173
+
174
+ float modf(float value, float* iptr); // see [library.c]
175
+ double modf(double value, double* iptr);
176
+ long double modf(long double value, long double* iptr); // see [library.c]
177
+ float modff(float value, float* iptr);
178
+ long double modfl(long double value, long double* iptr);
179
+
180
+ float scalbn(float x, int n); // see [library.c]
181
+ double scalbn(double x, int n);
182
+ long double scalbn(long double x, int n); // see [library.c]
183
+ float scalbnf(float x, int n);
184
+ long double scalbnl(long double x, int n);
185
+
186
+ float scalbln(float x, long int n); // see [library.c]
187
+ double scalbln(double x, long int n);
188
+ long double scalbln(long double x, long int n); // see [library.c]
189
+ float scalblnf(float x, long int n);
190
+ long double scalblnl(long double x, long int n);
191
+
192
+ float cbrt(float x); // see [library.c]
193
+ double cbrt(double x);
194
+ long double cbrt(long double x); // see [library.c]
195
+ float cbrtf(float x);
196
+ long double cbrtl(long double x);
197
+
198
+ // [c.math.abs], absolute values
199
+ int abs(int j);
200
+ long int abs(long int j);
201
+ long long int abs(long long int j);
202
+ float abs(float j);
203
+ double abs(double j);
204
+ long double abs(long double j);
205
+
206
+ float fabs(float x); // see [library.c]
207
+ double fabs(double x);
208
+ long double fabs(long double x); // see [library.c]
209
+ float fabsf(float x);
210
+ long double fabsl(long double x);
211
+
212
+ float hypot(float x, float y); // see [library.c]
213
+ double hypot(double x, double y);
214
+ long double hypot(double x, double y); // see [library.c]
215
+ float hypotf(float x, float y);
216
+ long double hypotl(long double x, long double y);
217
+
218
+ // [c.math.hypot3], three-dimensional hypotenuse
219
+ float hypot(float x, float y, float z);
220
+ double hypot(double x, double y, double z);
221
+ long double hypot(long double x, long double y, long double z);
222
+
223
+ float pow(float x, float y); // see [library.c]
224
+ double pow(double x, double y);
225
+ long double pow(long double x, long double y); // see [library.c]
226
+ float powf(float x, float y);
227
+ long double powl(long double x, long double y);
228
+
229
+ float sqrt(float x); // see [library.c]
230
+ double sqrt(double x);
231
+ long double sqrt(long double x); // see [library.c]
232
+ float sqrtf(float x);
233
+ long double sqrtl(long double x);
234
+
235
+ float erf(float x); // see [library.c]
236
+ double erf(double x);
237
+ long double erf(long double x); // see [library.c]
238
+ float erff(float x);
239
+ long double erfl(long double x);
240
+
241
+ float erfc(float x); // see [library.c]
242
+ double erfc(double x);
243
+ long double erfc(long double x); // see [library.c]
244
+ float erfcf(float x);
245
+ long double erfcl(long double x);
246
+
247
+ float lgamma(float x); // see [library.c]
248
+ double lgamma(double x);
249
+ long double lgamma(long double x); // see [library.c]
250
+ float lgammaf(float x);
251
+ long double lgammal(long double x);
252
+
253
+ float tgamma(float x); // see [library.c]
254
+ double tgamma(double x);
255
+ long double tgamma(long double x); // see [library.c]
256
+ float tgammaf(float x);
257
+ long double tgammal(long double x);
258
+
259
+ float ceil(float x); // see [library.c]
260
+ double ceil(double x);
261
+ long double ceil(long double x); // see [library.c]
262
+ float ceilf(float x);
263
+ long double ceill(long double x);
264
+
265
+ float floor(float x); // see [library.c]
266
+ double floor(double x);
267
+ long double floor(long double x); // see [library.c]
268
+ float floorf(float x);
269
+ long double floorl(long double x);
270
+
271
+ float nearbyint(float x); // see [library.c]
272
+ double nearbyint(double x);
273
+ long double nearbyint(long double x); // see [library.c]
274
+ float nearbyintf(float x);
275
+ long double nearbyintl(long double x);
276
+
277
+ float rint(float x); // see [library.c]
278
+ double rint(double x);
279
+ long double rint(long double x); // see [library.c]
280
+ float rintf(float x);
281
+ long double rintl(long double x);
282
+
283
+ long int lrint(float x); // see [library.c]
284
+ long int lrint(double x);
285
+ long int lrint(long double x); // see [library.c]
286
+ long int lrintf(float x);
287
+ long int lrintl(long double x);
288
+
289
+ long long int llrint(float x); // see [library.c]
290
+ long long int llrint(double x);
291
+ long long int llrint(long double x); // see [library.c]
292
+ long long int llrintf(float x);
293
+ long long int llrintl(long double x);
294
+
295
+ float round(float x); // see [library.c]
296
+ double round(double x);
297
+ long double round(long double x); // see [library.c]
298
+ float roundf(float x);
299
+ long double roundl(long double x);
300
+
301
+ long int lround(float x); // see [library.c]
302
+ long int lround(double x);
303
+ long int lround(long double x); // see [library.c]
304
+ long int lroundf(float x);
305
+ long int lroundl(long double x);
306
+
307
+ long long int llround(float x); // see [library.c]
308
+ long long int llround(double x);
309
+ long long int llround(long double x); // see [library.c]
310
+ long long int llroundf(float x);
311
+ long long int llroundl(long double x);
312
+
313
+ float trunc(float x); // see [library.c]
314
+ double trunc(double x);
315
+ long double trunc(long double x); // see [library.c]
316
+ float truncf(float x);
317
+ long double truncl(long double x);
318
+
319
+ float fmod(float x, float y); // see [library.c]
320
+ double fmod(double x, double y);
321
+ long double fmod(long double x, long double y); // see [library.c]
322
+ float fmodf(float x, float y);
323
+ long double fmodl(long double x, long double y);
324
+
325
+ float remainder(float x, float y); // see [library.c]
326
+ double remainder(double x, double y);
327
+ long double remainder(long double x, long double y); // see [library.c]
328
+ float remainderf(float x, float y);
329
+ long double remainderl(long double x, long double y);
330
+
331
+ float remquo(float x, float y, int* quo); // see [library.c]
332
+ double remquo(double x, double y, int* quo);
333
+ long double remquo(long double x, long double y, int* quo); // see [library.c]
334
+ float remquof(float x, float y, int* quo);
335
+ long double remquol(long double x, long double y, int* quo);
336
+
337
+ float copysign(float x, float y); // see [library.c]
338
+ double copysign(double x, double y);
339
+ long double copysign(long double x, long double y); // see [library.c]
340
+ float copysignf(float x, float y);
341
+ long double copysignl(long double x, long double y);
342
+
343
+ double nan(const char* tagp);
344
+ float nanf(const char* tagp);
345
+ long double nanl(const char* tagp);
346
+
347
+ float nextafter(float x, float y); // see [library.c]
348
+ double nextafter(double x, double y);
349
+ long double nextafter(long double x, long double y); // see [library.c]
350
+ float nextafterf(float x, float y);
351
+ long double nextafterl(long double x, long double y);
352
+
353
+ float nexttoward(float x, long double y); // see [library.c]
354
+ double nexttoward(double x, long double y);
355
+ long double nexttoward(long double x, long double y); // see [library.c]
356
+ float nexttowardf(float x, long double y);
357
+ long double nexttowardl(long double x, long double y);
358
+
359
+ float fdim(float x, float y); // see [library.c]
360
+ double fdim(double x, double y);
361
+ long double fdim(long double x, long double y); // see [library.c]
362
+ float fdimf(float x, float y);
363
+ long double fdiml(long double x, long double y);
364
+
365
+ float fmax(float x, float y); // see [library.c]
366
+ double fmax(double x, double y);
367
+ long double fmax(long double x, long double y); // see [library.c]
368
+ float fmaxf(float x, float y);
369
+ long double fmaxl(long double x, long double y);
370
+
371
+ float fmin(float x, float y); // see [library.c]
372
+ double fmin(double x, double y);
373
+ long double fmin(long double x, long double y); // see [library.c]
374
+ float fminf(float x, float y);
375
+ long double fminl(long double x, long double y);
376
+
377
+ float fma(float x, float y, float z); // see [library.c]
378
+ double fma(double x, double y, double z);
379
+ long double fma(long double x, long double y, long double z); // see [library.c]
380
+ float fmaf(float x, float y, float z);
381
+ long double fmal(long double x, long double y, long double z);
382
+
383
+ // [c.math.fpclass], classification / comparison functions
384
+ int fpclassify(float x);
385
+ int fpclassify(double x);
386
+ int fpclassify(long double x);
387
+
388
+ int isfinite(float x);
389
+ int isfinite(double x);
390
+ int isfinite(long double x);
391
+
392
+ int isinf(float x);
393
+ int isinf(double x);
394
+ int isinf(long double x);
395
+
396
+ int isnan(float x);
397
+ int isnan(double x);
398
+ int isnan(long double x);
399
+
400
+ int isnormal(float x);
401
+ int isnormal(double x);
402
+ int isnormal(long double x);
403
+
404
+ int signbit(float x);
405
+ int signbit(double x);
406
+ int signbit(long double x);
407
+
408
+ int isgreater(float x, float y);
409
+ int isgreater(double x, double y);
410
+ int isgreater(long double x, long double y);
411
+
412
+ int isgreaterequal(float x, float y);
413
+ int isgreaterequal(double x, double y);
414
+ int isgreaterequal(long double x, long double y);
415
+
416
+ int isless(float x, float y);
417
+ int isless(double x, double y);
418
+ int isless(long double x, long double y);
419
+
420
+ int islessequal(float x, float y);
421
+ int islessequal(double x, double y);
422
+ int islessequal(long double x, long double y);
423
+
424
+ int islessgreater(float x, float y);
425
+ int islessgreater(double x, double y);
426
+ int islessgreater(long double x, long double y);
427
+
428
+ int isunordered(float x, float y);
429
+ int isunordered(double x, double y);
430
+ int isunordered(long double x, long double y);
431
+
432
+ // [sf.cmath], mathematical special functions
433
+
434
+ // [sf.cmath.assoc_laguerre], associated Laguerre polynomials
435
+ double assoc_laguerre(unsigned n, unsigned m, double x);
436
+ float assoc_laguerref(unsigned n, unsigned m, float x);
437
+ long double assoc_laguerrel(unsigned n, unsigned m, long double x);
438
+
439
+ // [sf.cmath.assoc_legendre], associated Legendre functions
440
+ double assoc_legendre(unsigned l, unsigned m, double x);
441
+ float assoc_legendref(unsigned l, unsigned m, float x);
442
+ long double assoc_legendrel(unsigned l, unsigned m, long double x);
443
+
444
+ // [sf.cmath.beta], beta function
445
+ double beta(double x, double y);
446
+ float betaf(float x, float y);
447
+ long double betal(long double x, long double y);
448
+
449
+ // [sf.cmath.comp_ellint_1], complete elliptic integral of the first kind
450
+ double comp_ellint_1(double k);
451
+ float comp_ellint_1f(float k);
452
+ long double comp_ellint_1l(long double k);
453
+
454
+ // [sf.cmath.comp_ellint_2], complete elliptic integral of the second kind
455
+ double comp_ellint_2(double k);
456
+ float comp_ellint_2f(float k);
457
+ long double comp_ellint_2l(long double k);
458
+
459
+ // [sf.cmath.comp_ellint_3], complete elliptic integral of the third kind
460
+ double comp_ellint_3(double k, double nu);
461
+ float comp_ellint_3f(float k, float nu);
462
+ long double comp_ellint_3l(long double k, long double nu);
463
+
464
+ // [sf.cmath.cyl_bessel_i], regular modified cylindrical Bessel functions
465
+ double cyl_bessel_i(double nu, double x);
466
+ float cyl_bessel_if(float nu, float x);
467
+ long double cyl_bessel_il(long double nu, long double x);
468
+
469
+ // [sf.cmath.cyl_bessel_j], cylindrical Bessel functions of the first kind
470
+ double cyl_bessel_j(double nu, double x);
471
+ float cyl_bessel_jf(float nu, float x);
472
+ long double cyl_bessel_jl(long double nu, long double x);
473
+
474
+ // [sf.cmath.cyl_bessel_k], irregular modified cylindrical Bessel functions
475
+ double cyl_bessel_k(double nu, double x);
476
+ float cyl_bessel_kf(float nu, float x);
477
+ long double cyl_bessel_kl(long double nu, long double x);
478
+
479
+ // [sf.cmath.cyl_neumann], cylindrical Neumann functions;
480
+ // cylindrical Bessel functions of the second kind
481
+ double cyl_neumann(double nu, double x);
482
+ float cyl_neumannf(float nu, float x);
483
+ long double cyl_neumannl(long double nu, long double x);
484
+
485
+ // [sf.cmath.ellint_1], incomplete elliptic integral of the first kind
486
+ double ellint_1(double k, double phi);
487
+ float ellint_1f(float k, float phi);
488
+ long double ellint_1l(long double k, long double phi);
489
+
490
+ // [sf.cmath.ellint_2], incomplete elliptic integral of the second kind
491
+ double ellint_2(double k, double phi);
492
+ float ellint_2f(float k, float phi);
493
+ long double ellint_2l(long double k, long double phi);
494
+
495
+ // [sf.cmath.ellint_3], incomplete elliptic integral of the third kind
496
+ double ellint_3(double k, double nu, double phi);
497
+ float ellint_3f(float k, float nu, float phi);
498
+ long double ellint_3l(long double k, long double nu, long double phi);
499
+
500
+ // [sf.cmath.expint], exponential integral
501
+ double expint(double x);
502
+ float expintf(float x);
503
+ long double expintl(long double x);
504
+
505
+ // [sf.cmath.hermite], Hermite polynomials
506
+ double hermite(unsigned n, double x);
507
+ float hermitef(unsigned n, float x);
508
+ long double hermitel(unsigned n, long double x);
509
+
510
+ // [sf.cmath.laguerre], Laguerre polynomials
511
+ double laguerre(unsigned n, double x);
512
+ float laguerref(unsigned n, float x);
513
+ long double laguerrel(unsigned n, long double x);
514
+
515
+ // [sf.cmath.legendre], Legendre polynomials
516
+ double legendre(unsigned l, double x);
517
+ float legendref(unsigned l, float x);
518
+ long double legendrel(unsigned l, long double x);
519
+
520
+ // [sf.cmath.riemann_zeta], Riemann zeta function
521
+ double riemann_zeta(double x);
522
+ float riemann_zetaf(float x);
523
+ long double riemann_zetal(long double x);
524
+
525
+ // [sf.cmath.sph_bessel], spherical Bessel functions of the first kind
526
+ double sph_bessel(unsigned n, double x);
527
+ float sph_besself(unsigned n, float x);
528
+ long double sph_bessell(unsigned n, long double x);
529
+
530
+ // [sf.cmath.sph_legendre], spherical associated Legendre functions
531
+ double sph_legendre(unsigned l, unsigned m, double theta);
532
+ float sph_legendref(unsigned l, unsigned m, float theta);
533
+ long double sph_legendrel(unsigned l, unsigned m, long double theta);
534
+
535
+ // [sf.cmath.sph_neumann], spherical Neumann functions;
536
+ // spherical Bessel functions of the second kind:
537
+ double sph_neumann(unsigned n, double x);
538
+ float sph_neumannf(unsigned n, float x);
539
+ long double sph_neumannl(unsigned n, long double x);
540
+ }
541
+ ```
542
+
543
+ The contents and meaning of the header `<cmath>` are the same as the C
544
+ standard library header `<math.h>`, with the addition of a
545
+ three-dimensional hypotenuse function ([[c.math.hypot3]]) and the
546
+ mathematical special functions described in [[sf.cmath]].
547
+
548
+ [*Note 1*: Several functions have additional overloads in this
549
+ International Standard, but they have the same behavior as in the C
550
+ standard library ([[library.c]]). — *end note*]
551
+
552
+ For each set of overloaded functions within `<cmath>`, with the
553
+ exception of `abs`, there shall be additional overloads sufficient to
554
+ ensure:
555
+
556
+ 1. If any argument of arithmetic type corresponding to a `double`
557
+ parameter has type `long double`, then all arguments of arithmetic
558
+ type ([[basic.fundamental]]) corresponding to `double` parameters
559
+ are effectively cast to `long double`.
560
+ 2. Otherwise, if any argument of arithmetic type corresponding to a
561
+ `double` parameter has type `double` or an integer type, then all
562
+ arguments of arithmetic type corresponding to `double` parameters
563
+ are effectively cast to `double`.
564
+ 3. Otherwise, all arguments of arithmetic type corresponding to
565
+ `double` parameters have type `float`.
566
+
567
+ [*Note 2*: `abs` is exempted from these rules in order to stay
568
+ compatible with C. — *end note*]
569
+
570
+ ISO C 7.12
571
+