@rinxun/numeric-calculator 1.0.4 → 1.0.5

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,6 +109,14 @@ 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
@@ -211,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

package/package.json

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