@rinxun/numeric-calculator 1.0.4 → 1.0.6-beta.1

package/README.md

@@ -48,7 +48,8 @@ This project is licensed under the terms of the [MIT license](https://github.com
 
     - ```js
       config = {
-        precision?: number, // global precision, default to 15
+        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
       }
       ```
@@ -64,6 +65,7 @@ The instance supports chain operations.
 - `times(operands: IOperand[]) => instance`
 - `divide(operands: IOperand[]) => instance`
 - `toPrecision(precision?: number) => number`
+- `toFixed(fractionDigits?: number) => string`
 
 
 
@@ -73,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';
@@ -149,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,5 +1,6 @@
 declare type IConfig = {
     precision?: number;
+    fractionDigits?: number;
     enableCheckBoundary?: boolean;
 };
 declare type IOperand = Calculator | number | string;
@@ -14,7 +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
@@ -41,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
@@ -79,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

@@ -29,7 +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
@@ -42,6 +51,9 @@ var Calculator = /** @class */ (function () {
             if (config.precision !== undefined) {
                 this._precision = config.precision;
             }
+            if (config.fractionDigits !== undefined) {
+                this._fractionDigits = config.fractionDigits;
+            }
             if (config.enableCheckBoundary) {
                 this._enableCheckBoundary = config.enableCheckBoundary;
             }
@@ -97,17 +109,25 @@ var Calculator = /** @class */ (function () {
     Calculator.prototype.processPrecision = function (num, precision) {
         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
      * @param {number} num1 operand 1
      * @param {number} num2 operand 2
      */
     Calculator.prototype.processTimes = function (num1, num2) {
-        var num1MatissaLen = this.getMantissaLen(num1);
-        var num2MatissaLen = this.getMantissaLen(num2);
-        var amplifyingNum1 = num1 * Math.pow(10, num1MatissaLen);
-        var amplifyingNum2 = num2 * Math.pow(10, num2MatissaLen);
-        var magnification = Math.pow(10, num1MatissaLen + num2MatissaLen);
+        var num1MantissaLen = this.getMantissaLen(num1);
+        var num2MantissaLen = this.getMantissaLen(num2);
+        var amplifyingNum1 = num1 * Math.pow(10, num1MantissaLen);
+        var amplifyingNum2 = num2 * Math.pow(10, num2MantissaLen);
+        var magnification = Math.pow(10, num1MantissaLen + num2MantissaLen);
         this.checkBoundary(amplifyingNum1);
         this.checkBoundary(amplifyingNum2);
         var amplifyingResult = amplifyingNum1 * amplifyingNum2;
@@ -120,11 +140,11 @@ var Calculator = /** @class */ (function () {
      * @param {number} num2 operand 2
      */
     Calculator.prototype.processDivide = function (num1, num2) {
-        var num1MatissaLen = this.getMantissaLen(num1);
-        var num2MatissaLen = this.getMantissaLen(num2);
-        var amplifyingNum1 = num1 * Math.pow(10, num1MatissaLen);
-        var amplifyingNum2 = num2 * Math.pow(10, num2MatissaLen);
-        var magnification = Math.pow(10, num2MatissaLen - num1MatissaLen);
+        var num1MantissaLen = this.getMantissaLen(num1);
+        var num2MantissaLen = this.getMantissaLen(num2);
+        var amplifyingNum1 = num1 * Math.pow(10, num1MantissaLen);
+        var amplifyingNum2 = num2 * Math.pow(10, num2MantissaLen);
+        var magnification = Math.pow(10, num2MantissaLen - num1MantissaLen);
         this.checkBoundary(amplifyingNum1);
         this.checkBoundary(amplifyingNum2);
         var amplifyingResult = amplifyingNum1 / amplifyingNum2;
@@ -136,10 +156,10 @@ var Calculator = /** @class */ (function () {
      * @param {number} num2 operand 2
      */
     Calculator.prototype.processMinus = function (num1, num2) {
-        var num1MatissaLen = this.getMantissaLen(num1);
-        var num2MatissaLen = this.getMantissaLen(num2);
-        var maxMatissaLen = Math.max(num1MatissaLen, num2MatissaLen);
-        var magnification = Math.pow(10, maxMatissaLen);
+        var num1MantissaLen = this.getMantissaLen(num1);
+        var num2MantissaLen = this.getMantissaLen(num2);
+        var maxMantissaLen = Math.max(num1MantissaLen, num2MantissaLen);
+        var magnification = Math.pow(10, maxMantissaLen);
         var amplifyingNum1 = this.processTimes(num1, magnification);
         var amplifyingNum2 = this.processTimes(num2, magnification);
         this.checkBoundary(amplifyingNum1);
@@ -154,10 +174,10 @@ var Calculator = /** @class */ (function () {
      * @param {number} num2 operand 2
      */
     Calculator.prototype.processPlus = function (num1, num2) {
-        var num1MatissaLen = this.getMantissaLen(num1);
-        var num2MatissaLen = this.getMantissaLen(num2);
-        var maxMatissaLen = Math.max(num1MatissaLen, num2MatissaLen);
-        var magnification = Math.pow(10, maxMatissaLen);
+        var num1MantissaLen = this.getMantissaLen(num1);
+        var num2MantissaLen = this.getMantissaLen(num2);
+        var maxMantissaLen = Math.max(num1MantissaLen, num2MantissaLen);
+        var magnification = Math.pow(10, maxMantissaLen);
         var amplifyingNum1 = this.processTimes(num1, magnification);
         var amplifyingNum2 = this.processTimes(num2, magnification);
         this.checkBoundary(amplifyingNum1);
@@ -189,18 +209,34 @@ var Calculator = /** @class */ (function () {
         var result = values.reduce(function (prevOperand, currOperand) {
             var prev = _this.parseOperandToNum(prevOperand);
             var current = _this.parseOperandToNum(currOperand);
-            if (!current) {
+            if (current === undefined) {
                 return prev;
             }
             switch (op) {
-                case "plus":
+                case "plus": {
+                    if (current === 0) {
+                        return prev;
+                    }
                     return _this.processPlus(prev, current);
-                case "minus":
+                }
+                case "minus": {
+                    if (current === 0) {
+                        return prev;
+                    }
                     return _this.processMinus(prev, current);
-                case "times":
+                }
+                case "times": {
+                    if (current === 0) {
+                        return 0;
+                    }
                     return _this.processTimes(prev, current);
-                case "divide":
+                }
+                case "divide": {
+                    if (current === 0) {
+                        return 0;
+                    }
                     return _this.processDivide(prev, current);
+                }
                 default:
                     return prev;
             }
@@ -211,12 +247,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rinxun/numeric-calculator",
-  "version": "1.0.4",
+  "version": "1.0.6-beta.1",
   "description": "Calculate addition, subtraction, multiplication, division precisely, for tackling the precision issue",
   "keywords": [
     "long",