rounding using both precision and decimals

Author: dqnykamp

build/math-expressions.js

@@ -89,3 +89,60 @@ const round_numbers_to_decimals_sub = function(tree, ndecimals=0) {
   return [operator, ...operands.map(x => round_numbers_to_decimals_sub(x,ndecimals))]
 }
 
+
+
+export function round_numbers_to_precision_plus_decimals(expr_or_tree, digits=4, ndecimals=2) {
+  // round any decimals to specified number of significant digits
+  // but increase number of digits to ensure number of decimals
+
+  var tree = get_tree(expr_or_tree);
+
+  if(digits < 1) {
+    throw Error("For round_numbers_to_precision_plus_decimals, digits must be positive");
+  }
+
+  if(!Number.isFinite(digits)) {
+    throw Error("For round_numbers_to_precision_plus_decimals, digits must be a number");
+  }
+
+  if(!Number.isFinite(ndecimals)) {
+    throw Error("For round_numbers_to_precision_plus_decimals, ndecimals must be a number");
+  }
+
+  if(digits > 15) {
+    return tree;
+  }
+
+  digits = Math.round(digits);
+
+  ndecimals = Math.round(ndecimals);
+
+  // no need to go much beyond limits of double precision
+  ndecimals = Math.max(-330, Math.min(330, ndecimals));
+
+  return round_numbers_to_precision_plus_decimals_sub(tree,digits, ndecimals);
+}
+
+const round_numbers_to_precision_plus_decimals_sub = function(tree, digits=4, ndecimals=2) {
+
+  if(typeof tree === "number") {
+
+    if(Number.isFinite(tree) && tree !== 0) {
+      const scaleFactor = math.floor(math.log10(math.abs(tree)));
+      const n = Math.max(digits - scaleFactor - 1, ndecimals);
+      if(n < 0) {
+        // mathjs toFixed truncates zeros when n is negative
+        // so add back on when creating float
+        return parseFloat(toFixed(tree, n)+'0'.repeat(math.abs(n)));
+      } else {
+        return parseFloat(toFixed(tree, n))
+      }
+    }
+  }
+  if(!Array.isArray(tree)) {
+    return tree;
+  }
+  let operator = tree[0];
+  let operands = tree.slice(1);
+  return [operator, ...operands.map(x => round_numbers_to_precision_plus_decimals_sub(x,digits,ndecimals))]
+}

build/math-expressions_umd.js

@@ -1,7 +1,7 @@
 {
   "name": "math-expressions",
   "description": "Perform basic equality testing and symbolic computations on mathematical expressions involving transcendental functions",
-  "version": "2.0.0-alpha60",
+  "version": "2.0.0-alpha61",
   "author": {
     "name": "Jim Fowler",
     "email": "[email protected]",

lib/expression/round.js

@@ -147,4 +147,79 @@ describe("round to decimals", function () {
   });
 
 
+  describe("round to significant digits plus decimals", function () {
+
+    it("single number", function () {
+  
+      let expr = me.fromText('1.234567890123456789');
+      expect(expr.round_numbers_to_precision_plus_decimals(100,6).tree).toEqual(1.2345678901234567)
+      expect(expr.round_numbers_to_precision_plus_decimals(14,6).tree).toEqual(1.2345678901235)
+      expect(expr.round_numbers_to_precision_plus_decimals(10,6).tree).toEqual(1.23456789)
+      expect(expr.round_numbers_to_precision_plus_decimals(4,6).tree).toEqual(1.234568)
+  
+      expr = me.fromText('12345678901234567890000000000');
+      expect(expr.round_numbers_to_precision_plus_decimals(100,-17).tree).toEqual(12345678901234568000000000000)
+      expect(expr.round_numbers_to_precision_plus_decimals(14,-17).tree).toEqual(12345678901235000000000000000)
+      expect(expr.round_numbers_to_precision_plus_decimals(10,-17).tree).toEqual(12345678901200000000000000000)
+      expect(expr.round_numbers_to_precision_plus_decimals(4,-17).tree).toEqual(12345678901200000000000000000)
+  
+      expr = me.fromText('0.000000000000000000001234567890123456789');
+      expect(expr.round_numbers_to_precision_plus_decimals(100,27).tree).toEqual(0.0000000000000000000012345678901234568)
+      expect(expr.round_numbers_to_precision_plus_decimals(14,27).tree).toEqual(0.0000000000000000000012345678901235)
+      expect(expr.round_numbers_to_precision_plus_decimals(10,27).tree).toEqual(0.00000000000000000000123456789)
+      expect(expr.round_numbers_to_precision_plus_decimals(4,27).tree).toEqual(0.000000000000000000001234568)
+  
+      expect(me.fromAst(0).round_numbers_to_precision_plus_decimals(10,2).tree).toEqual(0)
+      expect(me.fromAst(Infinity).round_numbers_to_precision_plus_decimals(10,2).tree).toEqual(Infinity)
+      expect(me.fromAst(-Infinity).round_numbers_to_precision_plus_decimals(10,2).tree).toEqual(-Infinity)
+  
+    });
+  
+    it("expression", function () {
+  
+      let expr = me.fromText('exp(1.234567890123456789x+9.876543210987654321)/(5+8520203156.435345956432x)');
+      expect(expr.round_numbers_to_precision_plus_decimals(100,5).equals(
+        me.fromText('exp(1.2345678901234567 x + 9.876543210987654)/(5 + 8520203156.435346 x)'))).toBeTruthy();
+      expect(expr.round_numbers_to_precision_plus_decimals(14,5).equals(
+        me.fromText('exp(1.2345678901235 x + 9.8765432109877)/(5 + 8520203156.43535 x)'))).toBeTruthy();
+      expect(expr.round_numbers_to_precision_plus_decimals(10,5).equals(
+        me.fromText('exp(1.23456789 x + 9.876543211)/(5 + 8520203156.43535 x)'))).toBeTruthy();
+      expect(expr.round_numbers_to_precision_plus_decimals(4,5).equals(
+        me.fromText('exp(1.23457 x + 9.87654)/(5 + 8520203156.43535 x)'))).toBeTruthy();
+  
+    });
+  
+    it("don't round fractions", function () {
+  
+      let expr = me.fromText('3/7x + 381439619649.253 y');
+      expect(expr.round_numbers_to_precision_plus_decimals(100,-2).equals(
+        me.fromText('3/7x + 381439619649.253 y'))).toBeTruthy();
+      expect(expr.round_numbers_to_precision_plus_decimals(14,-2).equals(
+        me.fromText('3/7x + 381439619649.25 y'))).toBeTruthy();
+      expect(expr.round_numbers_to_precision_plus_decimals(10,-2).equals(
+        me.fromText('3/7x + 381439619600 y'))).toBeTruthy();
+      expect(expr.round_numbers_to_precision_plus_decimals(4,-2).equals(
+        me.fromText('3/7x + 381439619600 y'))).toBeTruthy();
+  
+    });
+  
+  
+    it("don't round pi or e", function () {
+  
+      let expr = me.fromText('3/7e + 381439619649.253 pi');
+      expect(expr.round_numbers_to_precision_plus_decimals(100,1).equals(
+        me.fromText('3/7exp(1) + 381439619649.253 pi'))).toBeTruthy();
+      expect(expr.round_numbers_to_precision_plus_decimals(14,1).equals(
+        me.fromText('3/7exp(1) + 381439619649.25 pi'))).toBeTruthy();
+      expect(expr.round_numbers_to_precision_plus_decimals(10,1).equals(
+        me.fromText('3/7exp(1) + 381439619649.3 pi'))).toBeTruthy();
+      expect(expr.round_numbers_to_precision_plus_decimals(4,1).equals(
+        me.fromText('3/7exp(1) + 381439619649.3 pi'))).toBeTruthy();
+  
+    });
+  
+  
+  });
+  
+
 });