Welcome to the Lounge

Amarnath S wrote:

we had DOUBLE PRECISION in Fortran and double in C.

1. Accounting rules require that calculations (e.g. multiplication, division) be performed with greater than 1 cent accuracy (5 decimal places, IIRC). This allows interest calculations, currency conversions etc. to work properly.
2. Rounding is performed using accounting rules - round to nearest or AWAY. The difference between this and round to nearest or EVEN is when the fraction is exactly 0.5. If this case, one rounds AWAY from 0. For example, 3.145 would round to nearest or EVEN as 3.14, but round to nearest or AWAY as 3.15.

Daniel Pfeffer wrote:

This is why COBOL has a decimal type.

Daniel Pfeffer wrote:

There may be other rules for accounting, but these are the major ones.

Jeremy Falcon wrote:

Had to give COBOL some love though.

Daniel Pfeffer wrote:

There may be other rules for accounting

Sander Rossel wrote:

.toFixed(x) should do the trick

Sander Rossel wrote:

But ultimately, I do all my calculations in C# that has a decent decimal type.

// this part at the top of the module

// according to the ECMAScript specification, the Number type uses double-precision floating points
// which have a 64-bit format (binary64), and consists of a sign bit with 11 exponent bits and 52
// fraction bits (each digit represents 4-bits, hence 64-bit values have a max of 16 decimals)
const MAX_DECIMALS = 16;

// ..........

/**
 * This will round off a number, but with special considerations for decimal places in a fractional
 * floating point number.
 * @param {number} number The number to round off.
 * @param {number} [decimals=0] The amount of decimal places, if any, to retain when rounding the number.
 * @returns {number} Returns the rounded number.
 */

export function roundOff(number: number, decimals = 0): number {
  const exponent = Math.min(Math.max(decimals, 0), MAX_DECIMALS);
  const factor = 10 ** exponent; // we're treating this as base 10

  // the value of Math.round(x) is the same as the value of Math.floor(x+0.5), except when x is −0 or is less
  // than 0 but greater than or equal to -0.5; for these cases Math.round(x) returns −0, but
  // Math.floor(x+0.5) returns +0. so, the last OR zero check looks for -0 and converts it to +0
  return (Math.round(((number || 0) + Number.EPSILON) * factor) || 0) / factor;
}

Sander Rossel wrote:

I once had a customer who wanted to calculate VAT for each sales order row and then got mad the total didn't add up due to rounding errors

Sander Rossel wrote:

You forgot shift, which removes the first element.

Sander Rossel wrote:

I just want to say array.remove(something); and it should remove something.

Sander Rossel wrote:

Everyone who says "splice is JavaScripts remove function" is dead wrong.

// given this
const data = [1, 2, 3, 4, 5];

// method 1, this is where you complain it takes two calls
delete data[2];
console.log(data.filter(x => x));

// method 2, this is where you complain it's not called "remove"
console.log(data.filter((x, i) => x !== 2));

// original method you didn't even bother to try, this mutates
// let me guess, never read the documentation on it?
data.splice(2, 1);
console.log(data);

// rounding off to two decimal places
1.005.toFixed(2); // outputs 1 instead of 1.01
Math.round(1.005 * 100) / 100; // outputs 1 instead of 1.01

Jeremy Falcon wrote:

complete accuracy on numbers