To round a double up to 2 decimal places, you can use:

Use with AI#include <iostream>
#include <cmath>

int main() {
    double value = 0.123;
    value = std::ceil(value * 100.0) / 100.0;
    std::cout << value << std::endl; // prints 0.13
    return 0;
}

To round up to n decimal places, you can use:

Use with AIdouble round_up(double value, int decimal_places) {
    const double multiplier = std::pow(10.0, decimal_places);
    return std::ceil(value * multiplier) / multiplier;
}

This method won't be particularly fast, if performance becomes an issue you may need another solution.

If you just want to round the number for output purposes, then the "%.2f" format string is indeed the correct answer. However, if you actually want to round the floating point value for further computation, something like the following works:

#include <math.h>

float val = 37.777779;

float rounded_down = floorf(val * 100) / 100;   /* Result: 37.77 */
float nearest = roundf(val * 100) / 100;  /* Result: 37.78 */
float rounded_up = ceilf(val * 100) / 100;      /* Result: 37.78 */

Notice that there are three different rounding rules you might want to choose: round down (ie, truncate after two decimal places), rounded to nearest, and round up. Usually, you want round to nearest.

As several others have pointed out, due to the quirks of floating point representation, these rounded values may not be exactly the "obvious" decimal values, but they will be very very close.

For much (much!) more information on rounding, and especially on tie-breaking rules for rounding to nearest, see the Wikipedia article on Rounding.

This works:

inputValue = Math.Round(inputValue, 2);

@Rashmi solution provides a nicely rounded display of a floating point value.
It does not change the value of the original number.

If one wants to round a floating point value to the nearest 0.01 use round()

#include <math.h>
double d = 1.2345;
d = round(d * 100.0)/100.0;

Notes:

Due to FP limitations, the rounded value may not be exactly a multiple of 0.01, but will be the closest FP number a given platform allows.

When d is very close to x.xx5, (x is various digits 0-9) d * 100.0 introduces a rounding in the product before the round() call. Code may round the wrong way.

double someValue = 2.346;    
String.Format("{0:0.00}", someValue);

Well I need to value to change so I used x = (double)((int)(x*100))/100;

This works, but you are limited to a relatively low range, i.e: 123456789 * 100 overflows.

Check if modf helps:

#include <stdio.h>
#include <math.h>

double dec2(double number)
{
    double fractpart, intpart;

    fractpart = modf(number, &intpart);
    return intpart + round(fractpart * 100) * 0.01;
}

int main(void)
{
    printf("%f\n", dec2(0.1234));
    printf("%f\n", dec2(3.14159));
    return 0;
}

Output:

0.120000
3.140000

Using recursion (which is going to be slow for some values of digits)

#include <math.h>
double my_round(double x, unsigned int digits) {
  if (digits > 0) {
    return my_round(x*10.0, digits-1)/10.0;
  }
  else {
    return round(x);
  }
}

A method likely to be somewhat faster, but which relies on a single call to the slow pow function:

#include <math.h>

double my_round(double x, unsigned int digits) {
    double fac = pow(10, digits);
    return round(x*fac)/fac;
}

An even faster method is to precompute a lookup table with the likely powers and use that instead of pow.

#include <math.h>

double fac[];  // population of this is left as an exercise for the reader

double my_round(double x, unsigned int digits) {
    return round(x*fac[digits])/fac[digits];
}

Here's some examples:

decimal a = 1.994444M;

Math.Round(a, 2); //returns 1.99

decimal b = 1.995555M;

Math.Round(b, 2); //returns 2.00

You might also want to look at bankers rounding / round-to-even with the following overload:

Math.Round(a, 2, MidpointRounding.ToEven);

There's more information on it here.

It is necessary that the number be stored in a variable as number = 136.25

But that would be the incorrect result. The precise result of number + number * 0.1 is 136.26787141. When you round that downwards to 2 decimal places, the number that you would get is 136.26, and not 136.25.

However, there is no way to store 136.26 in a float because it simply isn't a representable value (on your system). Best you can get is a value that is very close to it. You have successfully produced a floating point number that is very close to 136.26. If you cannot accept the slight error in the value, then you shouldn't be using finite precision floating point arithmetic.

If you wish to print the value of a floating point number up to limited number of decimals, you must understand that not all values can be represented by floating point numbers, and that you must use %.2f to get desired output.

Round float to 2 decimal places in C language?

Just like you did:

• multiply with 100
• round
• divide by 100

You can use the following algorithm:

• multiply with 100
• round to nearest integer
• divide by 100

This algorithm has problems with big values that are very close to maximum representable as the multiplication may overflow.

Another approach is to use the stream manipulators as you would with std::cout but stream into a string, and then convert that string back into a floating point number. This is much slower, but has no caveat mentioned above.