What am I missing?

[coldmeat]

Interesting to know. Mathematically 1.1 does equal 1.100000. Never would have thought a computer wouldn't be able to figure that out.

Well it was to 6 decimal places, none of which were 0

 

[Tweak155]

Well it was to 6 decimal places, none of which were 0

Check my edit. They were 0 on mine for the record.

 

[disappoint]

float x = 0.1;
while (x != 1.1) {
printf("x = %f\n", x);
x = x + 0.1;
}

​

On some systems, this loop will execute ten times as expected, but on other systems it will never terminate. The problem is that the loop terminating condition (x != 1.1) tests for exact equality of two floating point values, and the way floating point values are represented in many computers will make this test fail, because they cannot represent the value 1.1 exactly.
Because of the likelihood of tests for equality or not-equality failing unexpectedly, it is safer to use greater-than or less-than tests when dealing with floating-point values. For example, instead of testing whether x equals 1.1, one might test whether (x <= 1.0), or (x < 1.1), either of which would be certain to exit after a finite number of iterations. Another way to fix this particular example would be to use an integer as a loop index, counting the number of iterations that have been performed.


from: http://en.wikipedia.org/wiki/Infinite_loop

 

[Tweak155]

float x = 0.1;
while (x != 1.1) {
printf("x = %f\n", x);
x = x + 0.1;
}

​

On some systems, this loop will execute ten times as expected, but on other systems it will never terminate. The problem is that the loop terminating condition (x != 1.1) tests for exact equality of two floating point values, and the way floating point values are represented in many computers will make this test fail, because they cannot represent the value 1.1 exactly.
Because of the likelihood of tests for equality or not-equality failing unexpectedly, it is safer to use greater-than or less-than tests when dealing with floating-point values. For example, instead of testing whether x equals 1.1, one might test whether (x <= 1.0), or (x < 1.1), either of which would be certain to exit after a finite number of iterations. Another way to fix this particular example would be to use an integer as a loop index, counting the number of iterations that have been performed.


from: http://en.wikipedia.org/wiki/Infinite_loop

This seems like a good answer, but even when I type-cast onto the 1.1 it doesn't recognize it. I suppose I can't type cast it either. It is very odd.

 

[coldmeat]

float x = 0.1;
while (x != 1.1) {
printf("x = %f\n", x);
x = x + 0.1;
}

​

On some systems, this loop will execute ten times as expected, but on other systems it will never terminate. The problem is that the loop terminating condition (x != 1.1) tests for exact equality of two floating point values, and the way floating point values are represented in many computers will make this test fail, because they cannot represent the value 1.1 exactly.
Because of the likelihood of tests for equality or not-equality failing unexpectedly, it is safer to use greater-than or less-than tests when dealing with floating-point values. For example, instead of testing whether x equals 1.1, one might test whether (x <= 1.0), or (x < 1.1), either of which would be certain to exit after a finite number of iterations. Another way to fix this particular example would be to use an integer as a loop index, counting the number of iterations that have been performed.


from: http://en.wikipedia.org/wiki/Infinite_loop

Oh, makes sense I suppose. Why do I get weird numbers though after it runs for a little while? I'll start getting numbers like 258.704316

 

[disappoint]

Oh, makes sense I suppose. Why do I get weird numbers though after it runs for a little while? I'll start getting numbers like 258.704316

My guess is if you let it run for too long, the imprecision adds up.

The computer cannot represent the number 1.1 in floating point form exactly any more than you can write down pi or 1/3 in decimal form exactly. You can only approximate it.

 

[torpid]

Oh, makes sense I suppose. Why do I get weird numbers though after it runs for a little while? I'll start getting numbers like 258.704316

One of the links he posted explains the exact scenario from the problem pretty well.

http://en.wikipedia.org/wiki/Floating_point#Accuracy_problems

 

[gophins72]

it's also written about here:
http://www.codeguru.com/forum/printthread.php?t=323835

so in summary, seems a data type issue

 

[Numenorean]

Yup that second one has an extra ;

That kind of crap is annoying.

 

[gophins72]

definitely annoying, but I can see how these classes are good at teaching how to debug.

One of my previous jobs i was tasked to teach a bunch of new hires how to debug. I was completely lost at how to go about this.

 

[CPA]

float x = 0.1;
while (x != 1.1) {
printf("x = %f\n", x);
x = x + 0.1;
}

​

On some systems, this loop will execute ten times as expected, but on other systems it will never terminate. The problem is that the loop terminating condition (x != 1.1) tests for exact equality of two floating point values, and the way floating point values are represented in many computers will make this test fail, because they cannot represent the value 1.1 exactly.
Because of the likelihood of tests for equality or not-equality failing unexpectedly, it is safer to use greater-than or less-than tests when dealing with floating-point values. For example, instead of testing whether x equals 1.1, one might test whether (x <= 1.0), or (x < 1.1), either of which would be certain to exit after a finite number of iterations. Another way to fix this particular example would be to use an integer as a loop index, counting the number of iterations that have been performed.


from: http://en.wikipedia.org/wiki/Infinite_loop

woohoo, I think I was right!

😛

 

[coldmeat]

Those questions weren't on the final anyway.