js/src/jsmath.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
   2  *
   3  * ***** BEGIN LICENSE BLOCK *****
   4  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version
   7  * 1.1 (the "License"); you may not use this file except in compliance with
   8  * the License. You may obtain a copy of the License at
   9  * http://www.mozilla.org/MPL/
  10  *
  11  * Software distributed under the License is distributed on an "AS IS" basis,
  12  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13  * for the specific language governing rights and limitations under the
  14  * License.
  15  *
  16  * The Original Code is Mozilla Communicator client code, released
  17  * March 31, 1998.
  18  *
  19  * The Initial Developer of the Original Code is
  20  * Netscape Communications Corporation.
  21  * Portions created by the Initial Developer are Copyright (C) 1998
  22  * the Initial Developer. All Rights Reserved.
  23  *
  24  * Contributor(s):
  25  *
  26  * Alternatively, the contents of this file may be used under the terms of
  27  * either of the GNU General Public License Version 2 or later (the "GPL"),
  28  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  29  * in which case the provisions of the GPL or the LGPL are applicable instead
  30  * of those above. If you wish to allow use of your version of this file only
  31  * under the terms of either the GPL or the LGPL, and not to allow others to
  32  * use your version of this file under the terms of the MPL, indicate your
  33  * decision by deleting the provisions above and replace them with the notice
  34  * and other provisions required by the GPL or the LGPL. If you do not delete
  35  * the provisions above, a recipient may use your version of this file under
  36  * the terms of any one of the MPL, the GPL or the LGPL.
  37  *
  38  * ***** END LICENSE BLOCK ***** */
  39
  40 /*
  41  * JS math package.
  42  */
  43 #include <stdlib.h>
  44 #include "jstypes.h"
  45 #include "jsstdint.h"
  46 #include "jslong.h"
  47 #include "prmjtime.h"
  48 #include "jsapi.h"
  49 #include "jsatom.h"
  50 #include "jsbuiltins.h"
  51 #include "jscntxt.h"
  52 #include "jsversion.h"
  53 #include "jslock.h"
  54 #include "jsmath.h"
  55 #include "jsnum.h"
  56 #include "jslibmath.h"
  57 #include "jsobj.h"
  58
  59 extern jsdouble js_NaN;
  60
  61 #ifndef M_E
  62 #define M_E             2.7182818284590452354
  63 #endif
  64 #ifndef M_LOG2E
  65 #define M_LOG2E         1.4426950408889634074
  66 #endif
  67 #ifndef M_LOG10E
  68 #define M_LOG10E        0.43429448190325182765
  69 #endif
  70 #ifndef M_LN2
  71 #define M_LN2           0.69314718055994530942
  72 #endif
  73 #ifndef M_LN10
  74 #define M_LN10          2.30258509299404568402
  75 #endif
  76 #ifndef M_PI
  77 #define M_PI            3.14159265358979323846
  78 #endif
  79 #ifndef M_SQRT2
  80 #define M_SQRT2         1.41421356237309504880
  81 #endif
  82 #ifndef M_SQRT1_2
  83 #define M_SQRT1_2       0.70710678118654752440
  84 #endif
  85
  86 static JSConstDoubleSpec math_constants[] = {
  87     {M_E,       "E",            0, {0,0,0}},
  88     {M_LOG2E,   "LOG2E",        0, {0,0,0}},
  89     {M_LOG10E,  "LOG10E",       0, {0,0,0}},
  90     {M_LN2,     "LN2",          0, {0,0,0}},
  91     {M_LN10,    "LN10",         0, {0,0,0}},
  92     {M_PI,      "PI",           0, {0,0,0}},
  93     {M_SQRT2,   "SQRT2",        0, {0,0,0}},
  94     {M_SQRT1_2, "SQRT1_2",      0, {0,0,0}},
  95     {0,0,0,{0,0,0}}
  96 };
  97
  98 JSClass js_MathClass = {
  99     js_Math_str,
 100     JSCLASS_HAS_CACHED_PROTO(JSProto_Math),
 101     JS_PropertyStub,  JS_PropertyStub,  JS_PropertyStub,  JS_PropertyStub,
 102     JS_EnumerateStub, JS_ResolveStub,   JS_ConvertStub,   NULL,
 103     JSCLASS_NO_OPTIONAL_MEMBERS
 104 };
 105
 106 static JSBool
 107 math_abs(JSContext *cx, uintN argc, jsval *vp)
 108 {
 109     jsdouble x, z;
 110
 111     if (argc == 0) {
 112         *vp = DOUBLE_TO_JSVAL(cx->runtime->jsNaN);
 113         return JS_TRUE;
 114     }
 115     x = js_ValueToNumber(cx, &vp[2]);
 116     if (JSVAL_IS_NULL(vp[2]))
 117         return JS_FALSE;
 118     z = fabs(x);
 119     return js_NewNumberInRootedValue(cx, z, vp);
 120 }
 121
 122 static JSBool
 123 math_acos(JSContext *cx, uintN argc, jsval *vp)
 124 {
 125     jsdouble x, z;
 126
 127     if (argc == 0) {
 128         *vp = DOUBLE_TO_JSVAL(cx->runtime->jsNaN);
 129         return JS_TRUE;
 130     }
 131     x = js_ValueToNumber(cx, &vp[2]);
 132     if (JSVAL_IS_NULL(vp[2]))
 133         return JS_FALSE;
 134 #if defined(SOLARIS) && defined(__GNUC__)
 135     if (x < -1 || 1 < x) {
 136         *vp = DOUBLE_TO_JSVAL(cx->runtime->jsNaN);
 137         return JS_TRUE;
 138     }
 139 #endif
 140     z = acos(x);
 141     return js_NewNumberInRootedValue(cx, z, vp);
 142 }
 143
 144 static JSBool
 145 math_asin(JSContext *cx, uintN argc, jsval *vp)
 146 {
 147     jsdouble x, z;
 148
 149     if (argc == 0) {
 150         *vp = DOUBLE_TO_JSVAL(cx->runtime->jsNaN);
 151         return JS_TRUE;
 152     }
 153     x = js_ValueToNumber(cx, &vp[2]);
 154     if (JSVAL_IS_NULL(vp[2]))
 155         return JS_FALSE;
 156 #if defined(SOLARIS) && defined(__GNUC__)
 157     if (x < -1 || 1 < x) {
 158         *vp = DOUBLE_TO_JSVAL(cx->runtime->jsNaN);
 159         return JS_TRUE;
 160     }
 161 #endif
 162     z = asin(x);
 163     return js_NewNumberInRootedValue(cx, z, vp);
 164 }
 165
 166 static JSBool
 167 math_atan(JSContext *cx, uintN argc, jsval *vp)
 168 {
 169     jsdouble x, z;
 170
 171     if (argc == 0) {
 172         *vp = DOUBLE_TO_JSVAL(cx->runtime->jsNaN);
 173         return JS_TRUE;
 174     }
 175     x = js_ValueToNumber(cx, &vp[2]);
 176     if (JSVAL_IS_NULL(vp[2]))
 177         return JS_FALSE;
 178     z = atan(x);
 179     return js_NewNumberInRootedValue(cx, z, vp);
 180 }
 181
 182 static inline jsdouble JS_FASTCALL
 183 math_atan2_kernel(jsdouble x, jsdouble y)
 184 {
 185 #if defined(_MSC_VER)
 186     /*
 187      * MSVC's atan2 does not yield the result demanded by ECMA when both x
 188      * and y are infinite.
 189      * - The result is a multiple of pi/4.
 190      * - The sign of x determines the sign of the result.
 191      * - The sign of y determines the multiplicator, 1 or 3.
 192      */
 193     if (JSDOUBLE_IS_INFINITE(x) && JSDOUBLE_IS_INFINITE(y)) {
 194         jsdouble z = js_copysign(M_PI / 4, x);
 195         if (y < 0)
 196             z *= 3;
 197         return z;
 198     }
 199 #endif
 200
 201 #if defined(SOLARIS) && defined(__GNUC__)
 202     if (x == 0) {
 203         if (JSDOUBLE_IS_NEGZERO(y))
 204             return js_copysign(M_PI, x);
 205         if (y == 0)
 206             return x;
 207     }
 208 #endif
 209     return atan2(x, y);
 210 }
 211
 212 static JSBool
 213 math_atan2(JSContext *cx, uintN argc, jsval *vp)
 214 {
 215     jsdouble x, y;
 216
 217     if (argc <= 1) {
 218         *vp = DOUBLE_TO_JSVAL(cx->runtime->jsNaN);
 219         return JS_TRUE;
 220     }
 221     x = js_ValueToNumber(cx, &vp[2]);
 222     if (JSVAL_IS_NULL(vp[2]))
 223         return JS_FALSE;
 224     y = js_ValueToNumber(cx, &vp[3]);
 225     if (JSVAL_IS_NULL(vp[3]))
 226         return JS_FALSE;
 227     return js_NewNumberInRootedValue(cx, math_atan2_kernel (x, y), vp);
 228 }
 229
 230 static inline jsdouble JS_FASTCALL
 231 math_ceil_kernel(jsdouble x)
 232 {
 233 #ifdef __APPLE__
 234     if (x < 0 && x > -1.0)
 235         return js_copysign(0, -1);
 236 #endif
 237     return ceil(x);
 238 }
 239
 240 static JSBool
 241 math_ceil(JSContext *cx, uintN argc, jsval *vp)
 242 {
 243     jsdouble x, z;
 244
 245     if (argc == 0) {
 246         *vp = DOUBLE_TO_JSVAL(cx->runtime->jsNaN);
 247         return JS_TRUE;
 248     }
 249     x = js_ValueToNumber(cx, &vp[2]);
 250     if (JSVAL_IS_NULL(vp[2]))
 251         return JS_FALSE;
 252     z = math_ceil_kernel(x);
 253     return js_NewNumberInRootedValue(cx, z, vp);
 254 }
 255
 256 static JSBool
 257 math_cos(JSContext *cx, uintN argc, jsval *vp)
 258 {
 259     jsdouble x, z;
 260
 261     if (argc == 0) {
 262         *vp = DOUBLE_TO_JSVAL(cx->runtime->jsNaN);
 263         return JS_TRUE;
 264     }
 265     x = js_ValueToNumber(cx, &vp[2]);
 266     if (JSVAL_IS_NULL(vp[2]))
 267         return JS_FALSE;
 268     z = cos(x);
 269     return js_NewNumberInRootedValue(cx, z, vp);
 270 }
 271
 272 static JSBool
 273 math_exp(JSContext *cx, uintN argc, jsval *vp)
 274 {
 275     jsdouble x, z;
 276
 277     if (argc == 0) {
 278         *vp = DOUBLE_TO_JSVAL(cx->runtime->jsNaN);
 279         return JS_TRUE;
 280     }
 281     x = js_ValueToNumber(cx, &vp[2]);
 282     if (JSVAL_IS_NULL(vp[2]))
 283         return JS_FALSE;
 284 #ifdef _WIN32
 285     if (!JSDOUBLE_IS_NaN(x)) {
 286         if (x == *cx->runtime->jsPositiveInfinity) {
 287             *vp = DOUBLE_TO_JSVAL(cx->runtime->jsPositiveInfinity);
 288             return JS_TRUE;
 289         }
 290         if (x == *cx->runtime->jsNegativeInfinity) {
 291             *vp = JSVAL_ZERO;
 292             return JS_TRUE;
 293         }
 294     }
 295 #endif
 296     z = exp(x);
 297     return js_NewNumberInRootedValue(cx, z, vp);
 298 }
 299
 300 static JSBool
 301 math_floor(JSContext *cx, uintN argc, jsval *vp)
 302 {
 303     jsdouble x, z;
 304
 305     if (argc == 0) {
 306         *vp = DOUBLE_TO_JSVAL(cx->runtime->jsNaN);
 307         return JS_TRUE;
 308     }
 309     x = js_ValueToNumber(cx, &vp[2]);
 310     if (JSVAL_IS_NULL(vp[2]))
 311         return JS_FALSE;
 312     z = floor(x);
 313     return js_NewNumberInRootedValue(cx, z, vp);
 314 }
 315
 316 static JSBool
 317 math_log(JSContext *cx, uintN argc, jsval *vp)
 318 {
 319     jsdouble x, z;
 320
 321     if (argc == 0) {
 322         *vp = DOUBLE_TO_JSVAL(cx->runtime->jsNaN);
 323         return JS_TRUE;
 324     }
 325     x = js_ValueToNumber(cx, &vp[2]);
 326     if (JSVAL_IS_NULL(vp[2]))
 327         return JS_FALSE;
 328 #if defined(SOLARIS) && defined(__GNUC__)
 329     if (x < 0) {
 330         *vp = DOUBLE_TO_JSVAL(cx->runtime->jsNaN);
 331         return JS_TRUE;
 332     }
 333 #endif
 334     z = log(x);
 335     return js_NewNumberInRootedValue(cx, z, vp);
 336 }
 337
 338 static JSBool
 339 math_max(JSContext *cx, uintN argc, jsval *vp)
 340 {
 341     jsdouble x, z = *cx->runtime->jsNegativeInfinity;
 342     jsval *argv;
 343     uintN i;
 344
 345     if (argc == 0) {
 346         *vp = DOUBLE_TO_JSVAL(cx->runtime->jsNegativeInfinity);
 347         return JS_TRUE;
 348     }
 349     argv = vp + 2;
 350     for (i = 0; i < argc; i++) {
 351         x = js_ValueToNumber(cx, &argv[i]);
 352         if (JSVAL_IS_NULL(argv[i]))
 353             return JS_FALSE;
 354         if (JSDOUBLE_IS_NaN(x)) {
 355             *vp = DOUBLE_TO_JSVAL(cx->runtime->jsNaN);
 356             return JS_TRUE;
 357         }
 358         if (x == 0 && x == z) {
 359             if (js_copysign(1.0, z) == -1)
 360                 z = x;
 361         } else {
 362             z = (x > z) ? x : z;
 363         }
 364     }
 365     return js_NewNumberInRootedValue(cx, z, vp);
 366 }
 367
 368 static JSBool
 369 math_min(JSContext *cx, uintN argc, jsval *vp)
 370 {
 371     jsdouble x, z = *cx->runtime->jsPositiveInfinity;
 372     jsval *argv;
 373     uintN i;
 374
 375     if (argc == 0) {
 376         *vp = DOUBLE_TO_JSVAL(cx->runtime->jsPositiveInfinity);
 377         return JS_TRUE;
 378     }
 379     argv = vp + 2;
 380     for (i = 0; i < argc; i++) {
 381         x = js_ValueToNumber(cx, &argv[i]);
 382         if (JSVAL_IS_NULL(argv[i]))
 383             return JS_FALSE;
 384         if (JSDOUBLE_IS_NaN(x)) {
 385             *vp = DOUBLE_TO_JSVAL(cx->runtime->jsNaN);
 386             return JS_TRUE;
 387         }
 388         if (x == 0 && x == z) {
 389             if (js_copysign(1.0, x) == -1)
 390                 z = x;
 391         } else {
 392             z = (x < z) ? x : z;
 393         }
 394     }
 395     return js_NewNumberInRootedValue(cx, z, vp);
 396 }
 397
 398 static JSBool
 399 math_pow(JSContext *cx, uintN argc, jsval *vp)
 400 {
 401     jsdouble x, y, z;
 402
 403     if (argc <= 1) {
 404         *vp = DOUBLE_TO_JSVAL(cx->runtime->jsNaN);
 405         return JS_TRUE;
 406     }
 407     x = js_ValueToNumber(cx, &vp[2]);
 408     if (JSVAL_IS_NULL(vp[2]))
 409         return JS_FALSE;
 410     y = js_ValueToNumber(cx, &vp[3]);
 411     if (JSVAL_IS_NULL(vp[3]))
 412         return JS_FALSE;
 413     /*
 414      * Because C99 and ECMA specify different behavior for pow(),
 415      * we need to wrap the libm call to make it ECMA compliant.
 416      */
 417     if (!JSDOUBLE_IS_FINITE(y) && (x == 1.0 || x == -1.0)) {
 418         *vp = DOUBLE_TO_JSVAL(cx->runtime->jsNaN);
 419         return JS_TRUE;
 420     }
 421     /* pow(x, +-0) is always 1, even for x = NaN. */
 422     if (y == 0) {
 423         *vp = JSVAL_ONE;
 424         return JS_TRUE;
 425     }
 426     z = pow(x, y);
 427     return js_NewNumberInRootedValue(cx, z, vp);
 428 }
 429
 430 /*
 431  * Math.random() support, lifted from java.util.Random.java.
 432  */
 433 static void
 434 random_setSeed(JSRuntime *rt, int64 seed)
 435 {
 436     int64 tmp;
 437
 438     JSLL_I2L(tmp, 1000);
 439     JSLL_DIV(seed, seed, tmp);
 440     JSLL_XOR(tmp, seed, rt->rngMultiplier);
 441     JSLL_AND(rt->rngSeed, tmp, rt->rngMask);
 442 }
 443
 444 void
 445 js_random_init(JSRuntime *rt)
 446 {
 447     int64 tmp, tmp2;
 448
 449     /* Do at most once. */
 450     if (rt->rngInitialized)
 451         return;
 452     rt->rngInitialized = JS_TRUE;
 453
 454     /* rt->rngMultiplier = 0x5DEECE66DL */
 455     JSLL_ISHL(tmp, 0x5, 32);
 456     JSLL_UI2L(tmp2, 0xDEECE66DL);
 457     JSLL_OR(rt->rngMultiplier, tmp, tmp2);
 458
 459     /* rt->rngAddend = 0xBL */
 460     JSLL_I2L(rt->rngAddend, 0xBL);
 461
 462     /* rt->rngMask = (1L << 48) - 1 */
 463     JSLL_I2L(tmp, 1);
 464     JSLL_SHL(tmp2, tmp, 48);
 465     JSLL_SUB(rt->rngMask, tmp2, tmp);
 466
 467     /* rt->rngDscale = (jsdouble)(1L << 53) */
 468     JSLL_SHL(tmp2, tmp, 53);
 469     JSLL_L2D(rt->rngDscale, tmp2);
 470
 471     /* Finally, set the seed from current time. */
 472     random_setSeed(rt, PRMJ_Now());
 473 }
 474
 475 static uint32
 476 random_next(JSRuntime *rt, int bits)
 477 {
 478     int64 nextseed, tmp;
 479     uint32 retval;
 480
 481     JSLL_MUL(nextseed, rt->rngSeed, rt->rngMultiplier);
 482     JSLL_ADD(nextseed, nextseed, rt->rngAddend);
 483     JSLL_AND(nextseed, nextseed, rt->rngMask);
 484     rt->rngSeed = nextseed;
 485     JSLL_USHR(tmp, nextseed, 48 - bits);
 486     JSLL_L2I(retval, tmp);
 487     return retval;
 488 }
 489
 490 jsdouble
 491 js_random_nextDouble(JSRuntime *rt)
 492 {
 493     int64 tmp, tmp2;
 494     jsdouble d;
 495
 496     JSLL_ISHL(tmp, random_next(rt, 26), 27);
 497     JSLL_UI2L(tmp2, random_next(rt, 27));
 498     JSLL_ADD(tmp, tmp, tmp2);
 499     JSLL_L2D(d, tmp);
 500     return d / rt->rngDscale;
 501 }
 502
 503 static JSBool
 504 math_random(JSContext *cx, uintN argc, jsval *vp)
 505 {
 506     JSRuntime *rt;
 507     jsdouble z;
 508
 509     rt = cx->runtime;
 510     JS_LOCK_RUNTIME(rt);
 511     js_random_init(rt);
 512     z = js_random_nextDouble(rt);
 513     JS_UNLOCK_RUNTIME(rt);
 514     return js_NewNumberInRootedValue(cx, z, vp);
 515 }
 516
 517 #if defined _WIN32 && !defined WINCE && _MSC_VER < 1400
 518 /* Try to work around apparent _copysign bustage in VC6 and VC7. */
 519 double
 520 js_copysign(double x, double y)
 521 {
 522     jsdpun xu, yu;
 523
 524     xu.d = x;
 525     yu.d = y;
 526     xu.s.hi &= ~JSDOUBLE_HI32_SIGNBIT;
 527     xu.s.hi |= yu.s.hi & JSDOUBLE_HI32_SIGNBIT;
 528     return xu.d;
 529 }
 530 #endif
 531
 532 static JSBool
 533 math_round(JSContext *cx, uintN argc, jsval *vp)
 534 {
 535     jsdouble x, z;
 536
 537     if (argc == 0) {
 538         *vp = DOUBLE_TO_JSVAL(cx->runtime->jsNaN);
 539         return JS_TRUE;
 540     }
 541     x = js_ValueToNumber(cx, &vp[2]);
 542     if (JSVAL_IS_NULL(vp[2]))
 543         return JS_FALSE;
 544     z = js_copysign(floor(x + 0.5), x);
 545     return js_NewNumberInRootedValue(cx, z, vp);
 546 }
 547
 548 static JSBool
 549 math_sin(JSContext *cx, uintN argc, jsval *vp)
 550 {
 551     jsdouble x, z;
 552
 553     if (argc == 0) {
 554         *vp = DOUBLE_TO_JSVAL(cx->runtime->jsNaN);
 555         return JS_TRUE;
 556     }
 557     x = js_ValueToNumber(cx, &vp[2]);
 558     if (JSVAL_IS_NULL(vp[2]))
 559         return JS_FALSE;
 560     z = sin(x);
 561     return js_NewNumberInRootedValue(cx, z, vp);
 562 }
 563
 564 static JSBool
 565 math_sqrt(JSContext *cx, uintN argc, jsval *vp)
 566 {
 567     jsdouble x, z;
 568
 569     if (argc == 0) {
 570         *vp = DOUBLE_TO_JSVAL(cx->runtime->jsNaN);
 571         return JS_TRUE;
 572     }
 573     x = js_ValueToNumber(cx, &vp[2]);
 574     if (JSVAL_IS_NULL(vp[2]))
 575         return JS_FALSE;
 576     z = sqrt(x);
 577     return js_NewNumberInRootedValue(cx, z, vp);
 578 }
 579
 580 static JSBool
 581 math_tan(JSContext *cx, uintN argc, jsval *vp)
 582 {
 583     jsdouble x, z;
 584
 585     if (argc == 0) {
 586         *vp = DOUBLE_TO_JSVAL(cx->runtime->jsNaN);
 587         return JS_TRUE;
 588     }
 589     x = js_ValueToNumber(cx, &vp[2]);
 590     if (JSVAL_IS_NULL(vp[2]))
 591         return JS_FALSE;
 592     z = tan(x);
 593     return js_NewNumberInRootedValue(cx, z, vp);
 594 }
 595
 596 #if JS_HAS_TOSOURCE
 597 static JSBool
 598 math_toSource(JSContext *cx, uintN argc, jsval *vp)
 599 {
 600     *vp = ATOM_KEY(CLASS_ATOM(cx, Math));
 601     return JS_TRUE;
 602 }
 603 #endif
 604
 605 #ifdef JS_TRACER
 606
 607 #define MATH_BUILTIN_1(name) MATH_BUILTIN_CFUN_1(name, name)
 608 #define MATH_BUILTIN_CFUN_1(name, cfun)                                       \
 609     static jsdouble FASTCALL math_##name##_tn(jsdouble d) { return cfun(d); } \
 610     JS_DEFINE_TRCINFO_1(math_##name,                                          \
 611         (1, (static, DOUBLE, math_##name##_tn, DOUBLE, 1, 1)))
 612
 613 MATH_BUILTIN_CFUN_1(abs, fabs)
 614 MATH_BUILTIN_1(atan)
 615 MATH_BUILTIN_1(sin)
 616 MATH_BUILTIN_1(cos)
 617 MATH_BUILTIN_1(sqrt)
 618 MATH_BUILTIN_1(floor)
 619 MATH_BUILTIN_1(tan)
 620
 621 static jsdouble FASTCALL
 622 math_acos_tn(jsdouble d)
 623 {
 624 #if defined(SOLARIS) && defined(__GNUC__)
 625     if (d < -1 || 1 < d) {
 626         return js_NaN;
 627     }
 628 #endif
 629     return acos(d);
 630 }
 631
 632 static jsdouble FASTCALL
 633 math_asin_tn(jsdouble d)
 634 {
 635 #if defined(SOLARIS) && defined(__GNUC__)
 636     if (d < -1 || 1 < d) {
 637         return js_NaN;
 638     }
 639 #endif
 640     return asin(d);
 641 }
 642
 643 #ifdef _WIN32
 644
 645 static jsdouble FASTCALL
 646 math_exp_tn(JSContext *cx, jsdouble d)
 647 {
 648     if (!JSDOUBLE_IS_NaN(d)) {
 649         if (d == *cx->runtime->jsPositiveInfinity) {
 650             return *cx->runtime->jsPositiveInfinity;
 651         }
 652         if (d == *cx->runtime->jsNegativeInfinity) {
 653             return 0.0;
 654         }
 655     }
 656     return exp(d);
 657 }
 658
 659 JS_DEFINE_TRCINFO_1(math_exp,
 660     (2, (static, DOUBLE, math_exp_tn,  CONTEXT, DOUBLE,  1, 1)))
 661
 662 #else
 663
 664 MATH_BUILTIN_1(exp)
 665
 666 #endif
 667
 668 static jsdouble FASTCALL
 669 math_log_tn(jsdouble d)
 670 {
 671 #if defined(SOLARIS) && defined(__GNUC__)
 672     if (d < 0)
 673         return js_NaN;
 674 #endif
 675     return log(d);
 676 }
 677
 678 static jsdouble FASTCALL
 679 math_max_tn(jsdouble d, jsdouble p)
 680 {
 681     if (JSDOUBLE_IS_NaN(d) || JSDOUBLE_IS_NaN(p))
 682         return js_NaN;
 683
 684     if (p == 0 && p == d) {
 685         // Max prefers 0.0 to -0.0.
 686         if (js_copysign(1.0, d) == -1)
 687             return p;
 688         return d;
 689     }
 690     return (p > d) ? p : d;
 691 }
 692
 693 static jsdouble FASTCALL
 694 math_min_tn(jsdouble d, jsdouble p)
 695 {
 696     if (JSDOUBLE_IS_NaN(d) || JSDOUBLE_IS_NaN(p))
 697         return js_NaN;
 698
 699     if (p == 0 && p == d) {
 700         // Min prefers -0.0 to 0.0.
 701         if (js_copysign (1.0, p) == -1)
 702             return p;
 703         return d;
 704     }
 705     return (p < d) ? p : d;
 706 }
 707
 708 static jsdouble FASTCALL
 709 math_pow_tn(jsdouble d, jsdouble p)
 710 {
 711     if (!JSDOUBLE_IS_FINITE(p) && (d == 1.0 || d == -1.0))
 712         return js_NaN;
 713     if (p == 0)
 714         return 1.0;
 715     return pow(d, p);
 716 }
 717
 718 static jsdouble FASTCALL
 719 math_random_tn(JSRuntime* rt)
 720 {
 721     JS_LOCK_RUNTIME(rt);
 722     js_random_init(rt);
 723     jsdouble z = js_random_nextDouble(rt);
 724     JS_UNLOCK_RUNTIME(rt);
 725     return z;
 726 }
 727
 728 static jsdouble FASTCALL
 729 math_round_tn(jsdouble x)
 730 {
 731     return js_copysign(floor(x + 0.5), x);
 732 }
 733
 734 static jsdouble FASTCALL
 735 math_ceil_tn(jsdouble x)
 736 {
 737     return math_ceil_kernel(x);
 738 }
 739
 740 JS_DEFINE_TRCINFO_1(math_acos,
 741     (1, (static, DOUBLE, math_acos_tn, DOUBLE,          1, 1)))
 742 JS_DEFINE_TRCINFO_1(math_asin,
 743     (1, (static, DOUBLE, math_asin_tn, DOUBLE,          1, 1)))
 744 JS_DEFINE_TRCINFO_1(math_atan2,
 745     (2, (static, DOUBLE, math_atan2_kernel, DOUBLE, DOUBLE, 1, 1)))
 746 JS_DEFINE_TRCINFO_1(math_log,
 747     (1, (static, DOUBLE, math_log_tn, DOUBLE,           1, 1)))
 748 JS_DEFINE_TRCINFO_1(math_max,
 749     (2, (static, DOUBLE, math_max_tn, DOUBLE, DOUBLE,   1, 1)))
 750 JS_DEFINE_TRCINFO_1(math_min,
 751     (2, (static, DOUBLE, math_min_tn, DOUBLE, DOUBLE,   1, 1)))
 752 JS_DEFINE_TRCINFO_1(math_pow,
 753     (2, (static, DOUBLE, math_pow_tn, DOUBLE, DOUBLE,   1, 1)))
 754 JS_DEFINE_TRCINFO_1(math_random,
 755     (1, (static, DOUBLE, math_random_tn, RUNTIME,       0, 0)))
 756 JS_DEFINE_TRCINFO_1(math_round,
 757     (1, (static, DOUBLE, math_round_tn, DOUBLE,         1, 1)))
 758 JS_DEFINE_TRCINFO_1(math_ceil,
 759     (1, (static, DOUBLE, math_ceil_tn, DOUBLE,          1, 1)))
 760
 761 #endif /* JS_TRACER */
 762
 763 static JSFunctionSpec math_static_methods[] = {
 764 #if JS_HAS_TOSOURCE
 765     JS_FN(js_toSource_str,  math_toSource,        0, 0),
 766 #endif
 767     JS_TN("abs",            math_abs,             1, 0, math_abs_trcinfo),
 768     JS_TN("acos",           math_acos,            1, 0, math_acos_trcinfo),
 769     JS_TN("asin",           math_asin,            1, 0, math_asin_trcinfo),
 770     JS_TN("atan",           math_atan,            1, 0, math_atan_trcinfo),
 771     JS_TN("atan2",          math_atan2,           2, 0, math_atan2_trcinfo),
 772     JS_TN("ceil",           math_ceil,            1, 0, math_ceil_trcinfo),
 773     JS_TN("cos",            math_cos,             1, 0, math_cos_trcinfo),
 774     JS_TN("exp",            math_exp,             1, 0, math_exp_trcinfo),
 775     JS_TN("floor",          math_floor,           1, 0, math_floor_trcinfo),
 776     JS_TN("log",            math_log,             1, 0, math_log_trcinfo),
 777     JS_TN("max",            math_max,             2, 0, math_max_trcinfo),
 778     JS_TN("min",            math_min,             2, 0, math_min_trcinfo),
 779     JS_TN("pow",            math_pow,             2, 0, math_pow_trcinfo),
 780     JS_TN("random",         math_random,          0, 0, math_random_trcinfo),
 781     JS_TN("round",          math_round,           1, 0, math_round_trcinfo),
 782     JS_TN("sin",            math_sin,             1, 0, math_sin_trcinfo),
 783     JS_TN("sqrt",           math_sqrt,            1, 0, math_sqrt_trcinfo),
 784     JS_TN("tan",            math_tan,             1, 0, math_tan_trcinfo),
 785     JS_FS_END
 786 };
 787
 788 JSObject *
 789 js_InitMathClass(JSContext *cx, JSObject *obj)
 790 {
 791     JSObject *Math;
 792
 793     Math = JS_NewObject(cx, &js_MathClass, NULL, obj);
 794     if (!Math)
 795         return NULL;
 796     if (!JS_DefineProperty(cx, obj, js_Math_str, OBJECT_TO_JSVAL(Math),
 797                            JS_PropertyStub, JS_PropertyStub, 0)) {
 798         return NULL;
 799     }
 800
 801     if (!JS_DefineFunctions(cx, Math, math_static_methods))
 802         return NULL;
 803     if (!JS_DefineConstDoubles(cx, Math, math_constants))
 804         return NULL;
 805     return Math;
 806 }