17

Given a decimal '96.154', how can I ensure that it is always rounded up to 96.16 (as opposed to normal rounding to 2 decimals which would give 96.15).

Sam
  • 7,252
  • 16
  • 46
  • 65
Adam Goss
  • 1,017
  • 3
  • 14
  • 22

6 Answers6

19

Kind of hacky but a very intuitive way to do so:

var val = 96.154M;

var result = Math.Ceiling(val * 100) / 100.0M;
Oded
  • 489,969
  • 99
  • 883
  • 1,009
Yuck
  • 49,664
  • 13
  • 105
  • 135
7

You can add 0.005 to the value and then round the result.

Bruno Ferreira
  • 942
  • 9
  • 22
  • 1
    genius but, depends if you always want to round away from zero, what about negatives? – Jodrell Aug 03 '12 at 11:26
  • @Jodrell The title of the question says it all "always up". By the way, I upvoted the comment about negative numbers. – Bruno Ferreira Aug 03 '12 at 11:27
  • 4
    This will not work when the value is `96.150`, since that would round it to `96.16`, which is incorrect, since that it should stat `96.15`. – Steven Aug 03 '12 at 11:45
6

I think your looking for the Math.Ceiling method.

You could combine this with a multiplier to specify how many decimal places to round. Like this,

public float roundUp(float number, int numDecimalPlaces)
{
    double multiplier = Math.Pow(10, numDecimalPlaces))

    return Math.ceiling(number*multiplier) / multiplier;
}
Ben Ripley
  • 2,115
  • 21
  • 33
1

In case anyone is looking at this somewhat old question in 2022, the easiest way to do this with more recent versions of the framework/.NET core is this:

decimal.Round(96.154M, 2, MidpointRounding.ToPositiveInfinity)

This gives the result 96.16. The second parameter is the number of digits.

Note that if the input is negative and you want to round up to the nearest whole negative number, then you need to specify MidpointRounding.ToNegativeInfinity. Obviously you can test the input value's sign and use the appropriate MidpointRounding value if you want to support both scenarios.

paytools-steve
  • 3,580
  • 3
  • 26
  • 21
0

Here is the code of a roundUp method for a value and base fraction. The base fraction you should use for your question is 0.05M. However the method can be used for other common scenario which is base fraction 0.5M; And you can apply it in interesting ways like for example using a base fraction of 0.3M. Well I hope it should answer your questions, have fun :

static decimal roundUp(decimal aValue, decimal aBaseFraction)
{
   decimal quotient = aValue / aBaseFraction;
   decimal roundedQuotient = Math.Round(quotient, 0);
   decimal roundAdjust = 0.0M;
   if (quotient > roundedQuotient)
   {
      roundAdjust = aBaseFraction;
   }
   return roundAdjust + roundedQuotient * aBaseFraction;
}
Jorge Gonzalez
  • 1
  • 1
0

Here is my version of a RoundUp method, In this can specific decimal 

void Main()
{
    Console.WriteLine(RoundUp(2.8448M, 2));
    //RoundUp(2.8448M, 2).Dump();
}

public static decimal RoundUp(decimal numero, int numDecimales)
{
    decimal valorbase = Convert.ToDecimal(Math.Pow(10, numDecimales));
    decimal resultado = Decimal.Round(numero * 1.00000000M, numDecimales + 1, MidpointRounding.AwayFromZero) * valorbase;
    decimal valorResiduo = 10M * (resultado - Decimal.Truncate(resultado));

    if (valorResiduo < 5)
    {
        return Decimal.Round(numero * 1.00M, numDecimales, MidpointRounding.AwayFromZero);
    }
    else
    {
        var ajuste = Convert.ToDecimal(Math.Pow(10, -(numDecimales + 1)));
        numero += ajuste;
        return Decimal.Round(numero * 1.00000000M, numDecimales, MidpointRounding.AwayFromZero);
    }
}
Jorge Delgado
  • 1