1. ## round .5

Hi,

I'm trying to find a prebuit cpp function (or C) which manipulates output:
for the input of
Code:
```double a = 1.55555555
b= (manipulated a)
cout << b;```
i would like the output to be
1.56
in other words, I want set prescision to .2 (with sprintf,or setpressicioon, or whatever)
make sure that .5 is rounded upwards
Is there a buildin function for this in STD of MATH or is this somthing i must write?

Thanks

2. ## excel FIXED

I just noticed that this is exactly what MS excel does with the FIXED function....
How can I emulate this

3. So do you actually want the value in the variable to change or do you simply want to display the already existing value to the specifications you've given (without actually changing the value stored in the variable)?

This will simply display the value in the variable as you've requested without really changing it:
Code:
```#include <iomanip>

...

cout << fixed << setprecision(2) << b;```

4. Code:
```double round( double v, int p = 0 )
{
static const double
t = 10,
h = 0.5;
double
s = pow( t, p );
v *= s;
double
w = floor( v ),
f = v - w;
if( f >= h )
++w;
v = w / s;
return v;
}```
Example:
round( 555.555, 2 ) == 555.56
round( 555.554, 2 ) == 555.55
round( 555.554 ) == 556
round( 555.555, -2 ) == 600
round( 545.555, -2 ) == 500

5. You may also be interested in: Most Efficient Way to Check a Variable Is A Whole Number

@Sebastiani: Very nice code! Just two notes:
Code:
```\$ cat round.cpp
#include <iostream>
#include <cmath>

using std::pow;
using std::floor;

double my_round( double v, int p = 0 )
{
static const double
t = 10,
h = 0.5;
double
s = pow( t, p );
v *= s;
double
w = floor( v ),
f = v - w;
if( f >= h )
++w;
v = w / s;
return v;
}

int main() {
std::cout << my_round(-1.5) << std::endl;
return 0;
}
\$ ./round
-1
\$```
The first is that you always round upwards, whereas I think -1.5 should be rounded downwards, should it not? Also, there's a standard function called "round" so unless you use a different name, you'll probably get compiler errors (unless you don't #include <cmath>, which is difficult since the code uses pow and floor).

Oh, and I'd have used more descriptive variable names . . . .

6. Multiply by 100.0, round to nearest integer, divide by 100.0

7. Yeah, that's probably the way I would do it (if I actually needed the rounded value for other calculations, that is). Details of "round to nearest integer" are in that thread I linked to.

For completeness (since the OP mentioned sprintf()), here's how you would do it with printf() (sprintf() is a simple modification from here):
Code:
`printf("%.2f\n", 3.14159);  /* prints 3.14 */`

8. Originally Posted by brewbuck
Multiply by 100.0, round to nearest integer, divide by 100.0
That would just add 2 steps to what is needed to round anyway

9. Ah, but rounding to the nearest integer is very easy to do. Here's an example of mine from that thread that I posted which I wish everyone would read (): Most Efficient Way to Check a Variable Is A Whole Number

Basically: modf is one easy way to do it.

10. Originally Posted by ಠ_ಠ
That would just add 2 steps to what is needed to round anyway
And your more efficient proposed method for rounding to the N'th decimal place looks like what?

11. >> The first is that you always round upwards, whereas I think -1.5 should be rounded downwards, should it not?

Apparently, the answer to that is "it depends" (I believe mine would be the "round half up asymmetric" algorithm, as used in Java). The choice seems a bit arbitrary, though, since 0.5 is exactly in the middle (and so either way could be considered a correct approach), although the way you suggested is probably more consistent.

>> Also, there's a standard function called "round" so unless you use a different name, you'll probably get compiler errors (unless you don't #include <cmath>, which is difficult since the code uses pow and floor).

I'm an idiot. I completely forgot that was a standard function!

>> Oh, and I'd have used more descriptive variable names . . . .

I figured it might be a fairly common homework question so I decided to make it somewhat more obscure (although not obfuscated).

12. >> Multiply by 100.0, round to nearest integer, divide by 100.0

But doesn't that just truncate the value (without rounding)?

EDIT:
Ignore that. I'm having trouble understanding english today.

13. Originally Posted by brewbuck
And your more efficient proposed method for rounding to the N'th decimal place looks like what?
actually, the way you said to do it is the only way I can see to do it

oops

14. Apparently, the answer to that is "it depends" (I believe mine would be the "round half up asymmetric" algorithm, as used in Java). The choice seems a bit arbitrary, though, since 0.5 is exactly in the middle (and so either way could be considered a correct approach), although the way you suggested is probably more consistent.
Yes, indeed. I was just going by the std::round function, which I'm pretty sure has the behaviour I described (round .5 away from zero).

I figured it might be a fairly common homework question so I decided to make it somewhat more obscure (although not obfuscated).
I suppose, though I think that anyone marking code like that (nice indentation, static const variables, default values) would be able to tell from the rest of someone's code whether or not they actually wrote it . . . .

>> Multiply by 100.0, round to nearest integer, divide by 100.0

But doesn't that just truncate the value (without rounding)?
Consider 1.234. Multiply it by 100, and you get 123.4. Round this to the nearest integer; you have 123. Divide this by 100 again, and you get 1.23. I think that works, don't you? (At least in theory).

I'm not sure I really understood your question. [/edit]

15. Originally Posted by dwks

Consider 1.234. Multiply it by 100, and you get 123.4. Round this to the nearest integer; you have 123. Divide this by 100 again, and you get 1.23. I think that works, don't you? (At least in theory).

I'm not sure I really understood your question. [/edit]