Controlling Decimal Precision of Floats in C

Floating-point numbers (floats and doubles) are often used to represent real numbers in C. However, their internal representation can lead to results with many decimal places. Controlling the number of decimal places displayed or stored is a common requirement in many applications. This tutorial explains how to achieve this in C, covering both presentation for output and adjustments for further calculations.

Understanding the Issue

Due to the way floating-point numbers are represented in binary, they can’t always represent decimal values exactly. This can lead to results like 37.777779 instead of the more intuitive 37.78. Therefore, it’s important to distinguish between displaying a value with a specific precision and actually modifying the stored value.

Displaying Floating-Point Numbers with Controlled Precision

The simplest and most common approach is to control the precision when displaying the number. This doesn’t change the underlying value; it only affects how it’s presented to the user.

The printf function provides a powerful way to format output, including controlling the number of decimal places. Use the format specifier %.nf, where n is the desired number of decimal places.

#include <stdio.h>

int main() {
  float value = 37.777779;

  printf("%.2f\n", value);  // Output: 37.78
  printf("%.1f\n", value);  // Output: 37.8
  printf("%.3f\n", value);  // Output: 37.778

  return 0;
}

In this example, %.2f rounds the float to two decimal places for display. The actual value variable remains unchanged.

Rounding for Computation

If you need to modify the floating-point value itself for further calculations, several methods can be used:

1. Using floorf, ceilf, and roundf:

These functions from the math.h library provide different rounding options:

floorf(x): Rounds down to the nearest integer.
ceilf(x): Rounds up to the nearest integer.
roundf(x): Rounds to the nearest integer.

To round to two decimal places, multiply by 100, round to the nearest integer, and then divide by 100.

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

int main() {
  float value = 37.777779;

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

  printf("Rounded down: %.2f\n", rounded_down);
  printf("Rounded to nearest: %.2f\n", nearest);
  printf("Rounded up: %.2f\n", rounded_up);

  return 0;
}

2. Integer Conversion and Division:

Another method involves multiplying by 100, adding 0.5 (to achieve rounding to the nearest integer), casting to an integer, and then dividing by 100.0.

#include <stdio.h>

int main() {
  float value = 37.777779;
  float rounded = ((int)(value * 100 + .5) / 100.0);

  printf("Rounded: %.2f\n", rounded);

  return 0;
}

Storing Rounded Values as Strings

If you need to store the rounded value as a string, you can use the sprintf function.

#include <stdio.h>

int main() {
  float value = 37.777779;
  char number[24]; // Ensure sufficient size for the string

  sprintf(number, "%.2f", value);

  printf("Rounded string: %s\n", number);

  return 0;
}

Important Considerations:

Floating-Point Precision: Be aware that floating-point numbers are inherently imprecise. Rounding can help with display and comparison, but it doesn’t eliminate the underlying imprecision.
Comparison: Avoid direct equality comparisons of floating-point numbers. Instead, check if the difference between two numbers is within a small tolerance (epsilon).
Financial Calculations: For financial calculations, it’s generally recommended to use integer arithmetic or specialized decimal data types to avoid rounding errors.