# BDS Software

## Javascript Rounding

I don't find the Math.round function in Javascript to be acceptable. When the decimal fraction of a number is exactly 0.5, Math.round always rounds up to the next highest integer. But, this is NOT in accordance with the accepted IEEE 754 standard.

Wikipedia - Nearest Integer Function says:

In computer science, the nearest integer function of real number x denoted variously by [ x ] ... or Round(x), is a function which returns the nearest integer to x. To avoid ambiguity when operating on half-integers, a rounding rule must be chosen. On most computer implementations, the selected rule is to round half-integers to the nearest even integer -- for example,

[ 1.25 ] = 1

[ 1.50 ] = 2

[ 1.75 ] = 2

[ 2.25 ] = 2

[ 2.50 ] = 2

[ 2.75 ] = 3

[ 3.25 ] = 3

[ 3.50 ] = 4

[ 3.75 ] = 4

[ 4.50 ] = 4

etc.

This is in accordance with the IEEE 754 standard and helps reduce bias in the result.

Therefore, I have written a function to more closely approximate the IEEE 754 standard's methodology. Since Javascript stores all numbers as 64-bit doubles (whether they're intended to be integers, floats, doubles, unsigned ints, or whatever), there is an inherent lack of precision in the sixteenth decimal place. Thus, my function ignores the sixteenth decimal place, and centers a 0.499999999999999 value on 0.500000000000000. The code for this mdjRound() function is:

``` function mdjRound(input) { var sgn, trunc, frac, frac15, frac15t, output; // Get the sign and absolute value of the input if (input < 0) { sgn = -1; input = -input; } else { sgn = 1; } // Get the integer portion of the input number trunc = parseInt(input); // Get the fractional portion of the input frac = input - trunc; // Multiply the fractional part by ten to the fifteenth //    to isolate the 16th digit of the fraction frac15 = frac * 1000000000000000; // Discard that 16th digit frac15t = parseInt(frac15); // Center the truncated equivalent fraction (tef) if (frac15t == 499999999999999) { frac15t = 500000000000000; } // Examine for tef = 0.5 exactly if (frac15t == 500000000000000) { // The tef = 0.5 exactly // Examine the integer part for even or odd if(trunc % 2 == 0) { // The trunc is even --> round down output = Math.floor(input); } else { // The trunc is odd --> round up output = Math.ceil(input); } } else { // The tef is NOT = 0.5 exactly output = Math.round(input); } output = output * sgn; return output; } ```

And here's the function in action, with a comparison of the results of Math.round() and mdjRound() for whichever number you enter:

Results:

For more details on how this all works, just right-click this page and then click on "View Page Source" (in FireFox - other browsers vary slightly but are generally similar).

M.D.J. 2018/06/08

----------

### References:

Wikipedia Nearest Integer. https://en.wikipedia.org/wiki/Nearest_integer_function.