Source: polyfill/Math.js

  1. // Licensed Materials - Property of IBM
  2. //
  3. // IBM Watson Analytics
  4. //
  5. // (C) Copyright IBM Corp. 2015
  6. //
  7. // US Government Users Restricted Rights - Use, duplication or
  8. // disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
  10. ( function( Math, ObjectPolyfill )
  11. {
  12. "use strict";
  14. // This module polyfills bitwise operations.
  15. /*jshint bitwise:false*/
  17. /**
  18.  * Polyfills for {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math Math}.
  19.  * @class module:barejs/polyfill.Math
  20.  */
  22. /** @lends module:barejs/polyfill.Math */
  23. var stat = {};
  25. /*istanbul ignore else: We test with __ES__ set to 3*/
  26. if ( __ES__ < 6 )
  27. {
  28.     /**
  29.      * The Math.cbrt() function returns the cube root of a number.
  30.      * @param {number} _x The number to get the cube root of.
  31.      * @returns {number} The cube root of the number
  32.      */
  33.     stat.cbrt = function cbrt( _x )
  34.     {
  35.         var y = Math.pow( Math.abs( _x ), 1/3 );
  36.         return _x < 0 ? -y : y;
  37.     };
  39.     /**
  40.      * The Math.expm1() function returns e^x - 1, where x is the argument, and e the base of the natural logarithms.
  41.      * @param {number} _x The number.
  42.      * @returns {number} A number representing e^x - 1, where e is Euler's number and x is the argument.
  43.      */
  44.     stat.expm1 = function expm1( _x )
  45.     {
  46.         return Math.exp( _x ) - 1;
  47.     };
  49.     /**
  50.      * The Math.hypot() function returns the square root of the sum of squares of its arguments.
  51.      * @returns {number} The square root of the sum of squares of its arguments.
  52.      */
  53.     stat.hypot = function hypot( _a, _b/*, ...*/ )
  54.     {
  55.         for ( var i = 0, len = arguments.length, y = 0, v; i < len; ++i )
  56.         {
  57.             v = Math.abs( arguments[i] );
  58.             if ( v === Infinity )
  59.                 return v;
  60.             y += v * v;
  61.         }
  62.         return Math.sqrt( y );
  63.     };
  65.     /**
  66.      * The Math.imul() function returns the result of the C-like 32-bit multiplication of the two parameters.
  67.      * @param {number} _a Operand A.
  68.      * @param {number} _b Operand B.
  69.      * @returns {number} The result of the multiplication.
  70.      */
  71.     stat.imul = function imul( _a, _b )
  72.     {
  73.         var ah = ( _a >>> 16 ) & 0xffff;
  74.         var al = _a & 0xffff;
  75.         var bh = ( _b >>> 16 ) & 0xffff;
  76.         var bl = _b & 0xffff;
  77.         // the shift by 0 fixes the sign on the high part
  78.         // the final |0 converts the unsigned value into a signed value
  79.         return ( ( al * bl ) + ( ( ( ah * bl + al * bh ) << 16 ) >>> 0 ) | 0 );
  80.     };
  82.     ( function()
  83.     {
  84.         var table = [
  85.               32, 31,  0,         16,  0, 30,  3,  0, 15,  0,  0,  0, 29, 10,  2,  0,
  86.                0,  0, 12,         14, 21,  0, 19,  0,  0, 28,  0, 25,  0,  9,  1,  0,
  87.               17,  0,  4,  undefined,  0,  0, 11,  0, 13, 22, 20,  0, 26,  0,  0, 18,
  88.                5,  0,  0,         23,  0, 27,  0,  6,  0, 24,  7,  0,  8,  0,  0,  0];
  90.         /**
  91.          * The Math.clz32() function returns the number of leading zero bits in the 32-bit binary representation of a number.
  92.          * "clz32" is short for CountLeadingZeroes32.
  93.          * @param {number} _x
  94.          * @returns {number}
  95.          */
  96.         stat.clz32 = function clz32( _x )
  97.         {
  98.             var v = _x >>> 0; // convert to unsigned integer
  100.             v |= v >>> 1;
  101.             v |= v >>> 2;
  102.             v |= v >>> 4;
  103.             v |= v >>> 8;
  104.             v |= v >>> 16;
  106.             return table[ Math.imul( v, 0x06EB14F9 ) >>> 26 ];
  107.         };
  108.     }() );
  110.     /**
  111.      * The Math.log1p() function returns the natural logarithm (base e) of 1 + a number.
  112.      * @param {number} _x The value to get the logarithm of.
  113.      * @returns {number} The logarithm of 1 + _x.
  114.      */
  115.     stat.log1p = function log1p( _x )
  116.     {
  117.         return Math.log( 1 + _x );
  118.     };
  120.     /**
  121.      * The Math.log2() function returns the base 2 logarithm of a number.
  122.      * @param {number} _x The value to get the base 2 logarithm of.
  123.      * @returns {number} The base 2 logarithm of _x.
  124.      */
  125.     stat.log2 = function log2( _x )
  126.     {
  127.         return Math.log( _x ) / Math.LN2;
  128.     };
  130.     /**
  131.      * The Math.log10() function returns the base 10 logarithm of a number.
  132.      * Note that this polyfill is subject to rounding errors.
  133.      * @param {number} _x The value to get the base 10 logarithm of.
  134.      * @returns {number} The base 10 logarithm of _x.
  135.      */
  136.     stat.log10 = function log10( _x )
  137.     {
  138.         return Math.log( _x ) / Math.LN10;
  139.     };
  141.     /**
  142.      * The Math.cosh() function returns the hyperbolic cosine of a number.
  143.      * @param {number} _x The value to calculate the cosine of.
  144.      * @returns {number} The hyperbolic cosine.
  145.      */
  146.     stat.cosh = function cosh( _x )
  147.     {
  148.         var y = Math.exp( _x );
  149.         return ( y + 1 / y ) / 2;
  150.     };
  152.     /**
  153.      * The Math.acosh() function returns the hyperbolic arc-cosine of a number.
  154.      * @param {number} _x The value to calculate the arc-cosine of.
  155.      * @returns {number} The hyperbolic arc-cosine.
  156.      */
  157.     stat.acosh = function acosh( _x )
  158.     {
  159.         return Math.log( _x + Math.sqrt( _x * _x - 1 ) );
  160.     };
  162.     /**
  163.      * The Math.sinh() function returns the hyperbolic sine of a number.
  164.      * @param {number} _x The value to calculate the sine of.
  165.      * @returns {number} The hyperbolic sine.
  166.      */
  167.     stat.sinh = function sinh( _x )
  168.     {
  169.         var y = Math.exp( _x );
  170.         return ( y - 1 / y ) / 2;
  171.     };
  173.     /**
  174.      * The Math.asinh() function returns the hyperbolic arcsine of a number.
  175.      * @param {number} _x The value to calculate the arcsine of.
  176.      * @returns {number} The hyperbolic arcsine.
  177.      */
  178.     stat.asinh = function asinh( _x )
  179.     {
  180.         if ( _x === -Infinity )
  181.             return _x;
  182.         else
  183.             return Math.log( _x + Math.sqrt( _x * _x + 1 ) );
  184.     };
  186.     /**
  187.      * The Math.tanh() function returns the hyperbolic tangent of a number.
  188.      * @param {number} _x The value to calculate the tangent of.
  189.      * @returns {number} The hyperbolic tangent.
  190.      */
  191.     stat.tanh = function tanh( _x )
  192.     {
  193.         var y;
  195.         if ( _x === Infinity )
  196.             return 1;
  197.         else if ( _x === -Infinity )
  198.             return -1;
  199.         else
  200.             return ( ( y = Math.exp( 2 * _x ) ) - 1) / ( y + 1 );
  201.     };
  203.     /**
  204.      * The Math.atanh() function returns the hyperbolic arctangent of a number.
  205.      * @param {number} _x The value to calculate the arctangent of.
  206.      * @returns {number} The hyperbolic arctangent.
  207.      */
  208.     stat.atanh = function atanh( _x )
  209.     {
  210.         return Math.log( ( 1 + _x ) / ( 1 - _x ) ) / 2;
  211.     };
  213.     /**
  214.      * The Math.sign() function returns the sign of a number, indicating whether the number is positive, negative or zero.
  215.      * @param {number} _x The number to check
  216.      * @returns {number} This function has 5 kinds of return values, 1, -1, 0, -0, NaN, which represent
  217.      *                  "positive number", "negative number", "positive zero", "negative zero" and NaN respectively.
  218.      */
  219.     stat.sign = function sign( _x )
  220.     {
  221.         _x = +_x; // convert to a number
  222.         if ( _x === 0 || isNaN( _x ) )
  223.             return _x;
  224.         return _x > 0 ? 1 : -1;
  225.     };
  227.     /**
  228.      * Unlike other three Math methods: Math.floor(), Math.ceil() and Math.round(), the way
  229.      * Math.trunc() works is very simple and straightforward, just truncate the dot and the digits
  230.      * behind it, no matter whether the argument is a positive number or a negative number.
  231.      * @param {number} _x The number to truncate.
  232.      * @returns {number} The truncated number
  233.      */
  234.     stat.trunc = function trunc( _x )
  235.     {
  236.         return _x < 0 ? Math.ceil( _x ) : Math.floor( _x );
  237.     };
  238. // End of ES6 polyfill scope
  239. }
  241. ObjectPolyfill.polyfill( Math, stat, null, exports, "Math" );
  243. // End of module
  244. }( Math, require( "./Object" ) ) );