@rinxun/numeric-calculator 1.0.2 → 1.0.5

package/README.md

@@ -1,6 +1,6 @@
 <h1 align="center">Numeric Calculator</h1>
 
-<p align="center">Calculate addition, subtaction, multiplication, division precisely, for tackling the precision issue</p>
+<p align="center">Calculate addition, subtraction, multiplication, division precisely, for tackling the precision issue</p>
 
 ---
 
@@ -48,6 +48,8 @@ This project is licensed under the terms of the [MIT license](https://github.com
 
     - ```js
       config = {
+        precision?: number, // global default precision, default to 15, should be in the range 0 - 20, effects `toPrecision` when `toPrecision` has no args
+        fractionDigits?: number, // global default decimal length, default to 2, should be in the range 0 - 20, effects `toFixed` when `toFixed` has no args
         enableCheckBoundary?: boolean // if true, it will check if the value is out of the safe boundary
       }
       ```
@@ -63,6 +65,7 @@ The instance supports chain operations.
 - `times(operands: IOperand[]) => instance`
 - `divide(operands: IOperand[]) => instance`
 - `toPrecision(precision?: number) => number`
+- `toFixed(fractionDigits?: number) => string`
 
 
 
@@ -72,7 +75,7 @@ The instance supports chain operations.
 
 ```typescript
 // CommonJS
-const NC = require('@rinxun/numeric-calculator');
+const { default: NC } = require('@rinxun/numeric-calculator');
 
 // ES6 
 import NC from '@rinxun/numeric-calculator';
@@ -148,6 +151,19 @@ const result = new NC(1.2e-2).toPrecision(); // 0.012
 
 
 
+<h4>inst.toFixed(fractionDigits?: number)</h4>
+
+Follow the [Banker's Rounding rules](https://rounding.to/understanding-the-bankers-rounding/)
+
+```typescript
+const result = new NC(1.2345).toFixed(); // '1.23'
+const result = new NC(1.2345).toFixed(3); // '1.234'
+const result = new NC(1.2346).toFixed(3); // '1.235'
+const result = new NC(1.2e-2).toFixed(); // 0.01
+```
+
+
+
 <h4>chain operations</h4>
 
 ```typescript

package/index.d.ts

@@ -1,4 +1,6 @@
 declare type IConfig = {
+    precision?: number;
+    fractionDigits?: number;
     enableCheckBoundary?: boolean;
 };
 declare type IOperand = Calculator | number | string;
@@ -13,6 +15,16 @@ declare class Calculator {
      * @description global register for temporary results, core for chaining operations
      */
     private _VALUE;
+    /**
+     * @private
+     * @description global default precision, default to 15, should be in the range 0 - 20, effects `toPrecision` when `toPrecision` has no args
+     */
+    private _precision;
+    /**
+     * @private
+     * @description global default decimal length, default to 2, should be in the range 0 - 20, effects `toFixed` when `toFixed` has no args
+     */
+    private _fractionDigits;
     /**
      * @private
      * @description for debugging, if true, it will check if the value is out of the safe boundary
@@ -39,6 +51,12 @@ declare class Calculator {
      * @param {number} precision default 15
      */
     private processPrecision;
+    /**
+     * get the fixed-point value
+     * @param {number} num numeric
+     * @param {number} fractionDigits default 2
+     */
+    private processFixed;
     /**
      * core processor for times
      * @param {number} num1 operand 1
@@ -77,10 +95,16 @@ declare class Calculator {
     constructor(operand?: IOperand, config?: IConfig);
     /**
      * @description parse the result to precise numeric
-     * @param precision default to 15
+     * @param {number} precision default to 15
      * @returns {number} precise result
      */
     toPrecision(precision?: number): number;
+    /**
+     * @description parse the result to fixed-point value
+     * @param {number} fractionDigits default to 2, should be in the range 0 - 20
+     * @returns {string} fixed-point result
+     */
+    toFixed(fractionDigits?: number): string;
     /**
      * @description plus operator
      * @param {Array<IOperand>} operands operands

package/index.js

@@ -1,3 +1,4 @@
+"use strict";
 var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
         if (ar || !(i in from)) {
@@ -7,6 +8,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
+Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * @description Calculate addition, subtaction, multiplication, division precisely, for tackling the precision issue
  * @author Janden Ma
@@ -27,6 +29,16 @@ var Calculator = /** @class */ (function () {
          * @description global register for temporary results, core for chaining operations
          */
         this._VALUE = undefined;
+        /**
+         * @private
+         * @description global default precision, default to 15, should be in the range 0 - 20, effects `toPrecision` when `toPrecision` has no args
+         */
+        this._precision = 15;
+        /**
+         * @private
+         * @description global default decimal length, default to 2, should be in the range 0 - 20, effects `toFixed` when `toFixed` has no args
+         */
+        this._fractionDigits = 2;
         /**
          * @private
          * @description for debugging, if true, it will check if the value is out of the safe boundary
@@ -36,6 +48,12 @@ var Calculator = /** @class */ (function () {
             this._VALUE = this.parseOperandToNum(operand);
         }
         if (config) {
+            if (config.precision !== undefined) {
+                this._precision = config.precision;
+            }
+            if (config.fractionDigits !== undefined) {
+                this._fractionDigits = config.fractionDigits;
+            }
             if (config.enableCheckBoundary) {
                 this._enableCheckBoundary = config.enableCheckBoundary;
             }
@@ -89,7 +107,15 @@ var Calculator = /** @class */ (function () {
      * @param {number} precision default 15
      */
     Calculator.prototype.processPrecision = function (num, precision) {
-        return +parseFloat(num.toPrecision(precision || 15));
+        return +parseFloat(num.toPrecision(precision || this._precision || 15));
+    };
+    /**
+     * get the fixed-point value
+     * @param {number} num numeric
+     * @param {number} fractionDigits default 2
+     */
+    Calculator.prototype.processFixed = function (num, fractionDigits) {
+        return this.processPrecision(num).toFixed(fractionDigits || this._fractionDigits || 2);
     };
     /**
      * core processor for times
@@ -205,12 +231,20 @@ var Calculator = /** @class */ (function () {
     // #region Public Functions
     /**
      * @description parse the result to precise numeric
-     * @param precision default to 15
+     * @param {number} precision default to 15
      * @returns {number} precise result
      */
     Calculator.prototype.toPrecision = function (precision) {
         return this.processPrecision(this._VALUE || 0, precision);
     };
+    /**
+     * @description parse the result to fixed-point value
+     * @param {number} fractionDigits default to 2, should be in the range 0 - 20
+     * @returns {string} fixed-point result
+     */
+    Calculator.prototype.toFixed = function (fractionDigits) {
+        return this.processFixed(this._VALUE || 0, fractionDigits);
+    };
     /**
      * @description plus operator
      * @param {Array<IOperand>} operands operands
@@ -261,4 +295,4 @@ var Calculator = /** @class */ (function () {
     };
     return Calculator;
 }());
-export default Calculator;
+exports.default = Calculator;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rinxun/numeric-calculator",
-  "version": "1.0.2",
-  "description": "Calculate addition, subtaction, multiplication, division precisely, for tackling the precision issue",
+  "version": "1.0.5",
+  "description": "Calculate addition, subtraction, multiplication, division precisely, for tackling the precision issue",
   "keywords": [
     "long",
     "float",
@@ -10,12 +10,11 @@
     "precision",
     "calculator",
     "addition",
-    "subtaction",
+    "subtraction",
     "multiplication",
     "division"
   ],
   "main": "index.js",
-  "type": "module",
   "types": "**/*.d.ts",
   "license": "MIT",
   "private": false,