JSPM

  • ESM via JSPM
  • ES Module Entrypoint
  • Export Map
  • Keywords
  • License
  • Repository URL
  • TypeScript Types
  • README
  • Created
  • Published
  • Downloads 720
  • Score
    100M100P100Q99250F
  • License MIT

A rounding library for JavaScript that behaves predictably (unlike Math.round, Math.floor, Math.ceil).

Package Exports

  • reliable-round

This package does not declare an exports field, so the exports above have been automatically detected and optimized by JSPM instead. If any package subpath is missing, it is recommended to post an issue to the original package (reliable-round) to support the "exports" field. If that is not possible, create a JSPM override to customize the exports field for this package.

Readme

reliable-round

A reliable rounding library for JavaScript/TypeScript that actually behaves predictably (unlike Math.round).

npm version Build Status Coverage Status

Install

npm install reliable-round --save

Usage

import { round } from "reliable-round";

console.log(round(1.005)); // Rounds to a whole integer, returning 1

console.log(round(1.005, 2)); // Rounds to 2 decimal places returning 1.01

Why do I need this?

Because JavaScript floating point math often results in quirky and unpredictable results.

The classic JS WTF example is:

console.log(0.1 + 0.2);

// Evaluates to 0.30000000000000004

Maybe not what you expected right?

As for rounding, lets say you need to round to 2 decimal places then you can create your own function like this:

function roundToTwoDecimalPlaces(value) {
  return Math.round(value * 100) / 100;
}

console.log(roundToTwoDecimalPlaces(1.006));

// Returns 1.01 - Correct!

At first glace, the output of the above function looks correct. But unfortunately its only correct some of the time!

console.log(roundToTwoDecimalPlaces(1.005));

// Returns 1 - Wrong!

// The correct answer is 1.01

If you deal with rounding many floats in JS you will inevitably encounter many quirky inconsistencies like this.

reliable-round to the rescue!

import { round } from "reliable-round";

console.log(round(1.005, 2));

// Correctly returns 1.01

While you will get predictable, reliable results using reliable-round be aware that it is at the expense of performance. Traditional methods of rounding that use the Math class are much faster but at the expense of accuracy. You need to decide what's more important for your use-case.

Contributing

Got an issue or a feature request? Log it.

Pull-requests are also welcome. 😸