How to round a float by casting as an int in C

Question

So I am a second semester freshman in college. My teacher wants us to write a function that round a floating point number to the nearest hundredth. He said that we need to convert the floating point into an integer data type and then covert it back to a floating point. That's all he said. I have spent at least 5 hours trying different ways to do this.

This is my code so far:

#include <stdio.h>

int rounding(int roundedNum);
int main()
{
   float userNum,
         rounded;

   printf("\nThis program will round a number to the nearest hundredths\n");
   printf("\nPlease enter the number you want rounded\n>");

   scanf("%f", &userNum);

   rounded = rounding (userNum);

   printf("%f rounded is %f\n", userNum, rounded);

   return 0;
}

int rounding(int roundedNum)
{


   return roundedNum;
}

Answer 1

Your instructor may be thinking:

float RoundHundredth(float x)
{
    // Scale the hundredths place to the integer place.
    float y = x * 100;

    // Add .5 to cause rounding when converting to an integer.
    y += .5f;

    // Convert to an integer, which truncates.
    int n = y;

    // Convert back to float, undo scaling, and return.

    return n / 100.f;
}

This is a flawed solution because:

• Most C implementations use binary floating point. In binary floating-point, it is impossible to store any fractions that are not multiples of a negative power of two (½, ¼, ⅛, 1/16, 1/32, 1/64,…). So 1/100 cannot be exactly represented. Therefore, no matter what calculations you do, it is impossible to return exactly .01 or .79. The best you can do is get close.

• When you perform arithmetic on floating-point numbers, the results are rounded to the nearest representable value. This means that, in x * 100, the result is, in generally, not exactly 100 times x. There is a small error due to rounding. This error cause push the value across the point where rounding changes from one direction to another, so it can make the answer wrong. There are techniques for avoiding this sort of error, but they are too complicated for introductory classes.

• There is no need to convert to an integer to get truncation; C has a truncation function for floating-point built-in: trunc for double and truncf for float.

• Additionally, the use of truncation in converting to integer compelled us to add ½ to get rounding instead. But, once we are no longer using a conversion to an integer type to get an integer value, we can use the built-in function for rounding floating-point values to integer values: round for double and roundf for float.

If your C implementation has good formatted input/output routines, then an easy way to find the value of a floating-point number rounded to the nearest hundred is to format it (as with snprintf) using the conversion specifier %.2f. A proper C implementation will convert the number to decimal, with two digits after the decimal point, using correct rounding that avoids the arithmetic rounding errors mentioned above. However, then you will have the number in string form.

Answer 2

Here are some hints:

1. Multiply float with "some power of 10" to ensure the needed precision numbers are shifted left

2. Cast the new value to a new int variable so the unwanted float bits are discarded

3. Divide the int by the same power of 10 but add use a float form of that (e.g 10.0) so integer gets converted to float and the new value is the correct value

4. To test, use printf with the precision (.2f)

Answer 3

The two most common methods of rounding are "Away From Zero" and "Banker's Rounding (To Even)".

Pseudo-code for Rounding Away From Zero

EDIT Even though this is pseudo-code, I should have included the accounting for precision, since we are dealing with floating-point values here.

// this code is fixed for 2 decimal places (n = 2) and
// an expected precision limit of 0.001 (m = 3)
// for any values of n and m, the first multiplicand is 10^(n+1)
// the first divisor is 10^(m + 1), and
// the final divisor is 10^(n)

double roundAwayFromZero(double value) {
  boolean check to see if value is a negative number
  add precision bumper of (1.0 / 10000) to "value" // 10000.0 is 10^4
  multiply "value" by 1000.0 and cast to (int)  // 1000.0 is 10^3
  if boolean check is true, negate the integer to positive
  add 5 to integer result, and divide by 10
  if boolean check is true, negate the integer again
  divide the integer by 100.0 and return as double  // 100.0 is 10^2

  ex: -123.456
      true
      -123.456 + (1.0 / 10000.0) => -123.4561
      -123.4561 * 1000.0 => -123456.1 => -123456 as integer
      true, so => -(-123456) => 123456
      (123456 + 5) / 10 => 123461 / 10 => 12346
      true, so => -(12346) => -12346
      -12346 / 100.0 => -123.46 ===> return value
}

In your initial question, you expressed a desire for direction only, not the explicit answer in code. This is as vague as I can manage to make it while still making any sense. I'll leave the "Banker's Rounding" version for you to implement as an exercise.

Answer 4

Ok so I figured it out! thank yall for your answers.

//function
float rounding(float roundedNumber)
{
   roundedNumber = roundedNumber * 100.0f + 0.5f;
   roundedNumber = (int) roundedNumber * 0.01f;

   return roundedNumber;
}

So pretty much if I entered 56.12567 as roundedNumber, it would multiply by 100 yielding 5612.567. From there it would add .5 which would determine if it rounds up. In this case, it does. The number would change to 5613.067. Then you truncate it by converting it into a int and multiply by .01 to get the decimal back over. From there it returns the value to main and prints out the rounded number. Pretty odd way of rounding but I guess thats how you do it in C without using the rounding function.

Answer 5

Well, let's think about it. One thing that's helpful to know is that we can turn a float into an integer by casting:

float x = 5.4;
int y = (int) x;
//y is now equal to 5

When we cast, the float is truncated, meaning that whatever comes after the decimal point is dropped, regardless of its value (i.e. It always rounds towards 0).

So if you think about that and the fact that you care about the hundredths place, you could maybe imagine an approach that consists of manipulating your floating point number in someway such that when you cast it to an int you only truncate information you don't care about (i.e. digits past the hundredths place). Multiplying might be useful here.