floating-accuracy

When executing the following code: public class FPoint { public static void main(String[] args) { float f = 0.1f; for(int i = 0; i<9; i++) { f += 0.1f; } System.out.println(f); } } The following output is displayed: 1.0000001 But output should be 1.0000000 , right? Correct me if I'm wrong..!! 0.1 is not really "0.1" with IEEE 754 Standard. 0.1 is coded : 0 01111011 10011001100110011001101 (with float number) 0 is the sign (= positive) 01111011 the exponent (= 123 -> 123 - 127 = -4 (127 is the bias in IEEE 754)) 10011001100110011001101 the mantissa To convert the mantissa in decimal number we

This question already has an answer here: Is floating point math broken? 31 answers today happened to me a strange thing, when I try to compile and execute the output of this code isn't what I expected. Here is the code that simply add floating values to an array of float and then print it out. The simple code: int main(){ float r[10]; int z; int i=34; for(z=0;z<10;z++){ i=z*z*z; r[z]=i; r[z]=r[z]+0.634; printf("%f\n",r[z]); } } the output: 0.634000 1.634000 8.634000 27.634001 64.634003 125.634003 216.634003 343.634003 512.633972 729.633972 note that from the 27 appears numbers after the .634

After upgrading C++ project to Visual studio 2013, the result of the program has changed because of different floating point behavior of the new VC compiler. The floating model is set to /fp:precise In Visual Studio 2008(v9.0) float f = 0.4f; //it produce f = 0.400000001 float f6 = 0.400000006f; //it produce f = 0.400000001 In Visual Studio 2013 (v12.0) float f = 0.4f; //it produce f = 0.400000006 float f1 = 0.40000001f; //it produce f1 = 0.400000006 The setting for the project is identical (converted). I understand that there is a kind of liberty in floating point model, but I don't like that

Regarding minimising the error in floating-point operations, if I have an operation such as the following in C: float a = 123.456; float b = 456.789; float r = 0.12345; a = a - (r * b); Will the result of the calculation change if I split the multiplication and subtraction steps out, i.e.: float c = r * b; a = a - c; I am wondering whether a CPU would then treat these calculations differently and thereby the error may be smaller in one case? If not, which I presume anyway, are there any good rules-of-thumb to mitigate against floating-point error? Can I massage data in a way that will help?

Everyone knows sqrt function from math.h / cmath in C/C++ - it returns square root of its argument. Of course, it has to do it with some error, because not every number can be stored precisely. But am I guaranteed that the result has some precision? For example, 'it's the best approximation of square root that can be represented in the floating point type used or if you calculate square of the result, it will be as close to initial argument as possible using the floating point type given`? Does C/C++ standard have something about it? For C99, there are no specific requirements. But most

I am trying to figure out how to print floating point numbers without using library functions. Printing the decimal part of a floating point number turned out to be quite easy. Printing the integral part is harder: static const int base = 2; static const char hex[] = "0123456789abcdef"; void print_integral_part(float value) { assert(value >= 0); char a[129]; // worst case is 128 digits for base 2 plus NUL char * p = a + 128; *p = 0; do { int digit = fmod(value, base); value /= base; assert(p > a); *--p = hex[digit]; } while (value >= 1); printf("%s", p); } Printing the integral part of FLT_MAX