Math in V8 is Broken

Athan Reines / @kgryte

Standard Library

ES5

ES2015/ES6

Comparison

Golang

Golang (cont.)

So what?

Bugs

V8 and Node

Math.sin/Math.cos

var x = Math.pow( 2, 120 );
// returns 1.329227995784916e+36

var y = Math.sin( x );
// returns: -0.8783788442551665
// expected: 0.377820109360752

y = Math.cos( x );
// returns:   0.47796506772457525
// expected: -0.9258790228548378
				

NaN

var nan1 = 0.0 / 0.0;
var nan2 = Number.POSITIVE_INFINITY / Number.POSITIVE_INFINITY;

var arr = [ nan1, nan2 ];
var FLOAT64_VIEW = new Float64Array( arr );
var INT32_VIEW = new Int32Array( FLOAT64_VIEW.buffer );

var isnan1 = ( FLOAT64_VIEW[0] !== FLOAT64_VIEW[0] );
// returns true

var isnan2 = ( FLOAT64_VIEW[1] !== FLOAT64_VIEW[1] );
// returns true

var bool = ( nan1 !== nan2 );
// returns true

var int11 = INT32_VIEW[ 0 ];
var int12 = INT32_VIEW[ 1 ];
var int21 = INT32_VIEW[ 2 ];
var int22 = INT32_VIEW[ 3 ];

console.log( '%d|%d and %d|%d', int11, int12, int21, int22 );
// => 0|2146959360 and 0|-524288
				

Math.pow

var x = Math.pow( 10, 308 );
// returns:  1.0000000000000006e+308
// expected: 1.0e+308
				

Algorithm

function pow( x, y ) {
    var m = x;
    var n = y;
    var p = 1;
    while ( n !== 0 ) {
        if ( ( n & 1 ) !== 0 ) {
            p *= m;
        }
        m *= m;
        if ( ( n & 2 ) !== 0 ) {
            p *= m;
        }
        m *= m;
        n >>= 2;
    }
    return p;
}
				

Math.atanh

var y = Math.atanh( 1.0e-10 );
// returns:  1.000000082640371e-10
// expected: 1.0e-10
				

Math.acosh

var y = Math.acosh( 1.0 + 1.0e-10 );
// returns:  0.000014142136208733941
// expected: 0.000014142136208675862
				

Math.asinh

var y = Math.asinh( 1.0e-50 );
// returns:  0.0
// expected: 1.0e-50

y = Math.asinh( 1.0e200 );
// returns   +infinity
// expected: 461.2101657793691
				

Algorithm

function asinh( x ) {
    if ( x === 0 || !isFinite( x ) ) {
        return x;
    }
    if ( x > 0 ) {
        return Math.log( x + Math.sqrt( x*x + 1 ) );
    }
    return -Math.log( -x + Math.sqrt( x*x + 1 ) );
}
				

Algorithm

function asinh( x ) {
    var sgn;
    var xx;
    var t;
    if ( isnan( x ) || isinfinite( x ) ) {
        return x;
    }
    if ( x < 0.0 ) {
        x = -x;
        sgn = true;
    }
    // Case: |x| < 2**-28
    if ( x < NEAR_ZERO ) {
        t = x;
    }
    // Case: |x| > 2**28
    else if ( x > HUGE ) {
        t = ln( x ) + LN2;
    }
    // Case: 2**28 > |x| > 2.0
    else if ( x > 2.0 ) {
        t = ln( 2.0*x + 1.0/(sqrt(x*x + 1.0) + x) );
    }
    // Case: 2.0 > |x| > 2**-28
    else {
        xx = x * x;
        t = log1p( x + xx/(1.0 + sqrt(1.0 + xx)) );
    }
    return sgn ? -t : t;
}
				

Math.exp

var y = Math.exp( 100.0 );
// returns:  2.6881171418161485e+43
// expected: 2.6881171418161356e+43
				

Math.exp

Math.random

uint32_t state0 = 1;
uint32_t state1 = 2;
uint32_t mwc1616() {
  state0 = 18030 * (state0 & 0xffff) + (state0 >> 16);
  state1 = 30903 * (state1 & 0xffff) + (state1 >> 16);
  return state0 << 16 + (state1 & 0xffff);
}
				

Example

var ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';

function randomString( length ) {
    var randint;
    var str;
    var i;

    str = '';
    for ( i = 0; i < length; i++ ) {
        randint = Math.floor( Math.random() * ALPHABET.length );
        str += ALPHABET.substring( randint, randint+1 );
    }
    return str;
}
					

JavaScript

Community

Polyfills

var isFinite = require( 'is-finite' );

module.exports = function asinh( x ) {
    if ( x === 0 || !isFinite( x ) ) {
        return x;
    }
    return x < 0 ? -asinh( -x ) : Math.log( x + Math.sqrt( x*x + 1 ) );
}
				

Libraries

function asinh( x ) {
  return Math.log( Math.sqrt( x*x + 1 ) + x );
}
				

:(

github.com/stdlib-js/stdlib

Opportunities

Get Involved!

Advocate

Thank you!

Athan Reines / @kgryte

https://github.com/stdlib-js/stdlib

Appendix

What can be done at the specification level?

• Int64 (and bitwise ops)
• Typed Objects
• WebCL
• SIMD (long)
• Parallel Computing
• Operator Overloading
• Web Assembly

Integer Support

• discussion
• gist
• Int64 in R

Typed Objects

• spec
• explainer
• typed data structures in Go

WebCL

• node-opencl

SIMD

• polyfill
• Intel announcement
• MDN
• presentation

Parallel Computing

• Data parallelism
• Task parallelism
• Scheduler
• Lock-free programming
• Shared Memory Web Workers

Operator Overloading

• operator-overloading-js
• paper.js
• paper.js source

The End