| // The following is adapted from fdlibm (http://www.netlib.org/fdlibm), |
| // |
| // ==================================================== |
| // Copyright (C) 1993-2004 by Sun Microsystems, Inc. All rights reserved. |
| // |
| // Developed at SunSoft, a Sun Microsystems, Inc. business. |
| // Permission to use, copy, modify, and distribute this |
| // software is freely granted, provided that this notice |
| // is preserved. |
| // ==================================================== |
| // |
| // The original source code covered by the above license above has been |
| // modified significantly by Google Inc. |
| // Copyright 2014 the V8 project authors. All rights reserved. |
| // |
| // The following is a straightforward translation of fdlibm routines |
| // by Raymond Toy (rtoy@google.com). |
| |
| (function(global, utils) { |
| |
| "use strict"; |
| |
| %CheckIsBootstrapping(); |
| |
| // ------------------------------------------------------------------- |
| // Imports |
| |
| var GlobalMath = global.Math; |
| var MathAbs; |
| var MathExpm1; |
| |
| utils.Import(function(from) { |
| MathAbs = from.MathAbs; |
| MathExpm1 = from.MathExpm1; |
| }); |
| |
| // ES6 draft 09-27-13, section 20.2.2.30. |
| // Math.sinh |
| // Method : |
| // mathematically sinh(x) if defined to be (exp(x)-exp(-x))/2 |
| // 1. Replace x by |x| (sinh(-x) = -sinh(x)). |
| // 2. |
| // E + E/(E+1) |
| // 0 <= x <= 22 : sinh(x) := --------------, E=expm1(x) |
| // 2 |
| // |
| // 22 <= x <= lnovft : sinh(x) := exp(x)/2 |
| // lnovft <= x <= ln2ovft: sinh(x) := exp(x/2)/2 * exp(x/2) |
| // ln2ovft < x : sinh(x) := x*shuge (overflow) |
| // |
| // Special cases: |
| // sinh(x) is |x| if x is +Infinity, -Infinity, or NaN. |
| // only sinh(0)=0 is exact for finite x. |
| // |
| define KSINH_OVERFLOW = 710.4758600739439; |
| define TWO_M28 = 3.725290298461914e-9; // 2^-28, empty lower half |
| define LOG_MAXD = 709.7822265625; // 0x40862e42 00000000, empty lower half |
| |
| function MathSinh(x) { |
| x = x * 1; // Convert to number. |
| var h = (x < 0) ? -0.5 : 0.5; |
| // |x| in [0, 22]. return sign(x)*0.5*(E+E/(E+1)) |
| var ax = MathAbs(x); |
| if (ax < 22) { |
| // For |x| < 2^-28, sinh(x) = x |
| if (ax < TWO_M28) return x; |
| var t = MathExpm1(ax); |
| if (ax < 1) return h * (2 * t - t * t / (t + 1)); |
| return h * (t + t / (t + 1)); |
| } |
| // |x| in [22, log(maxdouble)], return 0.5 * exp(|x|) |
| if (ax < LOG_MAXD) return h * %math_exp(ax); |
| // |x| in [log(maxdouble), overflowthreshold] |
| // overflowthreshold = 710.4758600739426 |
| if (ax <= KSINH_OVERFLOW) { |
| var w = %math_exp(0.5 * ax); |
| var t = h * w; |
| return t * w; |
| } |
| // |x| > overflowthreshold or is NaN. |
| // Return Infinity of the appropriate sign or NaN. |
| return x * INFINITY; |
| } |
| |
| |
| // ES6 draft 09-27-13, section 20.2.2.12. |
| // Math.cosh |
| // Method : |
| // mathematically cosh(x) if defined to be (exp(x)+exp(-x))/2 |
| // 1. Replace x by |x| (cosh(x) = cosh(-x)). |
| // 2. |
| // [ exp(x) - 1 ]^2 |
| // 0 <= x <= ln2/2 : cosh(x) := 1 + ------------------- |
| // 2*exp(x) |
| // |
| // exp(x) + 1/exp(x) |
| // ln2/2 <= x <= 22 : cosh(x) := ------------------- |
| // 2 |
| // 22 <= x <= lnovft : cosh(x) := exp(x)/2 |
| // lnovft <= x <= ln2ovft: cosh(x) := exp(x/2)/2 * exp(x/2) |
| // ln2ovft < x : cosh(x) := huge*huge (overflow) |
| // |
| // Special cases: |
| // cosh(x) is |x| if x is +INF, -INF, or NaN. |
| // only cosh(0)=1 is exact for finite x. |
| // |
| define KCOSH_OVERFLOW = 710.4758600739439; |
| |
| function MathCosh(x) { |
| x = x * 1; // Convert to number. |
| var ix = %_DoubleHi(x) & 0x7fffffff; |
| // |x| in [0,0.5*log2], return 1+expm1(|x|)^2/(2*exp(|x|)) |
| if (ix < 0x3fd62e43) { |
| var t = MathExpm1(MathAbs(x)); |
| var w = 1 + t; |
| // For |x| < 2^-55, cosh(x) = 1 |
| if (ix < 0x3c800000) return w; |
| return 1 + (t * t) / (w + w); |
| } |
| // |x| in [0.5*log2, 22], return (exp(|x|)+1/exp(|x|)/2 |
| if (ix < 0x40360000) { |
| var t = %math_exp(MathAbs(x)); |
| return 0.5 * t + 0.5 / t; |
| } |
| // |x| in [22, log(maxdouble)], return half*exp(|x|) |
| if (ix < 0x40862e42) return 0.5 * %math_exp(MathAbs(x)); |
| // |x| in [log(maxdouble), overflowthreshold] |
| if (MathAbs(x) <= KCOSH_OVERFLOW) { |
| var w = %math_exp(0.5 * MathAbs(x)); |
| var t = 0.5 * w; |
| return t * w; |
| } |
| if (NUMBER_IS_NAN(x)) return x; |
| // |x| > overflowthreshold. |
| return INFINITY; |
| } |
| |
| // ES6 draft 09-27-13, section 20.2.2.33. |
| // Math.tanh(x) |
| // Method : |
| // x -x |
| // e - e |
| // 0. tanh(x) is defined to be ----------- |
| // x -x |
| // e + e |
| // 1. reduce x to non-negative by tanh(-x) = -tanh(x). |
| // 2. 0 <= x <= 2**-55 : tanh(x) := x*(one+x) |
| // -t |
| // 2**-55 < x <= 1 : tanh(x) := -----; t = expm1(-2x) |
| // t + 2 |
| // 2 |
| // 1 <= x <= 22.0 : tanh(x) := 1- ----- ; t = expm1(2x) |
| // t + 2 |
| // 22.0 < x <= INF : tanh(x) := 1. |
| // |
| // Special cases: |
| // tanh(NaN) is NaN; |
| // only tanh(0) = 0 is exact for finite argument. |
| // |
| |
| define TWO_M55 = 2.77555756156289135105e-17; // 2^-55, empty lower half |
| |
| function MathTanh(x) { |
| x = x * 1; // Convert to number. |
| // x is Infinity or NaN |
| if (!NUMBER_IS_FINITE(x)) { |
| if (x > 0) return 1; |
| if (x < 0) return -1; |
| return x; |
| } |
| |
| var ax = MathAbs(x); |
| var z; |
| // |x| < 22 |
| if (ax < 22) { |
| if (ax < TWO_M55) { |
| // |x| < 2^-55, tanh(small) = small. |
| return x; |
| } |
| if (ax >= 1) { |
| // |x| >= 1 |
| var t = MathExpm1(2 * ax); |
| z = 1 - 2 / (t + 2); |
| } else { |
| var t = MathExpm1(-2 * ax); |
| z = -t / (t + 2); |
| } |
| } else { |
| // |x| > 22, return +/- 1 |
| z = 1; |
| } |
| return (x >= 0) ? z : -z; |
| } |
| |
| //------------------------------------------------------------------- |
| |
| utils.InstallFunctions(GlobalMath, DONT_ENUM, [ |
| "sinh", MathSinh, |
| "cosh", MathCosh, |
| "tanh", MathTanh |
| ]); |
| |
| }) |