How to set precision of a float?

Question

For a number a = 1.263839, we can do - float a = 1.263839 cout << fixed << setprecision(2) << a <<endl; output :- 1.26

But what if i want set precision of a number and store it, for example- convert 1.263839 to 1.26 without printing it.

Answer 1

Using a stringstream would be an easy way to achieve that:

#include <iostream>
#include <iomanip>
#include <sstream>
using namespace std;

int main() {
    stringstream s("");
    s << fixed << setprecision(2) << 1.263839;
    float a;
    s >> a;
    cout << a; //Outputs 1.26
    return 0;
}

Answer 2

But what if i want set precision of a number and store it

You can store the desired precision in a variable:

int precision = 2;

You can then later use this stored precision when converting the float to a string:

std::cout << std::setprecision(precision) << a;

---

I think OP wants to convert from 1.263839 to 1.26 without printing the number.

If this is your goal, then you first must realise, that 1.26 is not representable by most commonly used floating point representation. The closest representable 32 bit binary IEEE-754 value is 1.2599999904632568359375.

So, assuming such representation, the best that you can hope for is some value that is very close to 1.26. In best case the one I showed, but since we need to calculate the value, keep in mind that some tiny error may be involved beyond the inability to precisely represent the value (at least in theory; there is no error with your example input using the algorithm below, but the possibility of accuracy loss should always be considered with floating point math).

The calculation is as follows:

• Let P bet the number of digits after decimal point that you want to round to (2 in this case).
• Let D be 10^P (100 in this case).
• Multiply input by D
• std::round to nearest integer.
• Divide by D.

P.S. Sometimes you might not want to round to the nearest, but instead want std::floor or std::ceil to the precision. This is slightly trickier. Simply std::floor(val * D) / D is wrong. For example 9.70 floored to two decimals that way would become 9.69, which would be undesirable.

What you can do in this case is multiply with one magnitude of precision, round to nearest, then divide the extra magnitude and proceed:

• Let P bet the number of digits after decimal point that you want to round to (2 in this case).
• Let D be 10^P (100 in this case).
• Multiply input by D * 10
• std::round to nearest integer.
• Divide by 10
• std::floor or std::ceil
• Divide by D.

Answer 3

If you're talking about storing exactly 1.26 in your variable, chances are you can't (there may be an off chance that exactly 1.26 works, but let's assume it doesn't for a moment) because floating point numbers don't work like that. There are always little inaccuracies because of the way computers handle floating point decimal numbers. Even if you could get 1.26 exactly, the moment you try to use it in a calculation.

That said, you can use some math and truncation tricks to get very close:

int main()
{
    // our float
    float a = 1.263839;

    // the precision we're trying to accomplish
    int precision = 100; // 3 decimal places

    // because we're an int, this will keep the 126 but lose everything else    
    int truncated = a * precision; // multiplying by the precision ensures we keep that many digits

    // convert it back to a float
    // Of course, we need to ensure we're doing floating point division
    float b = static_cast<float>(truncated) / precision;

    cout << "a: " << a << "\n";
    cout << "b: " << b << "\n";

    return 0;
}

Output:

a: 1.26384                                                                                                                    
b: 1.26

Note that this is not really 1.26 here. But is is very close.

This can be demonstrated by using setprecision():

cout << "a: " << std:: setprecision(10) << a << "\n";
cout << "b: " << std:: setprecision(10) << b << "\n";

Output:

a: 1.263839006                                                                                                                
b: 1.25999999

So again, it's not exactly 1.26, but very close, and slightly closer than you were before.

Answer 4

If your goal is to store a number with a small, fixed number of digits of precision after the decimal point, you can do that by storing it as an integer with an implicit power-of-ten multiplier:

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

// Given a floating point value and the number of digits
// after the decimal-point that you want to preserve,
// returns an integer encoding of the value.
int ConvertFloatToFixedPrecision(float floatVal, int numDigitsAfterDecimalPoint)
{
   return (int) roundf(floatVal*powf(10.0f, numDigitsAfterDecimalPoint));
}

// Given an integer encoding of your value (as returned
// by the above function), converts it back into a floating
// point value again.
float ConvertFixedPrecisionBackToFloat(int fixedPrecision, int numDigitsAfterDecimalPoint)
{
   return ((float) fixedPrecision) / powf(10.0f, numDigitsAfterDecimalPoint);
}

int main(int argc, char ** arg)
{
   const float val = 1.263839;

   int fixedTwoDigits = ConvertFloatToFixedPrecision(val, 2);
   printf("fixedTwoDigits=%i\n", fixedTwoDigits);

   float backToFloat = ConvertFixedPrecisionBackToFloat(fixedTwoDigits, 2);
   printf("backToFloat=%f\n", backToFloat);

   return 0;
}

When run, the above program prints this output:

fixedTwoDigits=126
backToFloat=1.260000

Answer 5

You would need to truncate it. Possibly the easiest way is to multiply it by a factor (in case of 2 decimal places, by a factor of 100), then truncate or round it, and lastly divide by the very same factor.

Now, mind you, that floating-point precision issues might occur, and that even after those operations your float might not be 1.26, but 1.26000000000003 instead.