js/src/jsmath.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
   2  * vim: set ts=8 sts=4 et sw=4 tw=99:
   3  * This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef jsmath_h
   8 #define jsmath_h
   9
  10 #include "mozilla/MemoryReporting.h"
  11
  12 #include "NamespaceImports.h"
  13
  14 #ifndef M_PI
  15 # define M_PI            3.14159265358979323846
  16 #endif
  17 #ifndef M_E
  18 # define M_E             2.7182818284590452354
  19 #endif
  20 #ifndef M_LOG2E
  21 # define M_LOG2E         1.4426950408889634074
  22 #endif
  23 #ifndef M_LOG10E
  24 # define M_LOG10E        0.43429448190325182765
  25 #endif
  26 #ifndef M_LN2
  27 # define M_LN2           0.69314718055994530942
  28 #endif
  29 #ifndef M_LN10
  30 # define M_LN10          2.30258509299404568402
  31 #endif
  32 #ifndef M_SQRT2
  33 # define M_SQRT2         1.41421356237309504880
  34 #endif
  35 #ifndef M_SQRT1_2
  36 # define M_SQRT1_2       0.70710678118654752440
  37 #endif
  38
  39 namespace js {
  40
  41 typedef double (*UnaryFunType)(double);
  42
  43 class MathCache
  44 {
  45   public:
  46     enum MathFuncId {
  47         Zero,
  48         Sin, Cos, Tan, Sinh, Cosh, Tanh, Asin, Acos, Atan, Asinh, Acosh, Atanh,
  49         Sqrt, Log, Log10, Log2, Log1p, Exp, Expm1, Cbrt, Trunc, Sign
  50     };
  51
  52   private:
  53     static const unsigned SizeLog2 = 12;
  54     static const unsigned Size = 1 << SizeLog2;
  55     struct Entry { double in; MathFuncId id; double out; };
  56     Entry table[Size];
  57
  58   public:
  59     MathCache();
  60
  61     unsigned hash(double x, MathFuncId id) {
  62         union { double d; struct { uint32_t one, two; } s; } u = { x };
  63         uint32_t hash32 = u.s.one ^ u.s.two;
  64         hash32 += uint32_t(id) << 8;
  65         uint16_t hash16 = uint16_t(hash32 ^ (hash32 >> 16));
  66         return (hash16 & (Size - 1)) ^ (hash16 >> (16 - SizeLog2));
  67     }
  68
  69     /*
  70      * N.B. lookup uses double-equality. This is only safe if hash() maps +0
  71      * and -0 to different table entries, which is asserted in MathCache().
  72      */
  73     double lookup(UnaryFunType f, double x, MathFuncId id) {
  74         unsigned index = hash(x, id);
  75         Entry& e = table[index];
  76         if (e.in == x && e.id == id)
  77             return e.out;
  78         e.in = x;
  79         e.id = id;
  80         return e.out = f(x);
  81     }
  82
  83     size_t sizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf);
  84 };
  85
  86 } /* namespace js */
  87
  88 /*
  89  * JS math functions.
  90  */
  91
  92 extern JSObject*
  93 js_InitMathClass(JSContext* cx, js::HandleObject obj);
  94
  95 namespace js {
  96
  97 extern void
  98 random_initState(uint64_t* rngState);
  99
 100 extern uint64_t
 101 random_next(uint64_t* rngState, int bits);
 102
 103 static const double RNG_DSCALE = double(1LL << 53);
 104
 105 inline double
 106 random_nextDouble(uint64_t* rng)
 107 {
 108     return double((random_next(rng, 26) << 27) + random_next(rng, 27)) / RNG_DSCALE;
 109 }
 110
 111 extern double
 112 math_random_no_outparam(JSContext* cx);
 113
 114 extern bool
 115 math_random(JSContext* cx, unsigned argc, js::Value* vp);
 116
 117 extern bool
 118 math_abs_handle(JSContext* cx, js::HandleValue v, js::MutableHandleValue r);
 119
 120 extern bool
 121 math_abs(JSContext* cx, unsigned argc, js::Value* vp);
 122
 123 extern double
 124 math_max_impl(double x, double y);
 125
 126 extern bool
 127 math_max(JSContext* cx, unsigned argc, js::Value* vp);
 128
 129 extern double
 130 math_min_impl(double x, double y);
 131
 132 extern bool
 133 math_min(JSContext* cx, unsigned argc, js::Value* vp);
 134
 135 extern bool
 136 math_sqrt(JSContext* cx, unsigned argc, js::Value* vp);
 137
 138 extern bool
 139 math_pow_handle(JSContext* cx, js::HandleValue base, js::HandleValue power,
 140                 js::MutableHandleValue result);
 141
 142 extern bool
 143 math_pow(JSContext* cx, unsigned argc, js::Value* vp);
 144
 145 extern bool
 146 minmax_impl(JSContext* cx, bool max, js::HandleValue a, js::HandleValue b,
 147             js::MutableHandleValue res);
 148
 149 extern bool
 150 math_sqrt_handle(JSContext* cx, js::HandleValue number, js::MutableHandleValue result);
 151
 152 extern bool
 153 math_imul(JSContext* cx, unsigned argc, js::Value* vp);
 154
 155 extern bool
 156 RoundFloat32(JSContext* cx, HandleValue v, float* out);
 157
 158 extern bool
 159 RoundFloat32(JSContext* cx, HandleValue arg, MutableHandleValue res);
 160
 161 extern bool
 162 math_fround(JSContext* cx, unsigned argc, js::Value* vp);
 163
 164 extern bool
 165 math_log(JSContext* cx, unsigned argc, js::Value* vp);
 166
 167 extern double
 168 math_log_impl(MathCache* cache, double x);
 169
 170 extern double
 171 math_log_uncached(double x);
 172
 173 extern bool
 174 math_sin(JSContext* cx, unsigned argc, js::Value* vp);
 175
 176 extern double
 177 math_sin_impl(MathCache* cache, double x);
 178
 179 extern double
 180 math_sin_uncached(double x);
 181
 182 extern bool
 183 math_sin_handle(JSContext* cx, HandleValue val, MutableHandleValue res);
 184
 185 extern bool
 186 math_cos(JSContext* cx, unsigned argc, js::Value* vp);
 187
 188 extern double
 189 math_cos_impl(MathCache* cache, double x);
 190
 191 extern double
 192 math_cos_uncached(double x);
 193
 194 extern bool
 195 math_exp(JSContext* cx, unsigned argc, js::Value* vp);
 196
 197 extern double
 198 math_exp_impl(MathCache* cache, double x);
 199
 200 extern double
 201 math_exp_uncached(double x);
 202
 203 extern bool
 204 math_tan(JSContext* cx, unsigned argc, js::Value* vp);
 205
 206 extern double
 207 math_tan_impl(MathCache* cache, double x);
 208
 209 extern double
 210 math_tan_uncached(double x);
 211
 212 extern bool
 213 math_log10(JSContext* cx, unsigned argc, js::Value* vp);
 214
 215 extern bool
 216 math_log2(JSContext* cx, unsigned argc, js::Value* vp);
 217
 218 extern bool
 219 math_log1p(JSContext* cx, unsigned argc, js::Value* vp);
 220
 221 extern bool
 222 math_expm1(JSContext* cx, unsigned argc, js::Value* vp);
 223
 224 extern bool
 225 math_cosh(JSContext* cx, unsigned argc, js::Value* vp);
 226
 227 extern bool
 228 math_sinh(JSContext* cx, unsigned argc, js::Value* vp);
 229
 230 extern bool
 231 math_tanh(JSContext* cx, unsigned argc, js::Value* vp);
 232
 233 extern bool
 234 math_acosh(JSContext* cx, unsigned argc, js::Value* vp);
 235
 236 extern bool
 237 math_asinh(JSContext* cx, unsigned argc, js::Value* vp);
 238
 239 extern bool
 240 math_atanh(JSContext* cx, unsigned argc, js::Value* vp);
 241
 242 extern double
 243 ecmaHypot(double x, double y);
 244
 245 extern bool
 246 math_hypot(JSContext* cx, unsigned argc, Value* vp);
 247
 248 extern bool
 249 math_hypot_handle(JSContext* cx, HandleValueArray args, MutableHandleValue res);
 250
 251 extern bool
 252 math_trunc(JSContext* cx, unsigned argc, Value* vp);
 253
 254 extern bool
 255 math_sign(JSContext* cx, unsigned argc, Value* vp);
 256
 257 extern bool
 258 math_cbrt(JSContext* cx, unsigned argc, Value* vp);
 259
 260 extern bool
 261 math_asin(JSContext* cx, unsigned argc, Value* vp);
 262
 263 extern bool
 264 math_acos(JSContext* cx, unsigned argc, Value* vp);
 265
 266 extern bool
 267 math_atan(JSContext* cx, unsigned argc, Value* vp);
 268
 269 extern bool
 270 math_atan2_handle(JSContext* cx, HandleValue y, HandleValue x, MutableHandleValue res);
 271
 272 extern bool
 273 math_atan2(JSContext* cx, unsigned argc, Value* vp);
 274
 275 extern double
 276 ecmaAtan2(double x, double y);
 277
 278 extern double
 279 math_atan_impl(MathCache* cache, double x);
 280
 281 extern double
 282 math_atan_uncached(double x);
 283
 284 extern bool
 285 math_atan(JSContext* cx, unsigned argc, js::Value* vp);
 286
 287 extern double
 288 math_asin_impl(MathCache* cache, double x);
 289
 290 extern double
 291 math_asin_uncached(double x);
 292
 293 extern bool
 294 math_asin(JSContext* cx, unsigned argc, js::Value* vp);
 295
 296 extern double
 297 math_acos_impl(MathCache* cache, double x);
 298
 299 extern double
 300 math_acos_uncached(double x);
 301
 302 extern bool
 303 math_acos(JSContext* cx, unsigned argc, js::Value* vp);
 304
 305 extern bool
 306 math_ceil(JSContext* cx, unsigned argc, Value* vp);
 307
 308 extern double
 309 math_ceil_impl(double x);
 310
 311 extern bool
 312 math_clz32(JSContext* cx, unsigned argc, Value* vp);
 313
 314 extern bool
 315 math_floor_handle(JSContext* cx, HandleValue v, MutableHandleValue r);
 316
 317 extern bool
 318 math_floor(JSContext* cx, unsigned argc, Value* vp);
 319
 320 extern double
 321 math_floor_impl(double x);
 322
 323 template<typename T>
 324 extern T GetBiggestNumberLessThan(T x);
 325
 326 extern bool
 327 math_round_handle(JSContext* cx, HandleValue arg, MutableHandleValue res);
 328
 329 extern bool
 330 math_round(JSContext* cx, unsigned argc, Value* vp);
 331
 332 extern double
 333 math_round_impl(double x);
 334
 335 extern float
 336 math_roundf_impl(float x);
 337
 338 extern double
 339 powi(double x, int y);
 340
 341 extern double
 342 ecmaPow(double x, double y);
 343
 344 extern bool
 345 math_imul(JSContext* cx, unsigned argc, Value* vp);
 346
 347 extern double
 348 math_log10_impl(MathCache* cache, double x);
 349
 350 extern double
 351 math_log10_uncached(double x);
 352
 353 extern double
 354 math_log2_impl(MathCache* cache, double x);
 355
 356 extern double
 357 math_log2_uncached(double x);
 358
 359 extern double
 360 math_log1p_impl(MathCache* cache, double x);
 361
 362 extern double
 363 math_log1p_uncached(double x);
 364
 365 extern double
 366 math_expm1_impl(MathCache* cache, double x);
 367
 368 extern double
 369 math_expm1_uncached(double x);
 370
 371 extern double
 372 math_cosh_impl(MathCache* cache, double x);
 373
 374 extern double
 375 math_cosh_uncached(double x);
 376
 377 extern double
 378 math_sinh_impl(MathCache* cache, double x);
 379
 380 extern double
 381 math_sinh_uncached(double x);
 382
 383 extern double
 384 math_tanh_impl(MathCache* cache, double x);
 385
 386 extern double
 387 math_tanh_uncached(double x);
 388
 389 extern double
 390 math_acosh_impl(MathCache* cache, double x);
 391
 392 extern double
 393 math_acosh_uncached(double x);
 394
 395 extern double
 396 math_asinh_impl(MathCache* cache, double x);
 397
 398 extern double
 399 math_asinh_uncached(double x);
 400
 401 extern double
 402 math_atanh_impl(MathCache* cache, double x);
 403
 404 extern double
 405 math_atanh_uncached(double x);
 406
 407 extern double
 408 math_trunc_impl(MathCache* cache, double x);
 409
 410 extern double
 411 math_trunc_uncached(double x);
 412
 413 extern double
 414 math_sign_impl(MathCache* cache, double x);
 415
 416 extern double
 417 math_sign_uncached(double x);
 418
 419 extern double
 420 math_cbrt_impl(MathCache* cache, double x);
 421
 422 extern double
 423 math_cbrt_uncached(double x);
 424
 425 } /* namespace js */
 426
 427 #endif /* jsmath_h */