js-big-decimal - npm Package Compare versions

Comparing version 1.0.2 to 1.1.0

lib/add.d.ts

 export declare function add(number1: any, number2?: string): string;
+export declare function trim(number: string): string;
+export declare function pad(number1: string, number2: string): string[];

lib/add.js

@@ -6,3 +6,3 @@ "use strict";
     if (number2 === void 0) { number2 = "0"; }
-    var neg = 0, ind = -1;
+    var neg = 0, ind = -1, neg_len;
     //check for negatives
@@ -13,2 +13,3 @@ if (number1[0] == '-') {
         number1 = number1.substring(1);
+        neg_len = number1.length;
     }
@@ -19,5 +20,7 @@ if (number2[0] == '-') {
         number2 = number2.substring(1);
+        neg_len = number2.length;
     }
-    var parts1 = number1.split('.'), parts2 = number2.split('.');
-    var li = Math.max(parts1[0].length, parts2[0].length), ld1 = parts1[1] ? parts1[1].length : 0, ld2 = parts2[1] ? parts2[1].length : 0, ld = Math.max(ld1, ld2);
+    number1 = trim(number1);
+    number2 = trim(number2);
+    _a = pad(trim(number1), trim(number2)), number1 = _a[0], number2 = _a[1];
     if (neg == 1) {
@@ -35,3 +38,3 @@ if (ind == 1)
     else {
-        if (res.length == li + ld + 1 + (ld ? 1 : 0))
+        if (number1.length < (res.length))
             return trim(res.substring(1));
@@ -41,2 +44,3 @@ else
     }
+    var _a;
 }
@@ -63,3 +67,4 @@ exports.add = add;
 }
-function addCore(number1, number2) {
+exports.trim = trim;
+function pad(number1, number2) {
     var parts1 = number1.split('.'), parts2 = number2.split('.');
@@ -87,2 +92,7 @@ //pad integral part
     number2 = parts2[0] + ((parts2[1]) ? ('.' + parts2[1]) : '');
+    return [number1, number2];
+}
+exports.pad = pad;
+function addCore(number1, number2) {
+    _a = pad(number1, number2), number1 = _a[0], number2 = _a[1];
     var sum = '', carry = 0;
@@ -98,3 +108,4 @@ for (var i = number1.length - 1; i >= 0; i--) {
     }
-    return carry ? ('1' + sum) : sum;
+    return carry ? (carry.toString() + sum) : sum;
+    var _a;
 }

lib/big-decimal.d.ts

@@ -6,5 +6,18 @@ export declare class bigDecimal {
     getValue(): string;
+    static getPrettyValue(number: any, digits: any, separator: any): string;
     getPrettyValue(digits: any, separator: any): string;
-    round(precision: any): any;
+    static round(number: any, precision: any): any;
+    round(precision: any): bigDecimal;
     static add(number1: any, number2: any): string;
+    add(number: bigDecimal): bigDecimal;
+    static subtract(number1: any, number2: any): string;
+    subtract(number: bigDecimal): bigDecimal;
+    static multiply(number1: any, number2: any): string;
+    multiply(number: bigDecimal): bigDecimal;
+    static divide(number1: any, number2: any): string;
+    divide(number: bigDecimal): bigDecimal;
+    static compareTo(number1: any, number2: any): 0 | 1 | -1;
+    compareTo(number: bigDecimal): 0 | 1 | -1;
+    static negate(number: any): string;
+    negate(): bigDecimal;
 }

lib/big-decimal.js

@@ -5,6 +5,9 @@ "use strict";
 var round_1 = require("./round");
+var multiply_1 = require("./multiply");
+var divide_1 = require("./divide");
+var compareTo_1 = require("./compareTo");
+var subtract_1 = require("./subtract");
 var bigDecimal = (function () {
     function bigDecimal(number) {
         if (number === void 0) { number = '0'; }
-        this.value = '0';
         this.value = bigDecimal.validate(number);
@@ -15,3 +18,3 @@ }
             number = number.toString();
-            if (isNaN(number) || number.indexOf('e') > -1)
+            if (isNaN(number))
                 throw Error("Parameter is not a number: " + number);
@@ -23,2 +26,19 @@ if (number[0] == '+')
             number = '0';
+        //handle exponentiation
+        if (/e/i.test(number)) {
+            var _a = number.split(/[eE]/), mantisa = _a[0], exponent = _a[1];
+            mantisa = add_1.trim(mantisa);
+            exponent = parseInt(exponent) + mantisa.indexOf('.');
+            mantisa = mantisa.replace('.', '');
+            if (mantisa.length < exponent) {
+                number = mantisa + (new Array(exponent - mantisa.length + 1)).join('0');
+            }
+            else if (mantisa.length >= exponent && exponent > 0) {
+                number = add_1.trim(mantisa.substring(0, exponent)) +
+                    ((mantisa.length > exponent) ? ('.' + mantisa.substring(exponent)) : '');
+            }
+            else {
+                number = '0.' + (new Array(-exponent + 1)).join('0') + mantisa;
+            }
+        }
         return number;
@@ -29,2 +49,24 @@ };
     };
+    bigDecimal.getPrettyValue = function (number, digits, separator) {
+        if (!(digits || separator)) {
+            digits = 3;
+            separator = ',';
+        }
+        else if (!(digits && separator)) {
+            throw Error('Illegal Arguments. Should pass both digits and separator or pass none');
+        }
+        var len = number.indexOf('.');
+        len = len > 0 ? len : (number.length);
+        var temp = '';
+        for (var i = len; i > 0;) {
+            if (i < digits) {
+                digits = i;
+                i = 0;
+            }
+            else
+                i -= digits;
+            temp = number.substring(i, i + digits) + ((i < (len - digits) && i >= 0) ? separator : '') + temp;
+        }
+        return temp + number.substring(len);
+    };
     bigDecimal.prototype.getPrettyValue = function (digits, separator) {
@@ -52,2 +94,9 @@ if (!(digits || separator)) {
     };
+    bigDecimal.round = function (number, precision) {
+        if (!precision)
+            precision = 0;
+        else if (isNaN(precision))
+            throw Error("Precision is not a number: " + precision);
+        return round_1.roundOff(number, precision);
+    };
     bigDecimal.prototype.round = function (precision) {
@@ -58,3 +107,3 @@ if (!precision)
             throw Error("Precision is not a number: " + precision);
-        return round_1.roundOff(this.value, precision);
+        return new bigDecimal(round_1.roundOff(this.value, precision));
     };
@@ -66,4 +115,46 @@ bigDecimal.add = function (number1, number2) {
     };
+    bigDecimal.prototype.add = function (number) {
+        return new bigDecimal(add_1.add(this.value, number.getValue()));
+    };
+    bigDecimal.subtract = function (number1, number2) {
+        number1 = bigDecimal.validate(number1);
+        number2 = bigDecimal.validate(number2);
+        return subtract_1.subtract(number1, number2);
+    };
+    bigDecimal.prototype.subtract = function (number) {
+        return new bigDecimal(subtract_1.subtract(this.value, number.getValue()));
+    };
+    bigDecimal.multiply = function (number1, number2) {
+        number1 = bigDecimal.validate(number1);
+        number2 = bigDecimal.validate(number2);
+        return multiply_1.multiply(number1, number2);
+    };
+    bigDecimal.prototype.multiply = function (number) {
+        return new bigDecimal(multiply_1.multiply(this.value, number.getValue()));
+    };
+    bigDecimal.divide = function (number1, number2) {
+        number1 = bigDecimal.validate(number1);
+        number2 = bigDecimal.validate(number2);
+        return divide_1.divide(number1, number2);
+    };
+    bigDecimal.prototype.divide = function (number) {
+        return new bigDecimal(divide_1.divide(this.value, number.getValue()));
+    };
+    bigDecimal.compareTo = function (number1, number2) {
+        number1 = bigDecimal.validate(number1);
+        number2 = bigDecimal.validate(number2);
+        return compareTo_1.compareTo(number1, number2);
+    };
+    bigDecimal.prototype.compareTo = function (number) {
+        return compareTo_1.compareTo(this.value, number.getValue());
+    };
+    bigDecimal.negate = function (number) {
+        number = bigDecimal.validate(number);
+        return subtract_1.negate(number);
+    };
+    bigDecimal.prototype.negate = function () {
+        return new bigDecimal(subtract_1.negate(this.value));
+    };
     return bigDecimal;
 }());
 exports.bigDecimal = bigDecimal;

lib/round.d.ts

 export declare function roundOff(input: any, n?: number): any;

lib/round.js

@@ -19,6 +19,6 @@ "use strict";
     else if (parts[1].length < n) {
-        return parseInt + '.' + (new Array(n - parts[1].length + 1).join('0'));
+        return partInt + '.' + parts[1] + (new Array(n - parts[1].length + 1).join('0'));
     }
     var partDec = parts[1].substring(0, n), rem = parts[1].substring(n);
-    if (greaterThanFive(rem, partDec)) {
+    if (rem && greaterThanFive(rem, partDec)) {
         partDec = increment(partDec);
@@ -25,0 +25,0 @@ if (partDec.length > n) {

package.json

 {
   "name": "js-big-decimal",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Work with large numbers on the client side. Round them off to any required precission.",
@@ -8,3 +8,4 @@ "main": "lib/big-decimal",
   "scripts": {
-    "test": "./node_modules/.bin/jasmine JASMINE_CONFIG_PATH=jasmine.json",
+    "test": "./node_modules/.bin/jasmine JASMINE_CONFIG_PATH=spec/jasmine.json --helper=spec/helper/*.js",
+    "travis-test": "./node_modules/.bin/jasmine JASMINE_CONFIG_PATH=spec/jasmine.json",
     "test-random": "node test/randomtest.js",
@@ -34,3 +35,5 @@ "compile": "./node_modules/.bin/tsc --watch"
   "devDependencies": {
+    "glob": "^7.1.2",
     "jasmine": "^2.6.0",
+    "jasmine-spec-reporter": "^4.1.1",
     "typescript": "^2.4.1"
@@ -37,0 +40,0 @@ },

README.md

@@ -5,5 +5,21 @@ # JS Big Decimal
 [![license](https://img.shields.io/github/license/royNiladri/js-big-decimal.svg?style=flat-square)](https://github.com/royNiladri/js-big-decimal/blob/master/LICENSE)
+[![npm](https://img.shields.io/npm/v/js-big-decimal.svg?style=flat-square)](https://www.npmjs.com/package/js-big-decimal)
 
 Work with large numbers on the client side with high precision.
 
+## Installation
+```javascript
+npm install --save js-big-decimal
+```
+
+### Usage
+Require in `javascript` as
+```jsavascript
+var bigDecimal = require(bigDecimal).bigDecimal;
+```
+For `typescript`, use
+```jsavascript
+import { bigDecimal } from 'bigDecimal';
+```
+
 ## Operations
@@ -14,3 +30,3 @@
 
-This does not support exponentiation as of yet. `12.456e3` will throw an error.
+It supports exponentiation, but only with integral exponent.
 
@@ -20,2 +36,3 @@ ```javascript
 var n2 = new bigDecimal("12345.6789");
+var n3 = new bigDecimal('12.456e3'); // 12456
 ```
@@ -29,5 +46,9 @@
 
-### getPrettyValue(digits, separator)
+### getPrettyValue(number, digits, separator)
 By default this returns the number in standard number format, comma after every three digts. Both arguments, `digits` - the number of digits (of the integral part) to group by, and `separator` - the character to mark the separation. Example of this can be to format a 16 digit number as _credit card_.
 ```javascript
+var value = bigDecimal.getPrettyValue("12345.6789"); // value = "12,345.6789"
+```
+Alternately, use the instance property. It returns the result as `string`.
+```javascript
 var n3 = n2.getPrettyValue(); // n4 = "12,345.6789"
@@ -39,14 +60,85 @@
 
-### round(precision)
-Returns the rounded value to the specified precission (number of digits after decimal). The default is set to 0 if no argument is passed.
+### round(number, precision)
+Returns the rounded value to the specified precision (number of digits after decimal). The default is set to 0 if no argument is passed.
 ```javascript
-var n3 = n1.round(2); // n3 = "12.68"
-var n4 = n2.round(); // n4 = "12346" 
+var value = bigDecimal.round("123.678", 2); // value = "123.68"
 ```
+Alternately, use the instance property. It returns the result as `bigDecimal`.
+```javascript
+var n3 = n1.round(2); // n3 = new bigDecimal("12.68")
+var n4 = n2.round(); // n4 = new bigDecimal("12346")
+```
 
-### add(number1, number2)
-Add two numbers. Pass in negative for substraction. ensure parameters are `strings`. 
+### compareTo(number1, number2)
+Compare two numbers. Returns `1, 0 and -1` if `number1 > number2, number1 == number2 and number1 < number2` respectively.
 ```javascript
+var value = bigDecimal.compareTo("23.678", "67.34"); // value = -1
+var value = bigDecimal.compareTo("23.678", "23.6780"); // value = 0
+var value = bigDecimal.compareTo("123.678", "67.34"); // value = 1
+```
+Alternately, use the instance property. It returns the result as `Integer`.
+```javascript
+var n1 = new bigDecimal('1234');
+var n2 = new bigDecimal('8765');
+var value = n1.compareTo(n2); // value = -1
+```
+
+### negate(number)
+Returns negation of a given number.
+```javascript
+var value = bigDecimal.negate("123.678"); // value = "-123.678";
+```
+Alternately, use the instance property. It returns the result as new `bigDecimal`.
+```javascript
+var n = new bigDecimal('-1234');
+var value = n.negate(); // value = new bigDecimal('1234')
+```
+
+### add(augend, addend)
+Add two numbers. Pass in negative for substraction. Ensure parameters are `string`s.
+```javascript
 var sum = bigDecimal.add("23.678", "67.34"); // sum = "91.018"
 var diff = bigDecimal.add("67.34", "-23.678"); // diff = "43.662"
+```
+Alternately, use the instance property. It returns the result as new `bigDecimal`.
+```javascript
+var n1 = new bigDecimal('1234');
+var n2 = new bigDecimal('8765');
+var sum = n1.add(n2); // sum = new bigDecimal('9999')
+```
+
+### subtract(minuend, subtrahend)
+Subtract one number from another
+```javascript
+var diff = bigDecimal.subtract("67.34", "23.678"); // diff = "43.662"
+```
+Alternately, use the instance property. It returns the result as new `bigDecimal`.
+```javascript
+var n1 = new bigDecimal('12.67');
+var n2 = new bigDecimal('130.7');
+var diff = n1.subtract(n2); // diff = new bigDecimal('-118.03')
+```
+
+### multiply(multiplicand, multiplier)
+Multiply two numbers. Ensure parameters are `string`s.
+```javascript
+var product = bigDecimal.multiply("-0.13", "0.00130"); // product = "-0.000169"
+```
+Alternately, use the instance property. It returns the result as new `bigDecimal`.
+```javascript
+var n1 = new bigDecimal('-0.13');
+var n2 = new bigDecimal('0.00130');
+var product = n1.multiply(n2); // product = new bigDecimal('-0.000169')
+```
+
+### divide(dividend, divisor, precision)
+Divide two numbers. Pass arguments as `string` if calling on bigDecimal or pass an instance of bigDecimal if calling on object. `precision` is an optional parameter with default value of 8.
+```javascript
+var quotient = bigDecimal.divide('45', '4', 2); // quotient = 11.25
+```
+Alternately, use the instance property. It returns the result as new `bigDecimal`.
+```javascript
+var n1 = new bigDecimal('45');
+var n2 = new bigDecimal('4');
+var quotient = n1.divide(n2); // quotient = new bigDecimal('11.25')
 ```

tsconfig.json

@@ -0,0 +0,0 @@ {

No alert changes

Improved metrics

Total package byte prevSize

30116

increased by126.83%

Number of package files

23

increased by64.29%

Lines of code

616

increased by152.46%

Number of lines in readme file

139

increased by195.74%

Worsened metrics

Dev dependency count

4

increased by100%

No dependency changes