Rounding up to 2 decimal places in C#

Question

I have a decimal number which can be like the following:

189.182

I want to round this up to 2 decimal places, so the output would be the following:

189.19

Is there built in functionality for this in the Math class, or something else? I know the ceiling function exists but this doesn't seem to do what I want - it'll round to the nearest int, so just '189' in this case.

Answer 1

Multiply by 100, call ceiling, divide by 100 does what I think you are asking for

public static double RoundUp(double input, int places)
{
    double multiplier = Math.Pow(10, Convert.ToDouble(places));
    return Math.Ceiling(input * multiplier) / multiplier;
}

Usage would look like:

RoundUp(189.182, 2);

This works by shifting the decimal point right 2 places (so it is to the right of the last 8) then performing the ceiling operation, then shifting the decimal point back to its original position.

Answer 2

You can use:

decimal n = 189.182M;
n = System.Math.Ceiling (n * 100) / 100;

An explanation of the various rounding functions can be found here.

---

Be aware that formulae like this are still constrained by the limited precision of the double type, should that be the type you are using (your question stated decimal but it's possible you may just have meant a floating point value with fractional component rather than that specific type).

For example:

double n = 283.79;
n = System.Math.Ceiling (n * 100);

will actually give you 28380, not the 283.79 you would expect^(a).

If you want accuarate results across the board, you should definitely be using the decimal type.

---

^(a) This is because the most accurate IEEE754 double precision representation of 283.79 is actually:

 283.790000000000020463630789891

That extra (admittedly minuscule) fractional component beyond the .79 gets ceilinged up, meaning it will give you a value higher than you would expect.

Answer 3

In .NET Core 3.0 and later versions, three additional rounding strategies are available through the MidpointRounding enumeration. Besides MidpointRounding.AwayFromZero and MidpointRounding.ToEven it now includes:

 1. MidpointRounding.ToNegativeInfinity
 2. MidpointRounding.ToPositiveInfinity
 3. MidpointRounding.ToZero

For this specific question you need to use MidpointRounding.ToPositiveInfinity, this will round the number up always. Note this only works if the number isn't negative. See table below for examples.

Original number	ToNegativeInfinity	ToPositiveInfinity	ToZero
3.55	3.5	3.6	3.5
2.83	2.8	2.9	2.8
2.54	2.5	2.6	2.5
2.16	2.1	2.2	2.1
-2.16	-2.2	-2.1	-2.1
-2.54	-2.6	-2.5	-2.5
-2.83	-2.9	-2.8	-2.8
-3.55	-3.6	-3.5	-3.5

For more information about midpointrounding see https://learn.microsoft.com/en-us/dotnet/api/system.midpointrounding

And of course the code to make it work:

// function explained: Math.Round(number, amount of decimals, MidpointRounding);
decimal number = 189.182m;
number =  Math.Round(number, 2, MidpointRounding.ToPositiveInfinity);
// result: number = 189.19

Answer 4

            var numberToBeRound1 = 4.125;
            var numberToBeRound2 = 4.175;
            var numberToBeRound3 = 4.631;
            var numberToBeRound4 = 4.638;
            var numberOfDecimalPlaces = 2;
            var multiplier = Math.Pow(10, numberOfDecimalPlaces);

            //To Round Up => 4.13
            var roundedUpNumber = Math.Ceiling(numberToBeRound1 * multiplier) / multiplier;

            //To Round Down => 4.12
            var roundedDownNumber = Math.Floor(numberToBeRound1 * multiplier) / multiplier;

            //To Round To Even => 4.12
            var roundedDownToEvenNumber = Math.Round(numberToBeRound1, numberOfDecimalPlaces, MidpointRounding.ToEven);

            //To Round To Even => 4.18
            var roundedUpToEvenNumber = Math.Round(numberToBeRound2, numberOfDecimalPlaces, MidpointRounding.ToEven);

            //To Round To Away From Zero => 4.63
            var roundedDownToAwayFromZero = Math.Round(numberToBeRound3, numberOfDecimalPlaces, MidpointRounding.AwayFromZero);

            //To Round To Away From Zero => 4.64
            var roundedUpToAwayFromZero2 = Math.Round(numberToBeRound4, numberOfDecimalPlaces, MidpointRounding.AwayFromZero);

Answer 5

How about

0.01 * ceil(100 * 189.182)

Answer 6

    public static decimal RoundUp(decimal input, int places)
    {
        decimal multiplier = (decimal)Math.Pow(10, places);
        return decimal.Ceiling(input * multiplier) / multiplier;
    }

Answer 7

   // Double will return the wrong value for some cases. eg: 160.80
    public static decimal  RoundUp(decimal input, int places)
    {
        decimal multiplier = Convert.ToDecimal(Math.Pow(10, Convert.ToDouble(places)));
        return Math.Ceiling(input * multiplier) / multiplier;
    }

Answer 8

One other quirky but fun way to do it is Math.Round() after offsetting the number.

decimal RoundUp(decimal n, int decimals)
{
    n += decimal.Parse($"1e-{decimals}", System.Globalization.NumberStyles.AllowExponent) / 2;
    n -= 1e-28m;
    return Math.Round(n, decimals);
}

decimal RoundDown(decimal n, int decimals)
{
    n -= decimal.Parse($"1e-{decimals}", System.Globalization.NumberStyles.AllowExponent) / 2;
    n += 1e-28m;
    return Math.Round(n, decimals);
}

Is has the advantage of not using Math.Pow() which uses double and thus can cause unpredictable rounding errors.

This solution basically uses the fact that midpoint rounding can be turned into up/down rounding if you increase/decrease the number a little:

• Math.Round(3.04m, 1) is 3.0 - not what we want
• Let's add 0.04(9) to it
• Math.Round(3.0899999999999999999999999999m, 1) is 3.1 - success!

Subtracting 1e-28m (= 0.0000000000000000000000000001) is important, because we want to be able to round up 3.0000000000000000000000000001 to 4, but 3.0000000000000000000000000000 should stay 3.