Round up midpoint rounding option in c#

Question

Although I've seen several questions about rounding, I haven't found an answer to this. Is there any way in C# / .Net to do midpoint rounding up? That is to say, if a decimal is halfway between 2 integers, I want to always round UP. As far as I know, this is a common rounding method, so I'm surprised that it's not listed in the standard Math.Round options.

87.3 -> 87
87.8 -> 88
87.5 -> 88
-87.3 -> -87
-87.8 -> -88
-87.5 -> -87

The closest I could find was MidpointRounding.AwayFromZero, but this handles negatives incorrectly, as they will round down, not up.

score 8 · Accepted Answer · edited May 23 '17 at 10:34

How about:

Math.Floor(value + 0.5)

EDIT: The code above is correct in idea, but has some corner case bugs in the real world.

A strict solution would be:

static double Round(double val)
{
    // 0.49999999999999994 + 0.5 makes 1.
    if (val == 0.49999999999999994)
        return 0;

    // 4503599627370497.0 + 0.5 makes 4503599627370498.0.
    if (val <= -4503599627370496.0 || 4503599627370496.0 <= val)
        return val;

    return Math.Floor(val + 0.5);
}

What are those magic numbers?

0.49999999999999994 represents the greatest double value less than 0.5, that is:
1.1111111111 1111111111 1111111111 1111111111 1111111111 11₂ * 2^-2
and adding 0.5 makes exactly:
1.1111111111 1111111111 1111111111 1111111111 1111111111 111₂ * 2^-1

Since the last 1 bit exceeds the double-precision, the FPU rounds it to nearest even^[1]:
10.0000000000 0000000000 0000000000 0000000000 0000000000 00₂ * 2^-1
then normalizes to:
1.0000000000 0000000000 0000000000 0000000000 0000000000 00₂ * 2⁰
that is exactly 1.0.
Of course Round(0.49999999999999994) must be 0, so we simply return 0 in that special case.

The other magic number 4503599627370496.0 is 2⁵².
Odd numbers greater than that and less than 2⁵³ plus 0.5 rounds up to nearest even as well, for example 4503599627370497.0 + 0.5 makes:
1.0000000000 0000000000 0000000000 0000000000 0000000000 011₂ * 2⁵²
and rounds to:
1.0000000000 0000000000 0000000000 0000000000 0000000000 10₂ * 2⁵²
that is 4503599627370498.0.

So are the negative of those: -4503599627370497.0 + 0.5 rounds to -4503599627370496.0.

Actually we have no longer need to round such big numbers because they already don't have decimal part. All we need to do is return the given value itself without any operations in that situation.

See also

Notes

[1] CLI spec states:

The rounding mode defined in IEC 60559:1989 shall be set by the CLI to “round to the nearest number,” and neither the CIL nor the class library provide a mechanism for modifying this setting.

where "round to the nearest number" means "round to the nearest, ties to even", according to IEC 60559:1989(IEEE 754-1985).

In addition, neither the CIL nor the class library provide a mechanism for modifying this setting indeed, but we can change the rounding mode using CRT function _controlfp_s on Windows, at least on my environment: Win7 SP1 64bit, Intel Core i7-2600, .NET 4.0.
My experimental code below worked fine for me:

[DllImport("msvcrt.dll", CallingConvention = CallingConvention.Cdecl)]
static extern int _controlfp_s(IntPtr currentControl, uint newControl, uint mask);

static double RoundWithFPC(double val)
{
    // Set the round mode as "Round towards negative infinity."
    _controlfp_s(IntPtr.Zero, 0x100 /* _RC_DOWN */, 0x300 /* _MCW_RC */);
    double rounded = Math.Floor(val + 0.5);
    // Restore the round mode.
    _controlfp_s(IntPtr.Zero, 0x000 /* _RC_NEAR */, 0x300 /* _MCW_RC */);
    return rounded;
}

except that it returns -0 instead of 0 when the argument is -0.5.

So how about the decimal type? It works always fine, doesn't it?

No. As for decimal type, a correct method would be:

static decimal Round(decimal val)
{
    // 7922816251426433759354395035m + 0.5m makes 7922816251426433759354395036m.
    if (val <= -7922816251426433759354395034m || 7922816251426433759354395034m <= val)
        return val;

    return Math.Floor(val + 0.5m);
}

where 7922816251426433759354395034m is nearly decimal.MaxValue / 10.
A decimal value whose absolute is greater than that cannot have decimal part, thus it + 0.5 rounds to even.

You'll need to cast the result of `Math.Floor()` to an `int`, but this is correct, and much simpler. — krillgar, Aug 07 '14 at 15:40
Beware of corner cases: `0.49999999999999994` will round up to `1.0` with this method, and `5000000000000001.0` will result in `5000000000000002.0`. — Mark Dickinson, Aug 08 '14 at 07:18
@MarkDickinson Thank you for pointing it out. That's right. I've verified that 0.49999999999999994 + 0.5 makes exactly 1, which surprised and interested me. I can't explain why. I might have to create a new question for that after some researching. — Ripple, Aug 08 '14 at 14:30
@Ripple: I think there's already a question somewhere; let me see if I can find it. IIRC, there's an infamous Java round bug (now fixed) that had the same cause. It's essentially just a result of floating-point rounding: the result of that value plus 0.5 isn't exactly representable, and ends up being rounded up to 1.0. The other corner case is also a result of rounding an inexact sum. — Mark Dickinson, Aug 08 '14 at 17:50
@MarkDickinson Took so long, but now edited my answer. Please check it out if you had time. — Ripple, Aug 23 '14 at 10:26
Thank you for upvoting and giving me a chance to acquire new knowledge. — Ripple, Aug 23 '14 at 15:03

Matthew Watson · Answer 2 · 2014-08-07T17:13:12.377

1

EDIT: This works, but Ripple's answer is much better. I'll leave this here for posterity. ;)

public static int Round(double value)
{
    if ((value > 0) || (int)(value*2)==(value*2))
        return (int)(value + 0.5);
    else
        return (int)(value - 0.5);
}

This returns the correct values for all the examples in the OP.

edited Aug 07 '14 at 17:13

answered Aug 07 '14 at 15:22

Matthew Watson

104,400
10
158
276

1

What does the `(int)(value*2)==(value*2)` do? – krillgar Aug 07 '14 at 15:24
@krillgar It corrects the special case where a negative value has a .5 at the end. Without it, the wrong answers are given. So for `-87.5` the answer should be -87. – Matthew Watson Aug 07 '14 at 15:25
I guess you could do that by `value % 0.5 == 0` ? – Sriram Sakthivel Aug 07 '14 at 15:26
modular is quite an expensive operation in comparison – Meirion Hughes Aug 07 '14 at 15:28
@SriramSakthivel Yes, that would also work (I was just trying to use the simplest floating point operations as possible). – Matthew Watson Aug 07 '14 at 15:30
@MeirionHughes Can you give a reference? Even if it would, that wont be expensive more than two multiplications – Sriram Sakthivel Aug 07 '14 at 15:34
@SriramSakthivel Multiplication by two is highly optimised, even for floats. You could optimise it further by caching the result of `value*2`, but it might not make any difference. – Matthew Watson Aug 07 '14 at 15:35
@MatthewWatson I'd like to know more, If you can please cite it, Or refer some link where you read it? – Sriram Sakthivel Aug 07 '14 at 15:36
@SriramSakthivel I'll have to do that later - just leaving work! – Matthew Watson Aug 07 '14 at 15:39
@MatthewWatson It would be very kind of you if you can do that. Take your time. Thanks.. – Sriram Sakthivel Aug 07 '14 at 15:39

score 0 · Answer 3 · answered Aug 07 '14 at 17:51

This is what I came up with before I saw these answers, though Ripple's answer is much cleaner:

if (value - Math.Floor(value) == .5m)
{
    value = Math.Ceiling(value);
}
else
{
    value= Math.Round(value);
}

Even so, it is annoying and surprising that the Math class doesn't have this built in as an option for MidpointRounding.

Round up midpoint rounding option in c#

3 Answers3