tests/stress/math-log-basics.js

   1 // Basic cases of Math.log().
   2
   3 // log(NaN).
   4 function logNaN(antilogarithm) {
   5     return Math.log(antilogarithm);
   6 }
   7 noInline(logNaN);
   8
   9 function testLogNaN() {
  10     for (var i = 0; i < 10000; ++i) {
  11         var result = logNaN(NaN);
  12         if (!isNaN(result))
  13             throw "logNaN(NaN) = " + result + ", expected NaN";
  14     }
  15 }
  16 testLogNaN();
  17
  18
  19 // log(0).
  20 function logZero(antilogarithm) {
  21     return Math.log(antilogarithm);
  22 }
  23 noInline(logZero);
  24
  25 function testLogZero() {
  26     for (var i = 0; i < 10000; ++i) {
  27         var result = logZero(0);
  28         if (result !== -Infinity)
  29             throw "logZero(0) = " + result + ", expected -Infinity";
  30     }
  31 }
  32 testLogZero();
  33
  34
  35 // log(1).
  36 function logOne(antilogarithm) {
  37     return Math.log(antilogarithm);
  38 }
  39 noInline(logOne);
  40
  41 function testLogOne() {
  42     for (var i = 0; i < 10000; ++i) {
  43         var result = logOne(1);
  44         if (result !== 0)
  45             throw "logOne(1) = " + result + ", expected 0";
  46     }
  47 }
  48 testLogOne();
  49
  50
  51 // log(-1).
  52 function logMinusOne(antilogarithm) {
  53     return Math.log(antilogarithm);
  54 }
  55 noInline(logMinusOne);
  56
  57 function testLogMinusOne() {
  58     for (var i = 0; i < 10000; ++i) {
  59         var result = logMinusOne(-1);
  60         if (!isNaN(result))
  61             throw "logMinusOne(-1) = " + result + ", expected NaN";
  62     }
  63 }
  64 testLogMinusOne();
  65
  66
  67 // log(Infinity).
  68 function logInfinity(antilogarithm) {
  69     return Math.log(antilogarithm);
  70 }
  71 noInline(logInfinity);
  72
  73 function testLogInfinity() {
  74     for (var i = 0; i < 10000; ++i) {
  75         var result = logInfinity(Infinity);
  76         if (result !== Infinity)
  77             throw "logInfinity(Infinity) = " + result + ", expected Infinity";
  78     }
  79 }
  80 testLogInfinity();
  81
  82
  83 // log(-Infinity).
  84 function logMinusInfinity(antilogarithm) {
  85     return Math.log(antilogarithm);
  86 }
  87 noInline(logMinusInfinity);
  88
  89 function testLogMinusInfinity() {
  90     for (var i = 0; i < 10000; ++i) {
  91         var result = logMinusInfinity(-Infinity);
  92         if (!isNaN(result))
  93             throw "logMinusInfinity(-Infinity) = " + result + ", expected NaN";
  94     }
  95 }
  96 testLogMinusInfinity();
  97
  98
  99 // log(integer).
 100 function logInteger(antilogarithm) {
 101     return Math.log(antilogarithm);
 102 }
 103 noInline(logInteger);
 104
 105 function testLogInteger() {
 106     for (var i = 0; i < 10000; ++i) {
 107         var result = logInteger(42);
 108         if (result !== 3.7376696182833684)
 109             throw "logInteger(42) = " + result + ", expected 3.7376696182833684";
 110     }
 111 }
 112 testLogInteger();
 113
 114
 115 // log(double).
 116 function logDouble(antilogarithm) {
 117     return Math.log(antilogarithm);
 118 }
 119 noInline(logDouble);
 120
 121 function testLogDouble() {
 122     for (var i = 0; i < 10000; ++i) {
 123         var result = logDouble(Math.PI);
 124         if (result !== 1.1447298858494002)
 125             throw "logDouble(Math.PI) = " + result + ", expected 1.1447298858494002";
 126     }
 127 }
 128 testLogDouble();