@numio/bigmath 1.0.1 → 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.1 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/{npm/index.d.ts → 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/{npm/index.js → 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.1",
+  "version": "1.0.3",
   "keywords": [
     "precision",
     "arithmetic",

package/{npm/src → 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/{npm/src → 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/{npm/src → 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/{npm/src → 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

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

package/{npm/src → 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

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

package/{npm/src → 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) {

package/build.ts

@@ -1,45 +0,0 @@
-const rootPath = "./npm";
-const decoder = new TextDecoder("utf-8");
-const encoder = new TextEncoder();
-
-async function walk(path: string, cb: ({ path, fileInfo }: CB) => void) {
-  const fileInfo = await Deno.lstat(path);
-
-  cb({ fileInfo, path });
-
-  if (fileInfo.isDirectory) {
-    const entries = await Deno.readDir(path);
-
-    for await (const entry of entries) {
-      await walk(`${path}/${entry.name}`, cb);
-    }
-  }
-}
-
-await walk(rootPath, ({ path, fileInfo }) => {
-  if (fileInfo.isFile && path.endsWith(".js")) {
-    const content = decoder.decode(Deno.readFileSync(path));
-    const fixed = content.replaceAll(".ts", ".js");
-
-    Deno.writeFileSync(path, encoder.encode(fixed));
-  }
-
-  if (fileInfo.isFile && path.endsWith(".d.ts")) {
-    const content = decoder.decode(Deno.readFileSync(path));
-    const fixed = content.replaceAll(".ts", ".d.ts");
-
-    Deno.writeFileSync(path, encoder.encode(fixed));
-  }
-
-  if (fileInfo.isFile && path.endsWith("types.js")) {
-    Deno.remove(path);
-  }
-});
-
-Deno.copyFileSync("LICENSE", "npm/LICENSE");
-Deno.copyFileSync("README.md", "npm/README.md");
-Deno.copyFileSync("package.json", "npm/package.json");
-Deno.copyFileSync("package-lock.json", "npm/package-lock.json");
-
-
-type CB = { path: string; fileInfo: Deno.FileInfo };

package/index.ts

@@ -1,6 +0,0 @@
-import { add } from "./src/add/index.ts";
-import { mul } from "./src/mul/index.ts";
-import { sub } from "./src/sub/index.ts";
-import { div } from "./src/div/index.ts";
-
-export { add, mul, sub, div };

package/npm/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 Oleksandr Brudnovskyi
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/npm/README.md

@@ -1,129 +0,0 @@
-# @numio/bigmath
-
-@numio/bigmath is an arbitrary-precision arithmetic library. This library provides functions for performing arithmetic operations (addition, subtraction, multiplication, and division) on numbers of arbitrary length. It addresses the limitations of JavaScript's built-in number type, which suffers from precision loss when dealing with very large or very small numbers, or numbers with more than 15 significant digits.
-
-
-## Key Features and Benefits
-
-* **Arbitrary Precision:** Handles numbers of any length, avoiding the limitations of JavaScript's `Number` type. This allows for calculations with extremely large or small numbers without loss of precision.
-* **No Precision Loss:** Eliminates precision errors that occur when using numeric literals with more than 15 significant digits. The library ensures accurate calculations even with very long numbers.
-* **Four Basic Operations:** Provides functions for addition (`add`), subtraction (`sub`), multiplication (`mul`), and division (`div`).
-* **Decimal Handling:** Correctly handles decimal numbers and performs calculations accurately, including scenarios involving negative numbers.
-* **Division Precision Control:** The `div` function allows you to specify the number of digits after the decimal point for the result. The default precision is 20 digits.
-* **Easy to Use:** The library provides simple and intuitive functions for performing arithmetic operations.
-
-
-## How it Solves the Problem
-
-JavaScript's `Number` type uses a 64-bit floating-point representation (IEEE 754), which can lead to precision issues when dealing with numbers that exceed its representable range or require more than 15 significant digits. This library likely uses a different representation internally (e.g., strings or arrays of digits) to store and manipulate numbers, effectively bypassing the limitations of the built-in `Number` type. This allows it to perform calculations on numbers of virtually unlimited size and maintain accuracy.
-
-## Use Cases
-
-This library is particularly useful in scenarios where precise calculations with large numbers are essential, such as:
-
-* **Financial applications:** Dealing with large sums of money or precise interest calculations.
-* **Scientific computing:** Working with very large or small numbers in scientific simulations.
-* **Cryptography:** Implementing cryptographic algorithms that require high precision.
-* **Any application** where exceeding JavaScript's number limits is a concern.
-
-
-### Latest update
-
-In version 1.0.1 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)
-
-# Install:
-
-### NPM
-
-```bash
-npm install @numio/bigmath
-```
-
-### YARN
-
-```bash
-yarn add @numio/bigmath
-```
-
-### BUN
-
-```bash
-bun add @numio/bigmath
-```
-
-### PNPM
-
-```bash
-pnpm add @numio/bigmath
-```
-
-### DENO
-
-```bash
-deno add jsr:@numio/bigmath
-```
-
-# Examples:
-
-### Add numbers
-
-```javascript
-import { add } from "@numio/bigmath";
-
-const int = add(["12345", "99"]); // 124444
-const float = add(["0.1", "0.2", "0.3"]); // 0.6
-const negative = add(["0.1", "-0.3", "0.1"]); // -0.1
-```
-
-### Subtract numbers
-```javascript
-import { sub } from "@numio/bigmath";
-
-const int = sub(["150", "99"]); // 51
-const float = sub(["1", "0.99"]); // 0.01
-const negative = sub(["-0.1", "-0.3", "0.4"]); // -0.2
-```
-
-### Multiply numbers
-```javascript
-import { mul } from "@numio/bigmath";
-
-const int = mul(["15", "11", "2"]); // 330
-const float = mul(["0.01", "0.99"]); // 0.0099
-const negative = mul(["-2", "3"]); // -6
-```
-
-### Divide numbers
-```javascript
-import { div } from "@numio/bigmath";
-
-const int = div(["9999", "33"]); // 
-const float = div(["0.06", "0.2"]); // 0.3
-const negative = div(["-2", "-3", "2"]); // 3
-
-// set number of digit after the decimal. By default it's 20
-div("10", "3"); // 3.33333
-```
-
-Does not have a limitation on the number of digits. You can use any length you'd
-like
-
-```javascript
-// NO precision loss using numeric literals with more than 15 significant digits.
-const int = sub(
-  "999999999999999999999999999999999999999999999999999999999999999",
-  "2",
-); // "1000000000000000000000000000000000000000000000000000000000000001"
-
-const float = mul(
-  "0.00000000000000000000000000000000000000000000000000000000000000000009",
-  "0.000000002",
-); // 0.00000000000000000000000000000000000000000000000000000000000000000000000000018
-```
-
-Download from NPM - https://www.npmjs.com/package/@numio/bigmath \
-Download from JSR - https://jsr.io/@numio/bigmath \
-Home page - https://github.com/shpunter/numio-bigmath/blob/main/README.md \
-License - https://github.com/shpunter/numio-bigmath/blob/main/LICENSE

package/npm/package-lock.json

@@ -1,16 +0,0 @@
-{
-  "name": "@numio/bigmath",
-  "version": "1.0.1",
-  "lockfileVersion": 3,
-  "requires": true,
-  "packages": {
-    "": {
-      "name": "@numio/bigmath",
-      "version": "1.0.1",
-      "license": "MIT",
-      "engines": {
-        "node": "*"
-      }
-    }
-  }
-}

package/npm/package.json

@@ -1,57 +0,0 @@
-{
-  "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.1",
-  "keywords": [
-    "precision",
-    "arithmetic",
-    "big",
-    "number",
-    "decimal",
-    "float",
-    "biginteger",
-    "bigdecimal",
-    "bignumber",
-    "bigint",
-    "bignum",
-    "infinite",
-    "longnumbers",
-    "infinitenumbers",
-    "integer",
-    "float",
-    "math",
-    "add",
-    "multiply",
-    "subtract",
-    "plus",
-    "minus",
-    "divide",
-    "long division",
-    "bigmath",
-    "numio"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/shpunter/numio-bigmath.git"
-  },
-  "main": "./index.js",
-  "types": "./index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./index.js"
-    },
-    "./package.json": "./package.json"
-  },
-  "author": {
-    "name": "Oleksandr Brudnovskyi ",
-    "email": "oleksandr.brudnovskyi@gmail.com"
-  },
-  "engines": {
-    "node": "*"
-  },
-  "license": "MIT",
-  "scripts": {
-    "test": "node test"
-  },
-  "dependencies": {}
-}

package/npm/src/mul/index.d.ts

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

package/npm/src/sub/index.d.ts

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

package/src/add/index.ts

@@ -1,34 +0,0 @@
-import { a2sSA, s2aSA } from "../shared/utils.ts";
-import { subtract } from "../sub/utils.ts";
-import { addition } from "./utils.ts";
-
-/** This function adds 2 numbers (as string). */
-export function add(strs: string[]): string {
-  const arrays = strs.map((str) => s2aSA(str));
-
-  const inputData = arrays.reduce((left, right) => {
-    if (left.array.length === 0) return right;
-
-    if (left.isNegative && !right.isNegative) {
-      return subtract(
-        [right.array, right.intLength],
-        [left.array, left.intLength],
-      );
-    }
-
-    if (!left.isNegative && right.isNegative) {
-      return subtract(
-        [left.array, left.intLength],
-        [right.array, right.intLength],
-      );
-    }
-
-    return addition(
-      [left.array, left.intLength],
-      [right.array, right.intLength],
-      left.isNegative && right.isNegative,
-    );
-  }, { array: [], intLength: 0, isFloat: false, isNegative: false });
-
-  return a2sSA(inputData.array, inputData.isFloat, inputData.isNegative);
-}

package/src/add/types.ts

@@ -1,7 +0,0 @@
-import type { InputData } from "../types.ts";
-
-export type Addition = (
-  L: [number[], number],
-  R: [number[], number],
-  isNegative: boolean
-) => InputData;