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.

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

@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.

... round a float value, say val to its nearest multiple of 0.05 ...

Given typical binary floating point, the best that can be had is

... round a float value to nearest to a multiple of 0.05 R and save as the nearest representable float r.

Method #1 is unclear in the corner cases. What OP has is not code, but an outline of code from a math perspective and not an actual C code one. I'd go with a variation on #2 that works very well. @Barmar

Almost method 2: Multiply, round, then divide.

#include <math.h>
double factor = 20.0;
float val = foo();
double_or_float rounded_val = round(val * factor)/factor;

This method has two subtle points that make it superior.

1. The multiplication is done with greater precision and range than the referenced answer - this allows for an exact product and a very precise quotient. If the product/quotient were calculated with only float math, some edge cases would end up with the wrong answer and of course some large values would overflow to infinity.

2. "Ties are settled by taking lower value." is a tough and unusual goal. Sounds like a goal geared to skew selection. round(double) nicely rounds half way cases away from zero regardless of the current rounding direction. To accomplish "lower", change the current rounding direction and use rint() or nearbyint().

   #include <fenv.h>
   int current_rounding_direction = fegetround();
   fesetround(FE_DOWNWARD);
   double rounded_val = rint(val * factor)/factor;
   fesetround(current_rounding_direction);
   

... method-2 yields wrong results some times...

OP needs to post the code and the exact values used and calculated for a quality explanation of the strength/weakness of various methods. Try printf("%a %a\n", val, rounded_val);. Often, problems occurs due to imprecise understanding of the exact values used should code use printf("%f\n", val);

Further: "I already have upper and lower bounds of val, say valU and valL respectively. I can do this in the following ways:"

This is doubtfully accurate as the deviation of valU and valL is just an iteration of the original problem - to find rounded_val. The code to find valL and valU each needs an upper and lower bound, else what is to prevent range [valL ... valU] from itself having inaccurate endpoints?

You can always just pass it to a ceil function. Something like this would round it up to two decimal places:

#include <cmath>

int roundUp(float toRound) {
    return ceil(toRound * 100) / 100;
}

This will return the value rounded up but you can replace ceil() with floor() to round down.

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

I know this is old post but just in case someone else is looking for a quick Two step option.

float old = -3.04299553323;  
float new = [[NSString stringWithFormat:@"%.2f",old]floatValue];

Result = -3.04

The @"%.2f" will round to two decimal places. If you want three decimal places put @"%.3f" and so on.

Hope this helps!