@numio/bigmath 1.0.2 → 1.0.3

package/README.md

@@ -29,9 +29,15 @@ This library is particularly useful in scenarios where precise calculations with
 
 ### Latest update
 
-In version 1.0.0 arguments for calculation changed to array, which increases performance dramatically \
-In version 0.3.0 added handling of negative numbers \
-In version 0.2.0 added division (int & float numbers)
+Added rounding
+* round up
+* round down
+* half-up
+* half-down
+* half-even
+* half-odd
+* decimal places to be rounded
+* significant figures decimals to be rounded
 
 # Install:
 
@@ -107,6 +113,59 @@ const negative = div(["-2", "-3", "2"]); // 3
 div("10", "3"); // 3.33333
 ```
 
+### Round
+```javascript
+round("-1.12345"); // -1
+round("1.5"); // 2
+round("1.0"); // 1
+round("0.00001"); // 0
+round("9.9"); // 10
+```
+
+### Round at position
+```javascript
+round("1.12345", { decimals: 1 }); // 1.1
+round("1.12345", { decimals: 2 }); // 1.12
+round("1.12234", { decimals: 0 }); // 1
+round("9.999", { decimals: 2 }); // 10
+```
+
+### Round modes
+```javascript
+round("1.11", { decimals: 1, roundMode: "up" }); // 1.2
+round("1.19", { decimals: 1, roundMode: "up" }); // 1.2
+
+round("1.11", { decimals: 1, roundMode: "down" }); // 1.1
+round("1.19", { decimals: 1, roundMode: "down" }); // 1.1
+
+round("1.15", { decimals: 1, roundMode: "half-up" }); // 1.2
+round("1.15", { decimals: 1, roundMode: "half-down" }); // 1.1
+
+round("1.15", { decimals: 1, roundMode: "half-even" }); // 1.2
+round("1.25", { decimals: 1, roundMode: "half-even" }); // 1.2
+round("1.35", { decimals: 1, roundMode: "half-even" }); // 1.4
+round("1.45", { decimals: 1, roundMode: "half-even" }); // 1.4
+round("1.55", { decimals: 1, roundMode: "half-even" }); // 1.6
+
+round("1.15", { decimals: 1, roundMode: "half-odd" }); // 1.1
+round("1.25", { decimals: 1, roundMode: "half-odd" }); // 1.3
+round("1.35", { decimals: 1, roundMode: "half-odd" }); // 1.3
+round("1.45", { decimals: 1, roundMode: "half-odd" }); // 1.5
+round("1.55", { decimals: 1, roundMode: "half-odd" }); // 1.5
+```
+
+### Round with "significant figures" flag
+```javascript
+round("0.000119", { decimals: 2, sigFig: false }); // 0
+round("0.000119", { decimals: 2, sigFig: true }); // 0.00012
+
+round("0.0019", { decimals: 1, sigFig: true, roundMode: "down" }); // 0.001
+round("0.0011", { decimals: 1, sigFig: true, roundMode: "up" }); // 0.002
+
+round("1.000119", { decimals: 2, sigFig: false }); // 1
+round("1.000119", { decimals: 2, sigFig: true }); // 1
+```
+
 Does not have a limitation on the number of digits. You can use any length you'd
 like
 

package/index.d.ts

@@ -2,4 +2,5 @@ import { add } from "./src/add/index.d.ts";
 import { mul } from "./src/mul/index.d.ts";
 import { sub } from "./src/sub/index.d.ts";
 import { div } from "./src/div/index.d.ts";
-export { add, mul, sub, div };
+import { round } from "./src/round/index.d.ts";
+export { add, div, mul, round, sub };

package/index.js

@@ -2,4 +2,5 @@ import { add } from "./src/add/index.js";
 import { mul } from "./src/mul/index.js";
 import { sub } from "./src/sub/index.js";
 import { div } from "./src/div/index.js";
-export { add, mul, sub, div };
+import { round } from "./src/round/index.js";
+export { add, div, mul, round, sub };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@numio/bigmath",
   "description": "@numio/bigmath is an arbitrary-precision arithmetic library. It can be used for basic operations with decimal numbers (integers and float)",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "keywords": [
     "precision",
     "arithmetic",

package/src/add/index.d.ts

@@ -1,2 +1,2 @@
-/** This function adds 2 numbers (as string). */
+/** This function adds numbers (as string). */
 export declare function add(strs: string[]): string;

package/src/add/index.js

@@ -1,7 +1,7 @@
 import { a2sSA, s2aSA } from "../shared/utils.js";
 import { subtract } from "../sub/utils.js";
 import { addition } from "./utils.js";
-/** This function adds 2 numbers (as string). */
+/** This function adds numbers (as string). */
 export function add(strs) {
     var arrays = strs.map(function (str) { return s2aSA(str); });
     var inputData = arrays.reduce(function (left, right) {

package/src/div/index.d.ts

@@ -1,2 +1,2 @@
-/** This function should divide 2 numbers (as string). */
+/** This function should divide numbers (as string). */
 export declare const div: (strs: string[], limit?: number) => string;

package/src/div/index.js

@@ -1,6 +1,6 @@
 import { a2sMD, s2aMD } from "../shared/utils.js";
 import { division } from "./utils.js";
-/** This function should divide 2 numbers (as string). */
+/** This function should divide numbers (as string). */
 export var div = function (strs, limit) {
     if (limit === void 0) { limit = 20; }
     if (strs[0] === "0")

package/src/mul/index.d.ts

@@ -1,2 +1,2 @@
-/** This function multiplies 2 numbers (as string). */
+/** This function multiplies numbers (as string). */
 export declare const mul: (strs: string[]) => string;

package/src/mul/index.js

@@ -1,6 +1,6 @@
 import { a2sMD, s2aMD } from "../shared/utils.js";
 import { multiplication } from "./utils.js";
-/** This function multiplies 2 numbers (as string). */
+/** This function multiplies numbers (as string). */
 export var mul = function (strs) {
     var arrays = strs.map(function (str) { return s2aMD(str); });
     var inputData = arrays.reduce(function (left, right) {

package/src/round/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const UP = "up";
+export declare const DOWN = "down";
+export declare const HALF_UP = "half-up";
+export declare const HALF_DOWN = "half-down";
+export declare const HALF_EVEN = "half-even";
+export declare const HALF_ODD = "half-odd";
+export declare const ROUND_MODE: readonly ["up", "down", "half-up", "half-down", "half-even", "half-odd"];

package/src/round/constants.js

@@ -0,0 +1,14 @@
+export var UP = "up";
+export var DOWN = "down";
+export var HALF_UP = "half-up";
+export var HALF_DOWN = "half-down";
+export var HALF_EVEN = "half-even";
+export var HALF_ODD = "half-odd";
+export var ROUND_MODE = [
+    UP,
+    DOWN,
+    HALF_UP,
+    HALF_DOWN,
+    HALF_EVEN,
+    HALF_ODD,
+];

package/src/round/index.d.ts

@@ -0,0 +1,3 @@
+import type { Round } from "./types.d.ts";
+/** This function round number. */
+export declare const round: Round;

package/src/round/index.js

@@ -0,0 +1,45 @@
+import { HALF_UP } from "./constants.js";
+import { calcLast, handleCarryOver, handleTail } from "./utils.js";
+/** This function round number. */
+export var round = function (value, options) {
+    var _a;
+    var _b, _c, _d, _e;
+    var roundMode = (_b = options === null || options === void 0 ? void 0 : options.roundMode) !== null && _b !== void 0 ? _b : HALF_UP;
+    var array = [];
+    var sigFig = (_c = options === null || options === void 0 ? void 0 : options.sigFig) !== null && _c !== void 0 ? _c : false;
+    var decimals = (_d = options === null || options === void 0 ? void 0 : options.decimals) !== null && _d !== void 0 ? _d : 0;
+    var isFloat = false;
+    var isNill = true;
+    for (var i = 0; i < value.length; i++) {
+        var charCode = value.charCodeAt(i);
+        if (sigFig && charCode > 48)
+            sigFig = false;
+        if (isNill && charCode > 48)
+            isNill = false;
+        if (isFloat && !sigFig)
+            decimals -= 1;
+        if (charCode === 46)
+            isFloat = true;
+        if (isFloat && decimals === 0) {
+            var next = (_e = value.charCodeAt(i + 1)) !== null && _e !== void 0 ? _e : 0;
+            var prev = value.charCodeAt(i - 1);
+            var curr = charCode === 46 ? prev : charCode;
+            var _f = calcLast(curr, next, roundMode), last = _f[0], hasCarryOver = _f[1];
+            if (charCode === 46)
+                isFloat = false;
+            if (hasCarryOver) {
+                _a = handleCarryOver(array, isFloat), array = _a[0], isFloat = _a[1];
+                break;
+            }
+            charCode === 46
+                ? array[array.length - 1] += last - prev
+                : array.push(last);
+            break;
+        }
+        array.push(charCode);
+    }
+    handleTail(array, isFloat);
+    return (isNill && array[array.length - 1] <= 48)
+        ? "0"
+        : String.fromCharCode.apply(String, array);
+};

package/src/round/types.d.ts

@@ -0,0 +1,10 @@
+import type { ROUND_MODE } from "./constants.d.ts";
+export type Round = (value: string, options?: {
+    decimals?: number;
+    roundMode?: RoundMode;
+    sigFig?: boolean;
+}) => string;
+export type RoundMode = typeof ROUND_MODE[number];
+export type HandleTail = (array: number[], isFloat: boolean) => void;
+export type HandleCarryOver = (array: number[], isFloat: boolean) => [number[], boolean];
+export type CalcLast = (current: number, next: number, roundMode: RoundMode) => [number, boolean];

package/src/round/utils.d.ts

@@ -0,0 +1,4 @@
+import type { CalcLast, HandleCarryOver, HandleTail } from "./types.d.ts";
+export declare const handleTail: HandleTail;
+export declare const handleCarryOver: HandleCarryOver;
+export declare const calcLast: CalcLast;

package/src/round/utils.js

@@ -0,0 +1,60 @@
+import { DOWN, HALF_DOWN, HALF_EVEN, HALF_ODD, HALF_UP, UP, } from "./constants.js";
+export var handleTail = function (array, isFloat) {
+    var lastIdx = array.length - 1;
+    while (isFloat && array[lastIdx] <= 48) {
+        if (array[lastIdx] === 46 || array.length === 1)
+            isFloat = false;
+        array.length > 1 && array.pop();
+        lastIdx -= 1;
+    }
+};
+export var handleCarryOver = function (array, isFloat) {
+    var _a;
+    var hasCarryOver = true;
+    var idx = array.length - 1;
+    var mapFloat = new Map([
+        [57, function () {
+                array.pop();
+                idx -= 1;
+            }],
+        [46, function () {
+                array.pop();
+                idx -= 1;
+                isFloat = false;
+            }],
+        [0, function () {
+                array[idx] += 1;
+                hasCarryOver = false;
+            }],
+    ]);
+    var mapInt = new Map([
+        [57, function () {
+                array[idx] = 48;
+                idx -= 1;
+            }],
+        [0, function () {
+                array[idx] += 1;
+                hasCarryOver = false;
+            }],
+    ]);
+    while (hasCarryOver && idx >= 0) {
+        var map = isFloat ? mapFloat : mapInt;
+        var key = map.has(array[idx]) ? array[idx] : 0;
+        (_a = map.get(key)) === null || _a === void 0 ? void 0 : _a();
+    }
+    hasCarryOver && array.unshift(49);
+    return [array, isFloat];
+};
+export var calcLast = function (current, next, roundMode) {
+    var _a;
+    var isEven = current % 2 === 1;
+    var map = (_a = {},
+        _a[UP] = current + (next > 48 ? 1 : 0),
+        _a[DOWN] = current,
+        _a[HALF_UP] = current + (next >= 53 ? 1 : 0),
+        _a[HALF_DOWN] = current + (next > 53 ? 1 : 0),
+        _a[HALF_EVEN] = current + ((isEven && next >= 53) ? 1 : 0),
+        _a[HALF_ODD] = current + ((!isEven && next >= 53) ? 1 : 0),
+        _a);
+    return map[roundMode] > 57 ? [48, true] : [map[roundMode], false];
+};

package/src/sub/index.d.ts

@@ -1,2 +1,2 @@
-/** This function subtracts 2 numbers (as string). */
+/** This function subtracts numbers (as string). */
 export declare function sub(strs: string[]): string;

package/src/sub/index.js

@@ -1,7 +1,7 @@
 import { addition } from "../add/utils.js";
 import { a2sSA, s2aSA } from "../shared/utils.js";
 import { subtract } from "./utils.js";
-/** This function subtracts 2 numbers (as string). */
+/** This function subtracts numbers (as string). */
 export function sub(strs) {
     var arrays = strs.map(function (str) { return s2aSA(str); });
     var inputData = arrays.reduce(function (left, right) {