Floating Point Rounding

January 8, 2013

This is easy enough:

(define (round f n) (/ (truncate (+ (* f (expt 10 n)) 0.5)) (expt 10 n)))

The expression (expt 10 n) returns 1000 when n is 3, 100 when n is 2, 1 when n is 0, and 1/10 when n is -1. This number is first multiplied by f and then divided into the result, so the output has the same order as the input. In between the multiplication and the division, 0.5 is added, then the result of the addition is truncated, which has the desired rounding effect. There is no need for extra credit here; the function works perfectly well for both positive and negative n.

You can run the program at http://programmingpraxis.codepad.org/AF35jtp1.

11 Responses to “Floating Point Rounding”

javabloggi said
January 8, 2013 at 10:52 AM
My Java solution here.
Robert Fisher said
January 8, 2013 at 7:36 PM
a C solution
fisherro said
January 8, 2013 at 7:53 PM
a Scheme solution
fisherro said
January 8, 2013 at 7:55 PM
I guess I should check the suggested solution to see if it is essentially the same as mine before posting mine. ^_^
Floating Point Rounding | My Blog said
January 9, 2013 at 6:30 AM
[…] Pages: 1 2 […]
Abe C. said
January 9, 2013 at 3:48 PM
> javabloggi said
>January 8, 2013 at 10:52 AM
>
>My Java solution here.

Your solution does not perform rounding correctly. You seem to be checking the digit in one more significant place value than you need to be in order to determine if rounding up is needed.

For example, from your output:
01 Enter numbers:
02 1000/7,3
03 Answer: 142.858

However, the correct answer should be 12.857.

Here’s my java solution:

public class FPR {

public static double round(double f, int n) {
double div = Math.pow(10, (double) n);
if (div*f*10 % 10 >= 5) {
return ((double) ((int) (div*f)) + 1)/div;
} else {
return ((double) ((int) (div*f)))/div;
}
}

public static void main(String[] args) {
for (int i = 3; i >= -2; i–) {
System.out.println(“1000/7,” + i + “: ” + round(1000.0/7.0, i));
}
}
}

Thanks.

Katzby
Abe C. said
January 9, 2013 at 4:18 PM
>However, the correct answer should be 12.857.

Sorry, I meant to say it should be 142.857.

Thanks.

Katzby

Joe A said

January 9, 2013 at 6:34 PM

An overly complicated python version =)

def my_round(f,n):
	'''Round floating point f n places
	>>> my_round(1000/7.0,3)
	142.857
	>>> my_round(1000/7.0,2)
	142.86
	>>> my_round(1000/7.0,1)
	142.9
	'''
	num = int(f * 10**(n+1))
	if num % 10 >= 5:
		num+= 10
	return (num/10) / 10.0**(n)

javabloggi said
January 10, 2013 at 8:10 PM
>However, the correct answer should be 12.857.

>Sorry, I meant to say it should be 142.857.

>Thanks.

>Katzby

Thanks for letting me know. I corrected the mistake.
ardnew said
January 11, 2013 at 4:03 AM
Every answer posted so far handles negative values incorrectly. Also, it doesn’t appear anyone implemented an unbiased tie-breaking scheme?

This solution handles both issues correctly (tie-breaking done with round-to-even) as well as the extra credit.

However, it doesn’t support the technical definition of significant digits.
```
use strict;
use warnings;

sub round
{
  my ($f, $n) = @_;

  my $m = 10 ** -$n;
  my $y = $f / $m;

  if (abs(abs($y) - abs(int($y))) - 0.5 < 1e-6)
  {
    return $m * 
      (int($y) + (int($y) & 1) * (-1 + 2 * ($y > 0)));
  }
  else
  {
    return int(abs($y) + 0.5) * (-$m, $m)[$y > 0];
  }
}
```
ardnew said
January 11, 2013 at 4:12 AM
oops typo on line 11. should be:
```
  if (abs(abs($y) - abs(int($y)) - 0.5) < 1e-6)
```

S	M	T	W	T	F	S
« Dec				Feb »
		1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	30	31

Programming Praxis