float f=0.7; f < 0.7 f<0.7f

[rahulsinner]

hi everyone,

main()
{
float f=0.7;
if ( f< 0.7)
printf("C");
else
printf("C++");
}
main()
{
float f=0.7;
if(f < 0.7f)
printf("C");
else
printf("C++");
}

The first code snippet prints C and the second one prints C++.Can
anyone tell me the reason for it

[Vladimir S. Oka]

ra*********@gmail.com opined:

hi everyone,

main()
{
float f=0.7;
if ( f< 0.7)
printf("C");
else
printf("C++");
}
main()
{
float f=0.7;
if(f < 0.7f)
printf("C");
else
printf("C++");
}

The first code snippet prints C and the second one prints C++.Can
anyone tell me the reason for it

No they don't (or at least not necessarily).

a) you do not include <stdio.h> so `printf` is unknown
b) you do not terminate output with '\n'
c) it's `int main(void)`
d) you're missing `return 0;` (or whatever value)

However, your problem is in the fact that undecorated floating point
constants, like `0.7` are of type `double`, by appending 'f', you make
them `float`. Now, if sizes of your `float`s and `double`s are
different representation of 0.7 in them may differ. Adding:

printf("%20.10f %20.10f\n",0.7, 0.7f);

to your code (after fixing the rest) I get (gcc 4.0.3pre, SUSE 10.0):

0.7000000000 0.6999999881

The morale is: if you're going to use floating point numbers in your
applications, carefully study their limitations, and your particular
implementation. Also look into C Standard to see what are the minumum
requirements for a conforming implementation. This advice applies
equally to any programming language you choose.

HTH

--
if (argc > 1 && strcmp(argv[1], "-advice") == 0) {
printf("Don't Panic!\n");
exit(42);
}
(Arnold Robbins in the LJ of February '95, describing RCS)

<http://clc-wiki.net/wiki/Introduction_to_comp.lang.c>

[Vladimir S. Oka]

Vladimir S. Oka opined:

ra*********@gmail.com opined:

hi everyone,

main()
{
float f=0.7;
if ( f< 0.7)
printf("C");
else
printf("C++");
}
main()
{
float f=0.7;
if(f < 0.7f)
printf("C");
else
printf("C++");
}

The first code snippet prints C and the second one prints C++.Can
anyone tell me the reason for it

No they don't (or at least not necessarily).

a) you do not include <stdio.h> so `printf` is unknown
b) you do not terminate output with '\n'
c) it's `int main(void)`
d) you're missing `return 0;` (or whatever value)

However, your problem is in the fact that undecorated floating point
constants, like `0.7` are of type `double`, by appending 'f', you
make them `float`. Now, if sizes of your `float`s and `double`s are
different representation of 0.7 in them may differ. Adding:

printf("%20.10f %20.10f\n",0.7, 0.7f);

to your code (after fixing the rest) I get (gcc 4.0.3pre, SUSE 10.0):

0.7000000000 0.6999999881

The morale is: if you're going to use floating point numbers in your
applications, carefully study their limitations, and your particular
implementation. Also look into C Standard to see what are the minumum
requirements for a conforming implementation. This advice applies
equally to any programming language you choose.

Oh yes, do not use type `float` it is too small for any serious (and
many less serious) uses. Use `double` instead. And, if I may add, if
you can avoid it, do not use floating point at all.

--
I did this 'cause Linux gives me a woody. It doesn't generate revenue.
(Dave '-ddt->` Taylor, announcing DOOM for Linux)

<http://clc-wiki.net/wiki/Introduction_to_comp.lang.c>

[Nils O. Selåsdal]

Vladimir S. Oka wrote:

Vladimir S. Oka opined:

ra*********@gmail.com opined:

hi everyone,

main()
{
float f=0.7;
if ( f< 0.7)
printf("C");
else
printf("C++");
}
main()
{
float f=0.7;
if(f < 0.7f)
printf("C");
else
printf("C++");
}

The first code snippet prints C and the second one prints C++.Can
anyone tell me the reason for it

No they don't (or at least not necessarily).

a) you do not include <stdio.h> so `printf` is unknown
b) you do not terminate output with '\n'
c) it's `int main(void)`
d) you're missing `return 0;` (or whatever value)

However, your problem is in the fact that undecorated floating point
constants, like `0.7` are of type `double`, by appending 'f', you
make them `float`. Now, if sizes of your `float`s and `double`s are
different representation of 0.7 in them may differ. Adding:

printf("%20.10f %20.10f\n",0.7, 0.7f);

to your code (after fixing the rest) I get (gcc 4.0.3pre, SUSE 10.0):

0.7000000000 0.6999999881

The morale is: if you're going to use floating point numbers in your
applications, carefully study their limitations, and your particular
implementation. Also look into C Standard to see what are the minumum
requirements for a conforming implementation. This advice applies
equally to any programming language you choose.

Oh yes, do not use type `float` it is too small for any serious (and
many less serious) uses. Use `double` instead. And, if I may add, if
you can avoid it, do not use floating point at all.

I recommend both of you read
http://docs.sun.com/source/806-3568/ncg_goldberg.html
--
Nils O. Selåsdal
www.utelsystems.com

[Vladimir S. Oka]

Nils O. Selåsdal wrote:

I recommend both of you read
http://docs.sun.com/source/806-3568/ncg_goldberg.html

Thanks for the link. I will read it. I may even comment on it (time
permitting).

I'd also like to know why did you feel I should read it as well? Is it
because I did not provide the OP with a long, and detailed, discussion
of finer points of using floating point numbers?

--
BR, Vladimir

[rahulsinner]

thanx for the advice.i didn't include <stdio.h> n left certain
formattings because i thought keeping the code to the min. will help
you people get to the problem immediately.

anyways next time onwards i will post codes which purely complies with
the std.

I know that real constants are "double" in c if not followed by a f but
i saw that question in an aptitude test n that baffled me.

anyways thnx for ur help.

[John Bode]

ra*********@gmail.com wrote:

hi everyone,

main()
{
float f=0.7;
if ( f< 0.7)
printf("C");
else
printf("C++");
}
main()
{
float f=0.7;
if(f < 0.7f)
printf("C");
else
printf("C++");
}

The first code snippet prints C and the second one prints C++.Can
anyone tell me the reason for it

0.7 cannot be represented exactly in a 32-bit float (assuming a
normalized 23-bit mantissa): the closest you can get without going over
is 0.699981632. It takes 29 bits (again, assuming a normalized
manitssa) to represent 0.7 exactly (provided I've done the math right).
So the first test succeeds, because f (0.699981632) is indeed strictly
less than 0.7. The second test fails, because f (0.699981632) is not
strictly less than 0.7f (0.699981632).

[Walter Roberson]

In article <11*********************@j33g2000cwa.googlegroups. com>,
John Bode <jo*******@my-deja.com> wrote:

0.7 cannot be represented exactly in a 32-bit float (assuming a
normalized 23-bit mantissa): the closest you can get without going over
is 0.699981632. It takes 29 bits (again, assuming a normalized
manitssa) to represent 0.7 exactly (provided I've done the math right).

I think you must have done the math wrong.

111 into 1010 goes 1, remainder 11. Quotant so far: 0.1
Shift the remainder, yielding 110
111 into 110 goes 0, remainder 110. Quotant so far: 0.10
Shift the remainder, yielding 1100
111 into 1100 goes 1, remainder 101. Quotant so far: 0.101
Shift the remainder, yielding 1010
This is the same value as we started with, so we have a repeating fraction.

Therefore 0.7 (decimal) is 0.101,101,101... repeated infinitely.
There is no exact and finite base 2 representation of 0.7 (decimal)
--
I was very young in those days, but I was also rather dim.
-- Christopher Priest

[John Bode]

Walter Roberson wrote:

In article <11*********************@j33g2000cwa.googlegroups. com>,
John Bode <jo*******@my-deja.com> wrote:

0.7 cannot be represented exactly in a 32-bit float (assuming a
normalized 23-bit mantissa): the closest you can get without going over
is 0.699981632. It takes 29 bits (again, assuming a normalized
manitssa) to represent 0.7 exactly (provided I've done the math right).

I think you must have done the math wrong.

111 into 1010 goes 1, remainder 11. Quotant so far: 0.1
Shift the remainder, yielding 110
111 into 110 goes 0, remainder 110. Quotant so far: 0.10
Shift the remainder, yielding 1100
111 into 1100 goes 1, remainder 101. Quotant so far: 0.101
Shift the remainder, yielding 1010
This is the same value as we started with, so we have a repeating fraction.

Therefore 0.7 (decimal) is 0.101,101,101... repeated infinitely.
There is no exact and finite base 2 representation of 0.7 (decimal)

Yeah, I mucked it up after 29 terms (serves me right for not
recognizing the pattern). Because my brain is fundamentally damaged,
I chose to do it the hard way and sum powers of 2 until I got close
(which gave me a bit pattern of 0.101001100110011...; the bit pattern
0.101101101... gets me 0.714, btw).

Even so, the point still holds; the value of the float representation
of 0.7 is strictly less than the value of the double representation of
0.7, whereas the value of the float representation of 0.7 is not
strictly less than the value of the float representation of 0.7.

[Vladimir S. Oka]

ra*********@gmail.com opined:

thanx for the advice.i didn't include <stdio.h> n left certain
formattings because i thought keeping the code to the min. will help
you people get to the problem immediately.

anyways next time onwards i will post codes which purely complies
with the std.

I know that real constants are "double" in c if not followed by a f
but i saw that question in an aptitude test n that baffled me.

anyways thnx for ur help.

You're welcome, but please also *do* read the link in my sig. Quoting
context is as important, as providing minimal compilable source
(obviously unless you have a problem that it won't compile in the
first place).

--
We are Pentium of Borg. Division is futile. You will be approximated.
(seen in someone's .signature)

<http://clc-wiki.net/wiki/Introduction_to_comp.lang.c>

[Kufa]

I know it's a bit out of place, but still

c) it's `int main(void)`

it is implementation dependent, int main(void) or int main(int,char**)
are only suggested by the norm.

[Vladimir S. Oka]

Kufa wrote:

I know it's a bit out of place, but still

c) it's `int main(void)`

it is implementation dependent, int main(void) or int main(int,char**)
are only suggested by the norm.

Do not snip attribution lines (the ones saying "Kufa wrote:"). I said
the above.

It is not "only suggested by the norm". The only two forms of `main()`
allowed by the Standard (or, if you want, the only two required to be
supported by all conforming implementations) are:

int main(void)
int main(int argc, char *argv[])

Some prefer the latter as:

int main(int argc, char **argv)

It's a matter of taste, really.

An implementation is allowed to implement, as long as it documents it,
a different sort of `main()`, and that is "implementation dependent".
However, it's not portable.

As this is comp.lang.c (you did find out what its about, didn't you?),
even if DS9K implemented:

double main(float pi)

it would be off-topic, and non-Standard...