@rinxun/numeric-calculator 1.0.0 → 1.0.1

package/README.md

@@ -35,11 +35,12 @@ This project is licensed under the terms of the [MIT license](https://github.com
 
 <h2>Constructor</h2>
 
-- `new NC(number: number, config: object)`
+- `new NC(operand: IOperand, config: IConfig)`
 
   - number: Initial numeric
 
     - optional
+    - `type IOperand = instance | number | string`
 
   - config: Configurations 
 
@@ -57,10 +58,10 @@ This project is licensed under the terms of the [MIT license](https://github.com
 
 The instance supports chain operations.
 
-- `plus(operands: number[]) => instance `
-- `minus(operands: number[]) => instance`
-- `times(operands: number[]) => instance`
-- `divide(operands: number[]) => instance`
+- `plus(operands: IOperand[]) => instance `
+- `minus(operands: IOperand[]) => instance`
+- `times(operands: IOperand[]) => instance`
+- `divide(operands: IOperand[]) => instance`
 - `toPrecision(precision?: number) => number`
 
 
@@ -85,8 +86,10 @@ import NC from '@rinxun/numeric-calculator';
 const inst1 = new NC(); 
 // or with initial numeric
 const inst2 = new NC(10); 
+const inst3 = new NC('10'); 
+const inst4 = new NC(new NC(10)); 
 // or with config
-const inst3 = new NC(10, { enableCheckBoundary: true }); 
+const inst5 = new NC(10, { enableCheckBoundary: true }); 
 ```
 
 
@@ -95,9 +98,9 @@ const inst3 = new NC(10, { enableCheckBoundary: true });
 
 ```typescript
 const result = new NC().plus(2.134).toPrecision(); // 2.134
-const result = new NC().plus(2.1341, 3.09, 0.65).toPrecision(); // 5.8741
-const result = new NC(10).plus(2.134).toPrecision(); // 12.134
-const result = new NC(10).plus(2.1341, 3.09, 0.65).toPrecision(); // 15.8741
+const result = new NC().plus(2.1341, new NC(1.09).plus(2), '0.65').toPrecision(); // => 2.1341+(1.09+2)+0.65 = 5.8741
+const result = new NC(10).plus(2.134).toPrecision(); // => 10+2.134 = 12.134
+const result = new NC(10).plus(2.1341, '3.09', 0.65).toPrecision(); // => 10+2.1341+3.09+0.65 = 15.8741
 ```
 
 
@@ -105,10 +108,10 @@ const result = new NC(10).plus(2.1341, 3.09, 0.65).toPrecision(); // 15.8741
 <h4>inst.minus</h4>
 
 ```typescript
-const result = new NC().minus(0.4).toPrecision(); // -0.6
-const result = new NC().minus(0.25, 1.5, 3.498).toPrecision(); // -4.748
-const result = new NC(2).minus(0.4).toPrecision(); // 1.6
-const result = new NC(-2).minus(0.25, 1.5, 3.498).toPrecision(); // -7.248
+const result = new NC().minus(0.4).toPrecision(); // 0.4
+const result = new NC().minus(0.25, new NC(2.5).minus(1), '3.498').toPrecision(); // => 0.25-(2.5-1)-3.498 -4.748
+const result = new NC(2).minus(0.4).toPrecision(); // => 2-0.4 = 1.6
+const result = new NC(-2).minus(0.25, 1.5, 3.498).toPrecision(); // -2-0.25-1.5-3.498 = -7.248
 ```
 
 
@@ -117,9 +120,9 @@ const result = new NC(-2).minus(0.25, 1.5, 3.498).toPrecision(); // -7.248
 
 ```typescript
 const result = new NC().times(0.12).toPrecision(); // 0.12
-const result = new NC().times(0.12, 100, 5).toPrecision(); // 60
-const result = new NC(-4).times(0.12).toPrecision(); // -0.48
-const result = new NC(3.2).times(0.12, 100, 5).toPrecision(); // 192
+const result = new NC().times(0.12, new NC(8).times(12.5), '5').toPrecision(); // => 0.12*(8*12.5)*5 = 60
+const result = new NC(-4).times(0.12).toPrecision(); // => -4*0.12 = -0.48
+const result = new NC(3.2).times(0.12, '100', 5).toPrecision(); // => 3.2*0.12*100*5 = 192
 ```
 
 
@@ -128,9 +131,9 @@ const result = new NC(3.2).times(0.12, 100, 5).toPrecision(); // 192
 
 ```typescript
 const result = new NC().divide(3).toPrecision(); // 3
-const result = new NC().divide(100, 20, 2).toPrecision(); // 2.5
-const result = new NC(36.12).divide(3).toPrecision(); // 12.04
-const result = new NC(-1000).divide(100, 20, 2).toPrecision(); // -0.25
+const result = new NC().divide(100, new NC(60).divide(3), '2').toPrecision(); // => 100/(60/3)/2 = 2.5
+const result = new NC(36.12).divide(3).toPrecision(); // => 36.12/3 = 12.04
+const result = new NC(-1000).divide(100, '20', 2).toPrecision(); // -1000/100/20/2 = -0.25
 ```
 
 
@@ -148,7 +151,8 @@ const result = new NC(1.2e-2).toPrecision(); // 0.012
 <h4>chain operations</h4>
 
 ```typescript
-const result = new NC(10).plus(2).minus(4).times(2).divide(8).toPrecision(); // 2
+const result = new NC(10).plus(2).minus(4).times(2).divide(8).toPrecision(); // => (10+2-4)*2/8 = 2
+const result = new NC(10).plus(new NC().times(2, 4), '6').divide(new NC(12).minus(4)).toPrecision(); // => (10+(2*4)+6)/(12-4) = 3
 ```
 
 

package/index.d.ts

@@ -1,6 +1,7 @@
 declare type IConfig = {
     enableCheckBoundary?: boolean;
 };
+declare type IOperand = Calculator | number | string;
 /**
  * @description Calculate addition, subtaction, multiplication, division precisely, for tackling the precision issue
  * @author Janden Ma
@@ -23,10 +24,15 @@ declare class Calculator {
      */
     private checkBoundary;
     /**
-     * get the length of the mantissa of the numeric
+     * @description get the length of the mantissa of the numeric
      * @param {number} num numeric
      */
     private getMantissaLen;
+    /**
+     * @description according to the type of operand, parse it to number
+     * @param {IOperand} operand operand
+     */
+    private parseOperandToNum;
     /**
      * get the precise value
      * @param {number} num numeric
@@ -59,16 +65,16 @@ declare class Calculator {
     private processPlus;
     /**
      * core processor for times
-     * @param {number[]} nums operands
+     * @param {IOperand[]} operands operands
      * @param {"plus" | "minus" | "times" | "divide"} op operator
      */
     private calculate;
     /**
      * @constructor
-     * @param {number|undefined} num initial operand
+     * @param {IOperand|undefined} operand initial operand
      * @param {Config} config Configurations
      */
-    constructor(num?: number, config?: IConfig);
+    constructor(operand?: IOperand, config?: IConfig);
     /**
      * @description parse the result to precise numeric
      * @param precision default to 15
@@ -77,23 +83,23 @@ declare class Calculator {
     toPrecision(precision?: number): number;
     /**
      * @description plus operator
-     * @param {number[]} nums operands
+     * @param {Array<IOperand>} operands operands
      */
-    plus(...nums: Array<number>): this;
+    plus(...operands: Array<IOperand>): this;
     /**
      * @description minus operator
-     * @param {number[]} nums operands
+     * @param {Array<IOperand>} operands operands
      */
-    minus(...nums: Array<number>): this;
+    minus(...operands: Array<IOperand>): this;
     /**
      * @description times operator
-     * @param {number[]} nums operands
+     * @param {Array<IOperand>} operands operands
      */
-    times(...nums: Array<number>): this;
+    times(...operands: Array<IOperand>): this;
     /**
      * @description divide operator
-     * @param {number[]} nums operands
+     * @param {Array<IOperand>} operands operands
      */
-    divide(...nums: Array<number>): this;
+    divide(...operands: Array<IOperand>): this;
 }
 export default Calculator;

package/index.js

@@ -17,10 +17,10 @@ var Calculator = /** @class */ (function () {
     // #region Constructor
     /**
      * @constructor
-     * @param {number|undefined} num initial operand
+     * @param {IOperand|undefined} operand initial operand
      * @param {Config} config Configurations
      */
-    function Calculator(num, config) {
+    function Calculator(operand, config) {
         // #region Private Variables
         /**
          * @private
@@ -32,8 +32,8 @@ var Calculator = /** @class */ (function () {
          * @description for debugging, if true, it will check if the value is out of the safe boundary
          */
         this._enableCheckBoundary = false;
-        if (num !== undefined && num !== null) {
-            this._VALUE = num;
+        if (operand !== undefined && operand !== null) {
+            this._VALUE = this.parseOperandToNum(operand);
         }
         if (config) {
             if (config.enableCheckBoundary) {
@@ -56,7 +56,7 @@ var Calculator = /** @class */ (function () {
         }
     };
     /**
-     * get the length of the mantissa of the numeric
+     * @description get the length of the mantissa of the numeric
      * @param {number} num numeric
      */
     Calculator.prototype.getMantissaLen = function (num) {
@@ -67,6 +67,22 @@ var Calculator = /** @class */ (function () {
         var len = decimals.length - +exponentSuffix;
         return len > 0 ? len : 0;
     };
+    /**
+     * @description according to the type of operand, parse it to number
+     * @param {IOperand} operand operand
+     */
+    Calculator.prototype.parseOperandToNum = function (operand) {
+        if (operand instanceof Calculator) {
+            return operand._VALUE;
+        }
+        else if (typeof operand === "number") {
+            return operand;
+        }
+        else {
+            var val = Number(operand);
+            return Number.isNaN(val) ? 0 : val;
+        }
+    };
     /**
      * get the precise value
      * @param {number} num numeric
@@ -146,32 +162,44 @@ var Calculator = /** @class */ (function () {
     };
     /**
      * core processor for times
-     * @param {number[]} nums operands
+     * @param {IOperand[]} operands operands
      * @param {"plus" | "minus" | "times" | "divide"} op operator
      */
-    Calculator.prototype.calculate = function (nums, op) {
+    Calculator.prototype.calculate = function (operands, op) {
         var _this = this;
-        var operands = __spreadArray([], nums, true);
+        var values = __spreadArray([], operands, true);
         var firstOperand = this._VALUE;
+        var analyzeFirstOperand = function () {
+            var parsedVal = _this.parseOperandToNum(values[0]);
+            values.shift();
+            if (parsedVal === undefined) {
+                return analyzeFirstOperand();
+            }
+            return parsedVal;
+        };
         if (firstOperand === undefined) {
-            firstOperand = operands[0];
-            operands.shift();
+            firstOperand = analyzeFirstOperand();
         }
-        var result = operands.reduce(function (prev, operand) {
+        var result = values.reduce(function (prevOperand, currOperand) {
+            var prev = _this.parseOperandToNum(prevOperand);
+            var current = _this.parseOperandToNum(currOperand);
+            if (!current) {
+                return prev;
+            }
             switch (op) {
                 case "plus":
-                    return _this.processPlus(prev, operand);
+                    return _this.processPlus(prev, current);
                 case "minus":
-                    return _this.processMinus(prev, operand);
+                    return _this.processMinus(prev, current);
                 case "times":
-                    return _this.processTimes(prev, operand);
+                    return _this.processTimes(prev, current);
                 case "divide":
-                    return _this.processDivide(prev, operand);
+                    return _this.processDivide(prev, current);
                 default:
                     return prev;
             }
         }, firstOperand);
-        this._VALUE = result;
+        this._VALUE = this.parseOperandToNum(result);
     };
     // #endregion
     // #region Public Functions
@@ -185,50 +213,50 @@ var Calculator = /** @class */ (function () {
     };
     /**
      * @description plus operator
-     * @param {number[]} nums operands
+     * @param {Array<IOperand>} operands operands
      */
     Calculator.prototype.plus = function () {
-        var nums = [];
+        var operands = [];
         for (var _i = 0; _i < arguments.length; _i++) {
-            nums[_i] = arguments[_i];
+            operands[_i] = arguments[_i];
         }
-        this.calculate(nums, "plus");
+        this.calculate(operands, "plus");
         return this;
     };
     /**
      * @description minus operator
-     * @param {number[]} nums operands
+     * @param {Array<IOperand>} operands operands
      */
     Calculator.prototype.minus = function () {
-        var nums = [];
+        var operands = [];
         for (var _i = 0; _i < arguments.length; _i++) {
-            nums[_i] = arguments[_i];
+            operands[_i] = arguments[_i];
         }
-        this.calculate(nums, "minus");
+        this.calculate(operands, "minus");
         return this;
     };
     /**
      * @description times operator
-     * @param {number[]} nums operands
+     * @param {Array<IOperand>} operands operands
      */
     Calculator.prototype.times = function () {
-        var nums = [];
+        var operands = [];
         for (var _i = 0; _i < arguments.length; _i++) {
-            nums[_i] = arguments[_i];
+            operands[_i] = arguments[_i];
         }
-        this.calculate(nums, "times");
+        this.calculate(operands, "times");
         return this;
     };
     /**
      * @description divide operator
-     * @param {number[]} nums operands
+     * @param {Array<IOperand>} operands operands
      */
     Calculator.prototype.divide = function () {
-        var nums = [];
+        var operands = [];
         for (var _i = 0; _i < arguments.length; _i++) {
-            nums[_i] = arguments[_i];
+            operands[_i] = arguments[_i];
         }
-        this.calculate(nums, "divide");
+        this.calculate(operands, "divide");
         return this;
     };
     return Calculator;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rinxun/numeric-calculator",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Calculate addition, subtaction, multiplication, division precisely, for tackling the precision issue",
   "keywords": [
     "long",