1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
|
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
export namespace std {
using std::double_t _LIBCPP_USING_IF_EXISTS;
using std::float_t _LIBCPP_USING_IF_EXISTS;
using std::acos _LIBCPP_USING_IF_EXISTS;
using std::acosf _LIBCPP_USING_IF_EXISTS;
using std::acosl _LIBCPP_USING_IF_EXISTS;
using std::asin _LIBCPP_USING_IF_EXISTS;
using std::asinf _LIBCPP_USING_IF_EXISTS;
using std::asinl _LIBCPP_USING_IF_EXISTS;
using std::atan _LIBCPP_USING_IF_EXISTS;
using std::atanf _LIBCPP_USING_IF_EXISTS;
using std::atanl _LIBCPP_USING_IF_EXISTS;
using std::atan2 _LIBCPP_USING_IF_EXISTS;
using std::atan2f _LIBCPP_USING_IF_EXISTS;
using std::atan2l _LIBCPP_USING_IF_EXISTS;
using std::cos _LIBCPP_USING_IF_EXISTS;
using std::cosf _LIBCPP_USING_IF_EXISTS;
using std::cosl _LIBCPP_USING_IF_EXISTS;
using std::sin _LIBCPP_USING_IF_EXISTS;
using std::sinf _LIBCPP_USING_IF_EXISTS;
using std::sinl _LIBCPP_USING_IF_EXISTS;
using std::tan _LIBCPP_USING_IF_EXISTS;
using std::tanf _LIBCPP_USING_IF_EXISTS;
using std::tanl _LIBCPP_USING_IF_EXISTS;
using std::acosh _LIBCPP_USING_IF_EXISTS;
using std::acoshf _LIBCPP_USING_IF_EXISTS;
using std::acoshl _LIBCPP_USING_IF_EXISTS;
using std::asinh _LIBCPP_USING_IF_EXISTS;
using std::asinhf _LIBCPP_USING_IF_EXISTS;
using std::asinhl _LIBCPP_USING_IF_EXISTS;
using std::atanh _LIBCPP_USING_IF_EXISTS;
using std::atanhf _LIBCPP_USING_IF_EXISTS;
using std::atanhl _LIBCPP_USING_IF_EXISTS;
using std::cosh _LIBCPP_USING_IF_EXISTS;
using std::coshf _LIBCPP_USING_IF_EXISTS;
using std::coshl _LIBCPP_USING_IF_EXISTS;
using std::sinh _LIBCPP_USING_IF_EXISTS;
using std::sinhf _LIBCPP_USING_IF_EXISTS;
using std::sinhl _LIBCPP_USING_IF_EXISTS;
using std::tanh _LIBCPP_USING_IF_EXISTS;
using std::tanhf _LIBCPP_USING_IF_EXISTS;
using std::tanhl _LIBCPP_USING_IF_EXISTS;
using std::exp _LIBCPP_USING_IF_EXISTS;
using std::expf _LIBCPP_USING_IF_EXISTS;
using std::expl _LIBCPP_USING_IF_EXISTS;
using std::exp2 _LIBCPP_USING_IF_EXISTS;
using std::exp2f _LIBCPP_USING_IF_EXISTS;
using std::exp2l _LIBCPP_USING_IF_EXISTS;
using std::expm1 _LIBCPP_USING_IF_EXISTS;
using std::expm1f _LIBCPP_USING_IF_EXISTS;
using std::expm1l _LIBCPP_USING_IF_EXISTS;
using std::frexp _LIBCPP_USING_IF_EXISTS;
using std::frexpf _LIBCPP_USING_IF_EXISTS;
using std::frexpl _LIBCPP_USING_IF_EXISTS;
using std::ilogb _LIBCPP_USING_IF_EXISTS;
using std::ilogbf _LIBCPP_USING_IF_EXISTS;
using std::ilogbl _LIBCPP_USING_IF_EXISTS;
using std::ldexp _LIBCPP_USING_IF_EXISTS;
using std::ldexpf _LIBCPP_USING_IF_EXISTS;
using std::ldexpl _LIBCPP_USING_IF_EXISTS;
using std::log _LIBCPP_USING_IF_EXISTS;
using std::logf _LIBCPP_USING_IF_EXISTS;
using std::logl _LIBCPP_USING_IF_EXISTS;
using std::log10 _LIBCPP_USING_IF_EXISTS;
using std::log10f _LIBCPP_USING_IF_EXISTS;
using std::log10l _LIBCPP_USING_IF_EXISTS;
using std::log1p _LIBCPP_USING_IF_EXISTS;
using std::log1pf _LIBCPP_USING_IF_EXISTS;
using std::log1pl _LIBCPP_USING_IF_EXISTS;
using std::log2 _LIBCPP_USING_IF_EXISTS;
using std::log2f _LIBCPP_USING_IF_EXISTS;
using std::log2l _LIBCPP_USING_IF_EXISTS;
using std::logb _LIBCPP_USING_IF_EXISTS;
using std::logbf _LIBCPP_USING_IF_EXISTS;
using std::logbl _LIBCPP_USING_IF_EXISTS;
using std::modf _LIBCPP_USING_IF_EXISTS;
using std::modff _LIBCPP_USING_IF_EXISTS;
using std::modfl _LIBCPP_USING_IF_EXISTS;
using std::scalbn _LIBCPP_USING_IF_EXISTS;
using std::scalbnf _LIBCPP_USING_IF_EXISTS;
using std::scalbnl _LIBCPP_USING_IF_EXISTS;
using std::scalbln _LIBCPP_USING_IF_EXISTS;
using std::scalblnf _LIBCPP_USING_IF_EXISTS;
using std::scalblnl _LIBCPP_USING_IF_EXISTS;
using std::cbrt _LIBCPP_USING_IF_EXISTS;
using std::cbrtf _LIBCPP_USING_IF_EXISTS;
using std::cbrtl _LIBCPP_USING_IF_EXISTS;
// [c.math.abs], absolute values
using std::abs _LIBCPP_USING_IF_EXISTS;
using std::fabs _LIBCPP_USING_IF_EXISTS;
using std::fabsf _LIBCPP_USING_IF_EXISTS;
using std::fabsl _LIBCPP_USING_IF_EXISTS;
using std::hypot _LIBCPP_USING_IF_EXISTS;
using std::hypotf _LIBCPP_USING_IF_EXISTS;
using std::hypotl _LIBCPP_USING_IF_EXISTS;
// [c.math.hypot3], three-dimensional hypotenuse
using std::pow _LIBCPP_USING_IF_EXISTS;
using std::powf _LIBCPP_USING_IF_EXISTS;
using std::powl _LIBCPP_USING_IF_EXISTS;
using std::sqrt _LIBCPP_USING_IF_EXISTS;
using std::sqrtf _LIBCPP_USING_IF_EXISTS;
using std::sqrtl _LIBCPP_USING_IF_EXISTS;
using std::erf _LIBCPP_USING_IF_EXISTS;
using std::erff _LIBCPP_USING_IF_EXISTS;
using std::erfl _LIBCPP_USING_IF_EXISTS;
using std::erfc _LIBCPP_USING_IF_EXISTS;
using std::erfcf _LIBCPP_USING_IF_EXISTS;
using std::erfcl _LIBCPP_USING_IF_EXISTS;
using std::lgamma _LIBCPP_USING_IF_EXISTS;
using std::lgammaf _LIBCPP_USING_IF_EXISTS;
using std::lgammal _LIBCPP_USING_IF_EXISTS;
using std::tgamma _LIBCPP_USING_IF_EXISTS;
using std::tgammaf _LIBCPP_USING_IF_EXISTS;
using std::tgammal _LIBCPP_USING_IF_EXISTS;
using std::ceil _LIBCPP_USING_IF_EXISTS;
using std::ceilf _LIBCPP_USING_IF_EXISTS;
using std::ceill _LIBCPP_USING_IF_EXISTS;
using std::floor _LIBCPP_USING_IF_EXISTS;
using std::floorf _LIBCPP_USING_IF_EXISTS;
using std::floorl _LIBCPP_USING_IF_EXISTS;
using std::nearbyint _LIBCPP_USING_IF_EXISTS;
using std::nearbyintf _LIBCPP_USING_IF_EXISTS;
using std::nearbyintl _LIBCPP_USING_IF_EXISTS;
using std::rint _LIBCPP_USING_IF_EXISTS;
using std::rintf _LIBCPP_USING_IF_EXISTS;
using std::rintl _LIBCPP_USING_IF_EXISTS;
using std::lrint _LIBCPP_USING_IF_EXISTS;
using std::lrintf _LIBCPP_USING_IF_EXISTS;
using std::lrintl _LIBCPP_USING_IF_EXISTS;
using std::llrint _LIBCPP_USING_IF_EXISTS;
using std::llrintf _LIBCPP_USING_IF_EXISTS;
using std::llrintl _LIBCPP_USING_IF_EXISTS;
using std::round _LIBCPP_USING_IF_EXISTS;
using std::roundf _LIBCPP_USING_IF_EXISTS;
using std::roundl _LIBCPP_USING_IF_EXISTS;
using std::lround _LIBCPP_USING_IF_EXISTS;
using std::lroundf _LIBCPP_USING_IF_EXISTS;
using std::lroundl _LIBCPP_USING_IF_EXISTS;
using std::llround _LIBCPP_USING_IF_EXISTS;
using std::llroundf _LIBCPP_USING_IF_EXISTS;
using std::llroundl _LIBCPP_USING_IF_EXISTS;
using std::trunc _LIBCPP_USING_IF_EXISTS;
using std::truncf _LIBCPP_USING_IF_EXISTS;
using std::truncl _LIBCPP_USING_IF_EXISTS;
using std::fmod _LIBCPP_USING_IF_EXISTS;
using std::fmodf _LIBCPP_USING_IF_EXISTS;
using std::fmodl _LIBCPP_USING_IF_EXISTS;
using std::remainder _LIBCPP_USING_IF_EXISTS;
using std::remainderf _LIBCPP_USING_IF_EXISTS;
using std::remainderl _LIBCPP_USING_IF_EXISTS;
using std::remquo _LIBCPP_USING_IF_EXISTS;
using std::remquof _LIBCPP_USING_IF_EXISTS;
using std::remquol _LIBCPP_USING_IF_EXISTS;
using std::copysign _LIBCPP_USING_IF_EXISTS;
using std::copysignf _LIBCPP_USING_IF_EXISTS;
using std::copysignl _LIBCPP_USING_IF_EXISTS;
using std::nan _LIBCPP_USING_IF_EXISTS;
using std::nanf _LIBCPP_USING_IF_EXISTS;
using std::nanl _LIBCPP_USING_IF_EXISTS;
using std::nextafter _LIBCPP_USING_IF_EXISTS;
using std::nextafterf _LIBCPP_USING_IF_EXISTS;
using std::nextafterl _LIBCPP_USING_IF_EXISTS;
using std::nexttoward _LIBCPP_USING_IF_EXISTS;
using std::nexttowardf _LIBCPP_USING_IF_EXISTS;
using std::nexttowardl _LIBCPP_USING_IF_EXISTS;
using std::fdim _LIBCPP_USING_IF_EXISTS;
using std::fdimf _LIBCPP_USING_IF_EXISTS;
using std::fdiml _LIBCPP_USING_IF_EXISTS;
using std::fmax _LIBCPP_USING_IF_EXISTS;
using std::fmaxf _LIBCPP_USING_IF_EXISTS;
using std::fmaxl _LIBCPP_USING_IF_EXISTS;
using std::fmin _LIBCPP_USING_IF_EXISTS;
using std::fminf _LIBCPP_USING_IF_EXISTS;
using std::fminl _LIBCPP_USING_IF_EXISTS;
using std::fma _LIBCPP_USING_IF_EXISTS;
using std::fmaf _LIBCPP_USING_IF_EXISTS;
using std::fmal _LIBCPP_USING_IF_EXISTS;
// [c.math.lerp], linear interpolation
using std::lerp _LIBCPP_USING_IF_EXISTS;
// [c.math.fpclass], classification / comparison functions
using std::fpclassify _LIBCPP_USING_IF_EXISTS;
using std::isfinite _LIBCPP_USING_IF_EXISTS;
using std::isgreater _LIBCPP_USING_IF_EXISTS;
using std::isgreaterequal _LIBCPP_USING_IF_EXISTS;
using std::isinf _LIBCPP_USING_IF_EXISTS;
using std::isless _LIBCPP_USING_IF_EXISTS;
using std::islessequal _LIBCPP_USING_IF_EXISTS;
using std::islessgreater _LIBCPP_USING_IF_EXISTS;
using std::isnan _LIBCPP_USING_IF_EXISTS;
using std::isnormal _LIBCPP_USING_IF_EXISTS;
using std::isunordered _LIBCPP_USING_IF_EXISTS;
using std::signbit _LIBCPP_USING_IF_EXISTS;
// [sf.cmath], mathematical special functions
#if 0
// [sf.cmath.assoc.laguerre], associated Laguerre polynomials
using std::assoc_laguerre;
using std::assoc_laguerref;
using std::assoc_laguerrel;
// [sf.cmath.assoc.legendre], associated Legendre functions
using std::assoc_legendre;
using std::assoc_legendref;
using std::assoc_legendrel;
// [sf.cmath.beta], beta function
using std::beta;
using std::betaf;
using std::betal;
// [sf.cmath.comp.ellint.1], complete elliptic integral of the first kind
using std::comp_ellint_1;
using std::comp_ellint_1f;
using std::comp_ellint_1l;
// [sf.cmath.comp.ellint.2], complete elliptic integral of the second kind
using std::comp_ellint_2;
using std::comp_ellint_2f;
using std::comp_ellint_2l;
// [sf.cmath.comp.ellint.3], complete elliptic integral of the third kind
using std::comp_ellint_3;
using std::comp_ellint_3f;
using std::comp_ellint_3l;
// [sf.cmath.cyl.bessel.i], regular modified cylindrical Bessel functions
using std::cyl_bessel_i;
using std::cyl_bessel_if;
using std::cyl_bessel_il;
// [sf.cmath.cyl.bessel.j], cylindrical Bessel functions of the first kind
using std::cyl_bessel_j;
using std::cyl_bessel_jf;
using std::cyl_bessel_jl;
// [sf.cmath.cyl.bessel.k], irregular modified cylindrical Bessel functions
using std::cyl_bessel_k;
using std::cyl_bessel_kf;
using std::cyl_bessel_kl;
// [sf.cmath.cyl.neumann], cylindrical Neumann functions
// cylindrical Bessel functions of the second kind
using std::cyl_neumann;
using std::cyl_neumannf;
using std::cyl_neumannl;
// [sf.cmath.ellint.1], incomplete elliptic integral of the first kind
using std::ellint_1;
using std::ellint_1f;
using std::ellint_1l;
// [sf.cmath.ellint.2], incomplete elliptic integral of the second kind
using std::ellint_2;
using std::ellint_2f;
using std::ellint_2l;
// [sf.cmath.ellint.3], incomplete elliptic integral of the third kind
using std::ellint_3;
using std::ellint_3f;
using std::ellint_3l;
// [sf.cmath.expint], exponential integral
using std::expint;
using std::expintf;
using std::expintl;
#endif
// [sf.cmath.hermite], Hermite polynomials
using std::hermite;
using std::hermitef;
using std::hermitel;
#if 0
// [sf.cmath.laguerre], Laguerre polynomials
using std::laguerre;
using std::laguerref;
using std::laguerrel;
// [sf.cmath.legendre], Legendre polynomials
using std::legendre;
using std::legendref;
using std::legendrel;
// [sf.cmath.riemann.zeta], Riemann zeta function
using std::riemann_zeta;
using std::riemann_zetaf;
using std::riemann_zetal;
// [sf.cmath.sph.bessel], spherical Bessel functions of the first kind
using std::sph_bessel;
using std::sph_besself;
using std::sph_bessell;
// [sf.cmath.sph.legendre], spherical associated Legendre functions
using std::sph_legendre;
using std::sph_legendref;
using std::sph_legendrel;
// [sf.cmath.sph.neumann], spherical Neumann functions;
// spherical Bessel functions of the second kind
using std::sph_neumann;
using std::sph_neumannf;
using std::sph_neumannl;
#endif
} // namespace std
|
