libcxx/modules/std/cmath.inc

   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
  10 export 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