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