Welcome to the Lounge

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

Matt Bond wrote:

When seeking consistency, I would wrap all of that in a utility class. This way I know it's consistent and works the same everywhere. If I need something a little different, then I either overload or add a default parameter as the occasion requires.

Matt Bond wrote:

I agree that storing the numerator and denominator would be the best way to prevent most headaches. In C#, I would use a Fraction struct for this (home grown if one doesn't exist already). Only collapse the fraction to a primitive type as necessary. This also has the benefit of letting you use money with a decimal value, so you don't have to do the extra math to get the cents back.

Matt Bond wrote:

Speaking of money, you only have to store 4 decimals with money to be accurate for accounting purposes.

Matt Bond wrote:

However, we don't do multiplication and division on the money.