can my code determine if it needs a big number?

Question

I am writing a method that must return a numeric value which is a result of an arithmetic operation applied to two input numbers.

If the operation results in an overflow then I need to use an existing big number implementation (specifically, https://github.com/MikeMcl/decimal.js/), if not then I need to return a built in Javascript Number.

Is it possible, in code, to determine that I have an overflow and I need a big number?

Answer 1

You could do it like this:

function multiply(a, b) {
  var res = a * b;
  if (isFinite(res)) {
    return res;
  }

  return new Decimal(a).times(b);
}

multiply(2, 3);         // returns number 6
multiply(2e200, 3e200); // returns BigNumber 6e+400

However, I think it may be a better idea to always return the same type of output (i.e. BigNumber), independent of the input. Right now when you use this function you always have to check what the returned result is (number or BigNumber), and act accordingly.

Answer 2

I think you will find it simpler to use the Big Number library from the start and then once you have the sum in the Big Number format, you can test it to see if it is small enough to fit in a regular Javascript Number and, if so, convert it to that and return that.

While this approach is slightly inefficient (involves extra conversions in some cases), it prevents you from having to predict whether the result of a math operation you haven't yet done is too big which can be kind of difficult to do and get right. Just using Big Number for the math operation guarantees that the math operation is correct and then lets you just see how big the result is and act accordingly.

If you were only doing addition or subtraction of two values, you could probably write a predictive function, but I'd be surprised if the extra effort to get this right was actually worth whatever savings there really was. Once you're doing a more complex math operation (multiple operands or multiplication or division), then you're going to need to re-implement part of the math operation in order to predict the size of the result.

For reference, my hierarchy of priorities in writing software is:

1. Correctness
2. Robustness (ability to deal with edge cases, unexpected input and any error cases)
3. Clarity and Maintainability of the code
4. Extensibility and Reusability
5. Performance (only when the performance is actually relevant)
6. Compactness

I will sacrifice some aspects of 3, 4 to improve performance, but only when I've proven that improving the performance of this particular piece of code is important to the goal of the project and only after measuring that the performance of this particular piece of code is actually the issue worth spending time on. I will never sacrifice 1 or 2 to improve performance. In your particular case, I'd look long and hard at whether the performance impact of using Big Number to do the math operation is really a problem worth sacrificing a number of other priorities for.