Is there a way to take a number as a string, and without using float or double, round it to the exact number of digits?

Question

I have a very large Decimal number as a string, it cannot be accurately represented by a float or double, so I cannot use any function that works with numbers, I have to keep my number as string, and do all functions with strings.

For example: PI:

string pI = round("3.141592653589793239", 6);

will return "3.141593".

Precision normally refers to total number of digits, as such my answer has a Precision of 7, so I will call this Decimal Places as to not confuse this issue.

I realize I could just write a function to do this, and I am working on it, but I wanted to ask for the most accurate way of doing this, and so far that is not my code, I blame it on my headache, but I have spent way too much time looking for a solution, getting caught up in using this Library and that one, when it seems there should be a library that does just this, without using floating-point math, and I have looked at a few arbitrary-precision arithmetic libraries, and have not been able to figure out how to set the number of Decimal Places, and have tried using the Precision, and came to stand still, because the numbers it gave me were not correct at the low range, between 0-42 decimal places.

I am using this in a Qt Qml Felgo App, so I will be calling it from Qml JavaScript, via a C++ back end call.

Update: Writing my string round function got ugly real quick, too many things to check for, its just as easy as it may sound till you start testing from them.

Looking at

CLN: https://ginac.de/CLN/cln.html

MPIR: https://github.com/wbhart/mpir

A fork of GMP: http://gmplib.org/

TTMath BigNum: https://sourceforge.net/projects/ttmath/

And I have an issue with Boost that ended in a bug report, and I thought I could write my own round function, so I could use their library, but what is the point, no matter what Library I use, I have a requirement for accuracy, and decimal point places.

People that have a need for Math, need a Math Library that can handle all their needs, and rounding to a specific decimal place is a given, yet I am having a hard time finding a function in any library that can to this well, so I have to test every library, and that is not easy, first you have to learn how to use it, and if it does not work the way you think it should, you end up spending more time, like I am doing here, trying to figure it out, and trust me, I read all the post about using big numbers, Floats specifically, that I could find, but none of them really dealt with arbitrary decimal point precision, meaning to do math at a specific decimal precision, most people think more is more accurate, that is not my case, I am looking for a way to do math that will return the correct number and not an estimation of it, float and long double is an estimate I cannot use, it was off by 100 miles, that bugs me, but not as much as just bad estimates, boost gave me the correct number, I just could not figure out how to use precision to adjust the number of digits, and that is not really boost thing, since they have never though it important enough to add a function to set decimal places, few people I know care about precision, they just care about how many decimal places it has, and specifically returning a set number of decimal places without having to use precision to do so, I thought that if I took the length of the left side, or whole number side, and add the precision to it, that it should work, I was wrong, and the results were too, so what I really need is a library that understands this.

I relize now that every calculator is actually an estimator at best.

I did find a library that worked with numbers, did not try it, but to be complete here is is:

https://www.codewars.com/kata/5324945e2ece5e1f32000370

I like the concept of libmpdec, so I will work on that now.

I ended up using https://github.com/MikeMcl/bignumber.js it works great in Qml, just import "bignumber.js" as BigNumberJs, and following the instructions.

Thanks for all the help.

Answer 1

Given you need precise decimal places, all of the libraries you mentioned are either out of bounds or will require setting absurd levels of precision to guarantee your results are rounded accurately.

The problem is they're all based on binary floating point, so when you specify a precision, e.g. with mpf_set_default_prec in GMP/MPIR (or the equivalent call in MPFR, a fork of GMP that provides more guarantees on exact, portable precision), you're saying how many bits will be used for the significand (roughly, how many bits of integer precision exist before it is scaled by the exponent). While there is a rough correspondence to decimal precision (so using four bits of significand for every one decimal digit of precision needed is usually good enough for most purposes), the lack of decimal precision means explicit output rounding is always needed to avoid false precision, and there is always the risk of inconsistent rounding: a number that logically ends in 5 and should be subjected to rounding rules like round half-even, round half-up or round half-down might end up with false precision that makes it appear to not end exactly with 5, so the rounding rules aren't applied.

What you want is a decimal math library, like Java's BigDecimal, Python's decimal, etc. The C/C++ standard library for this is libmpdec, the core of the mpdecimal package (on Python 3.3+, this is the backend for the decimal module, so you can experiment with its behavior on Python before committing to using it in your C/C++ project). Since it's decimal based, you have guaranteed precision levels; if you set the precision to 4 and mode to ROUND_HALF_EVEN, then parsing "XX.X45" will consistently produce "XX.X4", while "XX.X75" will consistently produce "XX.X8" (the final 5 rounds the next digit to even numbers). You can also "quantize" to round to a specific precision after the decimal point (so your precision might be 100 to allow for 100 digits combined on left and right hand sides of the decimal point, but you can quantize relative to "0.0000" to force rounding of the right hand of the decimal to exactly four digits).

Point is, if you want to perform exact decimal rounding of strings representing numbers in the reals in C/C++, take a look at libmpdec.

For your particular use case, a Python version of the code (using the moneyfmt recipe, because formatting numbers like "1.1E-26" to avoid scientific notation is a pain) would look roughly like:

from decimal import localcontext

def round_string(s, digits, rounding=None):
    '''
    Round string s representing a decimal floating point number to the specific digits of precision

    rounding is the current context's default mode if passed as None, otherwise
    any decimal module rounding mode is accepted.
    '''
    s = s.strip()  # Remove whitespace to get "real" length of string
    with localcontext() as ctx:
        # For inputs that may be in scientific notation, it's kind of annoying to
        # determine required precision, so we make a stab at it that's almost always
        # overestimating, but should work consistently
        decpart, sep, exp = s.lower().partition('e')
        ctx.prec = len(decpart) + digits + (abs(int(exp)) if sep else 0)
        if rounding is not None:
            ctx.rounding = rounding
        return moneyfmt(ctx.create_decimal(s), digits, sep='')

Obviously, equivalent C++ code will be somewhat more complicated, but not necessarily by much; the moneyfmt recipe can be simplified to avoid handling a bunch of monetary things we don't need, and if you don't need to handle scientific notation, the precision calculation is simpler. Regardless, libmpdec is the ultimate source of Python 3.3+'s decimal package, so all of it can be done, with guaranteed conformance with the IEEE 754 decimal floating point specification.