How to count from 0.0001 to 1 in ruby?

Question

I want to count from 0.0001 to 1 with 0.0001 steps in ruby. I wrote this code but it enters to an infinite loop. Somewhy the interpreter does a wrong summation.

x = 0.0001
while x != 1.0
  puts x
  x = x + 0.0001
end

Here is the first 10 value it gives:

0.0001
0.0002
0.00030000000000000003
0.0004
0.0005
0.0006000000000000001
0.0007000000000000001
0.0008000000000000001
0.0009000000000000002
0.0010000000000000002

It should be 0.0001, 0.0002, 0.0003, etc... How can I make it working? Thanks!

gioele's answer is clearly better than the one you marked as correct. — steenslag, Dec 16 '11 at 22:21

gioele · Answer 1 · 2011-12-16T14:52:14.050

16

Try this:

0.0001.step(1, 0.0001).each { |i| puts i }

EDIT: you should use the Float#step method because it shields you from the weirdness of float arithmetic. Float#step will take care of incrementing the value and comparing to the limit in a float-proof way. For more information have a look at the official documentation of Float#step.

edited Dec 16 '11 at 14:52

answered Dec 16 '11 at 14:37

gioele

9,748
5
55
80

Thank you! This makes the job:) – Hiddin Dec 16 '11 at 14:58

score 2 · Accepted Answer · answered Dec 16 '11 at 14:38

2

The problem is that real numbers in ruby are not represented exactly due to binary storage and manipulation. I would do this

x = 1
while x < 10000
    puts (x/10000).round(4)
    x += 1
end

answered Dec 16 '11 at 14:38

ghoppe

21,452
3
30
21

Thank you!:) I just started programming. I didn't know that!:) – Hiddin Dec 16 '11 at 14:59
4

Just to clarify, this isn't limited to Ruby, it's a floating point issue. – the Tin Man Dec 16 '11 at 15:02

score 1 · Answer 3 · answered Dec 16 '11 at 14:34

Rather than x != 1.0, put x < 1.0. That will at least be sure your loop ends.

A binary system like those that run all of our modern computers cannot (easily) represent fractions, especially ones that cannot be accurately represented in decimal. That is where the strange number comes in when you should have .0003. It is an artifact of how the numbers are represented internally.

Some languages are better at dealing with numbers and accuracy than others, so if the accuracy of the numbers matters, you either need to use a different language, use a library that handles the number things for you (significant digits and all that), or you need to handle it yourself with appropriate rounding, etc. at each step.

Yes it is working. But what to do if I want an accurate result? And why 0.0005 + 0.0001 equals 0.0006000000000000001 to ruby? — Hiddin, Dec 16 '11 at 14:37
Because of the way floating number works: have a look at http://floating-point-gui.de/ — gioele, Dec 16 '11 at 14:39

score 0 · Answer 4 · answered Dec 16 '11 at 14:39

0

Floating point numbers are not exactly accurate Wikipedia Floating Point article.

If you must have clean x's, I'd recommend using an integer and dividing down by 1000 before you use the value. If you don't care about the little bits of noise off, you'll be fine with changing your while x != 1.0 to while x < 1.0

answered Dec 16 '11 at 14:39

Tom Cerul

1,773
2
13
27

I agree. In general, using integers for operations (if possible) and then converting down at the end will give more accurate results. – cdeszaq Dec 16 '11 at 14:41
Common binary _representations_ of floating point numbers (e.g. IEEE 754) aren't accurate. – Michael Mior Dec 16 '11 at 14:54
Michael, are you saying that the math is reliable but the output is the problem? – Tom Cerul Dec 16 '11 at 14:56

score 0 · Answer 5 · answered Dec 16 '11 at 14:48

0

What you are seeing is due to binary representation of floating-point numbers. This affects all computer programming languages. For more detail see What Every Computer Scientist Should Know about Floating Point Arithmetic.

What you can do is round it to the appropriate number of digits at print time, or as goiele has found, use step:

0.0001.step(1, 0.0001).each do |i|
  puts i
end

answered Dec 16 '11 at 14:48

Mark Thomas

37,131
11
74
101

Thank you! I will read it through! And the code is also working fine:) – Hiddin Dec 16 '11 at 14:58

score 0 · Answer 6 · answered Dec 16 '11 at 15:06

0

1.step(10000, 1).each { |x| puts "%f" % (x / 10000.0).round(4) }

answered Dec 16 '11 at 15:06

Marek Příhoda

11,108
3
39
53

How to count from 0.0001 to 1 in ruby?

6 Answers6