Rounding double values in C++ like MS Excel does it

问题

I've searched all over the net, but I could not find a solution to my problem. I simply want a function that rounds double values like MS Excel does. Here is my code:

#include <iostream>
#include "math.h"

using namespace std;

double Round(double value, int precision) {
    return floor(((value * pow(10.0, precision)) + 0.5)) / pow(10.0, precision);
}

int main(int argc, char *argv[]) {
    /* The way MS Excel does it:
        1.27815 1.27840 ->  1.27828
        1.27813 1.27840 ->  1.27827
        1.27819 1.27843 ->  1.27831
        1.27999 1.28024 ->  1.28012
        1.27839 1.27866 ->  1.27853
    */
    cout << Round((1.27815 + 1.27840)/2, 5) << "\n"; // *
    cout << Round((1.27813 + 1.27840)/2, 5) << "\n";
    cout << Round((1.27819 + 1.27843)/2, 5) << "\n";
    cout << Round((1.27999 + 1.28024)/2, 5) << "\n"; // *
    cout << Round((1.27839 + 1.27866)/2, 5) << "\n"; // *

    if(Round((1.27815 + 1.27840)/2, 5) == 1.27828) {
                      cout << "Hurray...\n";
    }
    system("PAUSE");
    return EXIT_SUCCESS;
}

I have found the function here at stackoverflow, the answer states that it works like the built-in excel rounding routine, but it does not. Could you tell me what I'm missing?

回答1:

In a sense what you are asking for is not possible:

Floating point values on most common platforms do not have a notion of a "number of decimal places". Numbers like 2.3 or 8.71 simply cannot be represented precisely. Therefore, it makes no sense to ask for any function that will return a floating point value with a given number of non-zero decimal places -- such numbers simply do not exist.

The only thing you can do with floating point types is to compute the nearest representable approximation, and then print the result with the desired precision, which will give you the textual form of the number that you desire. To compute the representation, you can do this:

double round(double x, int n)
{
    int e;
    double d;

    std::frexp(x, &e);

    if (e >= 0) return x; // number is an integer, nothing to do

    double const f = std::pow(10.0, n);
    std::modf(x * f, &d);                 // d == integral part of 10^n * x

    return d / f;
}

(You can also use modf instead of frexp to determine whether x is already an integer. You should also check that n is non-negative, or otherwise define semantics for negative "precision".)

Alternatively to using floating point types, you could perform fixed point arithmetic. That is, you store everything as integers, but you treat them as units of, say, 1/1000. Then you could print such a number as follows:

 std::cout << n / 1000 << "." << n % 1000;

Addition works as expected, though you have to write your own multiplication function.

回答2:

To compare double values, you must specify a range of comparison, where the result could be considered "safe". You could use a macro for that.

Here is one example of what you could use:

#define COMPARE( A, B, PRECISION ) ( ( A >= B - PRECISION ) && ( A <= B + PRECISION ) ) 

int main()
{
  double a = 12.34567;
  bool equal = COMPARE( a, 12.34567F, 0.0002 );

  equal = COMPARE( a, 15.34567F, 0.0002 );
  return 0;
}

回答3:

Thank you all for your answers! After considering the possible solutions I changed the original Round() function in my code to adding 0.6 instead of 0.5 to the value.

The value "127827.5" (I do understand that this is not an exact representation!) becomes "127828.1" and finally through floor() and dividing it becomes "1.27828" (or something more like 1.2782800..001). Using COMPARE suggested by Renan Greinert with a correctly chosen precision I can safely compare the values now.

Here is the final version:

#include <iostream>
#include "math.h"
#define COMPARE(A, B, PRECISION) ((A >= B-PRECISION) && (A <= B+PRECISION))

using namespace std;

double Round(double value, int precision) {
    return floor(value * pow(10.0, precision) + 0.6) / pow(10.0, precision);
}
int main(int argc, char *argv[]) {
    /* The way MS Excel does it:
        1.27815 1.27840 // 1.27828
        1.27813 1.27840 ->  1.27827
        1.27819 1.27843 ->  1.27831
        1.27999 1.28024 ->  1.28012
        1.27839 1.27866 ->  1.27853
    */
    cout << Round((1.27815 + 1.27840)/2, 5) << "\n"; 
    cout << Round((1.27813 + 1.27840)/2, 5) << "\n";
    cout << Round((1.27819 + 1.27843)/2, 5) << "\n";
    cout << Round((1.27999 + 1.28024)/2, 5) << "\n";
    cout << Round((1.27839 + 1.27866)/2, 5) << "\n";

    //Comparing the rounded value against a fixed one
    if(COMPARE(Round((1.27815 + 1.27840)/2, 5), 1.27828, 0.000001)) {
       cout << "Hurray!\n";
    }
    //Comparing two rounded values
    if(COMPARE(Round((1.27815 + 1.27840)/2, 5), Round((1.27814 + 1.27841)/2, 5), 0.000001)) {
       cout << "Hurray!\n";
    }    

    system("PAUSE");
    return EXIT_SUCCESS;
}

I've tested it by rounding a hundred double values and than comparing the results to what Excel gives. They were all the same.

回答4:

I'm afraid the answer is that Round cannot perform magic.
Since 1.27828 is not exactly representable as a double, you cannot compare some double with 1.27828 and hope it will match.

回答5:

You need to do the maths without the decimal part, to get that numbers... so something like this.

double dPow = pow(10.0, 5.0);

    double a = 1.27815;
    double b = 1.27840;


    double a2 = 1.27815 * dPow;
    double b2 = 1.27840 * dPow;

    double c = (a2 + b2) / 2 + 0.5;

Using your function...

double c = (Round(a) + Round(b)) / 2 + 0.5;

来源：https://stackoverflow.com/questions/8758156/rounding-double-values-in-c-like-ms-excel-does-it

标签

c++

excel

double

rounding