This month’s Exercise required you to create three rounding functions: *roundup()*, *rounddown()*, and *roundhalf()*. Each one deals with a floating-point value in a specific way, but they all handle the basic rounding chore by typecasting a floating point variable to an integer.

Click here to view my solution. Your solution can be subtly different, as long as it yields the same results.

Here’s sample output:

```
Value v1 = 1234.567871
Value v2 = 98765.429688
Rounded up: 1235.000000 98766.000000
Rounded down: 1234.000000 98765.000000
Rounded half: 1235.000000 98765.000000
```

For my approach with the *roundup()* function, I typecast the function’s variable `n`

as an integer at Line 7. That value is increased by one (to round “up”), and returned as a *float* in Line 8:

```
r = (int)n;
return( (float)(r+1) );
```

I could have split that process up into several lines, or I could have scrunched it all up into one. However it’s done, the result is the same.

In the *rounddown()* function, the integer typecast for variable `n`

is simply returned:

```
r = (int)n;
return( (float)r );
```

Another way to do this, which is obfuscated but it works, is this:

` return( (float)((int)n) );`

The first typecast, `(int)n`

, must be enclosed in parentheses or the compiler gets all testy.

Finally, for the *roundhalf()* function, I inserted the typecasting technique for rounding down in Lines 24 and 25:

```
r = (int)n;
t = (float)r;
```

The purpose here is to get the round-down value of variable `n`

into variable `t`

. An alternative would have been to use the *rounddown()* function directly:

` t = rounddown(n);`

Once you have that lower value in variable `t`

, a simple comparison with 0.5 determines whether to round up or round down, and return the appropriate value:

```
if( n - t < 0.5)
return(t);
else
return(t+1);
```

In my rendition of the *roundhalf()* function, any value 0.5 or greater is always rounded up. You could modify the code to specifically deal with the exact value 0.5, determining when and how it gets rounded. I'll leave that chore up to you to experiment with on your own.