comparing a #define constant with a variable of same value does not equal (C language) [duplicate]





.everyoneloves__top-leaderboard:empty,.everyoneloves__mid-leaderboard:empty,.everyoneloves__bot-mid-leaderboard:empty{ height:90px;width:728px;box-sizing:border-box;
}







1
















This question already has an answer here:




  • strange output in comparison of float with float literal

    8 answers




I am new to C language. Here is my question and code:



I have a constant and a variable with the same value and I try to compare them to check if they are equal. It seems to me that since they are assigned the same value, they should be equal but that is not the case.



#include <stdio.h>
#define mypi1 3.14

int main()
{
int ans;
float mypi2 = 3.14;
if(mypi1==mypi2)
{
ans=1;
}
else
{
ans=0;
}
printf("%i",ans);

return 0;
}


My output is 0. Which indicates they are not equal. What is the reasoning behind this? This is a really simple question but I could not find it anywhere. Please help and thanks in advance.










share|improve this question













marked as duplicate by Swordfish, M.M c
Users with the  c badge can single-handedly close c questions as duplicates and reopen them as needed.

StackExchange.ready(function() {
if (StackExchange.options.isMobile) return;

$('.dupe-hammer-message-hover:not(.hover-bound)').each(function() {
var $hover = $(this).addClass('hover-bound'),
$msg = $hover.siblings('.dupe-hammer-message');

$hover.hover(
function() {
$hover.showInfoMessage('', {
messageElement: $msg.clone().show(),
transient: false,
position: { my: 'bottom left', at: 'top center', offsetTop: -7 },
dismissable: false,
relativeToBody: true
});
},
function() {
StackExchange.helpers.removeMessages();
}
);
});
});
Nov 22 '18 at 0:36


This question has been asked before and already has an answer. If those answers do not fully address your question, please ask a new question.














  • 1





    3.14 is a double, mypi2 is a float.

    – Swordfish
    Nov 22 '18 at 0:34













  • Hint: replace the definition of mypi1 with 3.14f and observe the output of the program

    – Govind Parmar
    Nov 22 '18 at 0:35


















1
















This question already has an answer here:




  • strange output in comparison of float with float literal

    8 answers




I am new to C language. Here is my question and code:



I have a constant and a variable with the same value and I try to compare them to check if they are equal. It seems to me that since they are assigned the same value, they should be equal but that is not the case.



#include <stdio.h>
#define mypi1 3.14

int main()
{
int ans;
float mypi2 = 3.14;
if(mypi1==mypi2)
{
ans=1;
}
else
{
ans=0;
}
printf("%i",ans);

return 0;
}


My output is 0. Which indicates they are not equal. What is the reasoning behind this? This is a really simple question but I could not find it anywhere. Please help and thanks in advance.










share|improve this question













marked as duplicate by Swordfish, M.M c
Users with the  c badge can single-handedly close c questions as duplicates and reopen them as needed.

StackExchange.ready(function() {
if (StackExchange.options.isMobile) return;

$('.dupe-hammer-message-hover:not(.hover-bound)').each(function() {
var $hover = $(this).addClass('hover-bound'),
$msg = $hover.siblings('.dupe-hammer-message');

$hover.hover(
function() {
$hover.showInfoMessage('', {
messageElement: $msg.clone().show(),
transient: false,
position: { my: 'bottom left', at: 'top center', offsetTop: -7 },
dismissable: false,
relativeToBody: true
});
},
function() {
StackExchange.helpers.removeMessages();
}
);
});
});
Nov 22 '18 at 0:36


This question has been asked before and already has an answer. If those answers do not fully address your question, please ask a new question.














  • 1





    3.14 is a double, mypi2 is a float.

    – Swordfish
    Nov 22 '18 at 0:34













  • Hint: replace the definition of mypi1 with 3.14f and observe the output of the program

    – Govind Parmar
    Nov 22 '18 at 0:35














1












1








1









This question already has an answer here:




  • strange output in comparison of float with float literal

    8 answers




I am new to C language. Here is my question and code:



I have a constant and a variable with the same value and I try to compare them to check if they are equal. It seems to me that since they are assigned the same value, they should be equal but that is not the case.



#include <stdio.h>
#define mypi1 3.14

int main()
{
int ans;
float mypi2 = 3.14;
if(mypi1==mypi2)
{
ans=1;
}
else
{
ans=0;
}
printf("%i",ans);

return 0;
}


My output is 0. Which indicates they are not equal. What is the reasoning behind this? This is a really simple question but I could not find it anywhere. Please help and thanks in advance.










share|improve this question















This question already has an answer here:




  • strange output in comparison of float with float literal

    8 answers




I am new to C language. Here is my question and code:



I have a constant and a variable with the same value and I try to compare them to check if they are equal. It seems to me that since they are assigned the same value, they should be equal but that is not the case.



#include <stdio.h>
#define mypi1 3.14

int main()
{
int ans;
float mypi2 = 3.14;
if(mypi1==mypi2)
{
ans=1;
}
else
{
ans=0;
}
printf("%i",ans);

return 0;
}


My output is 0. Which indicates they are not equal. What is the reasoning behind this? This is a really simple question but I could not find it anywhere. Please help and thanks in advance.





This question already has an answer here:




  • strange output in comparison of float with float literal

    8 answers








c






share|improve this question













share|improve this question











share|improve this question




share|improve this question










asked Nov 22 '18 at 0:32









lollalollalollalolla

82




82




marked as duplicate by Swordfish, M.M c
Users with the  c badge can single-handedly close c questions as duplicates and reopen them as needed.

StackExchange.ready(function() {
if (StackExchange.options.isMobile) return;

$('.dupe-hammer-message-hover:not(.hover-bound)').each(function() {
var $hover = $(this).addClass('hover-bound'),
$msg = $hover.siblings('.dupe-hammer-message');

$hover.hover(
function() {
$hover.showInfoMessage('', {
messageElement: $msg.clone().show(),
transient: false,
position: { my: 'bottom left', at: 'top center', offsetTop: -7 },
dismissable: false,
relativeToBody: true
});
},
function() {
StackExchange.helpers.removeMessages();
}
);
});
});
Nov 22 '18 at 0:36


This question has been asked before and already has an answer. If those answers do not fully address your question, please ask a new question.









marked as duplicate by Swordfish, M.M c
Users with the  c badge can single-handedly close c questions as duplicates and reopen them as needed.

StackExchange.ready(function() {
if (StackExchange.options.isMobile) return;

$('.dupe-hammer-message-hover:not(.hover-bound)').each(function() {
var $hover = $(this).addClass('hover-bound'),
$msg = $hover.siblings('.dupe-hammer-message');

$hover.hover(
function() {
$hover.showInfoMessage('', {
messageElement: $msg.clone().show(),
transient: false,
position: { my: 'bottom left', at: 'top center', offsetTop: -7 },
dismissable: false,
relativeToBody: true
});
},
function() {
StackExchange.helpers.removeMessages();
}
);
});
});
Nov 22 '18 at 0:36


This question has been asked before and already has an answer. If those answers do not fully address your question, please ask a new question.










  • 1





    3.14 is a double, mypi2 is a float.

    – Swordfish
    Nov 22 '18 at 0:34













  • Hint: replace the definition of mypi1 with 3.14f and observe the output of the program

    – Govind Parmar
    Nov 22 '18 at 0:35














  • 1





    3.14 is a double, mypi2 is a float.

    – Swordfish
    Nov 22 '18 at 0:34













  • Hint: replace the definition of mypi1 with 3.14f and observe the output of the program

    – Govind Parmar
    Nov 22 '18 at 0:35








1




1





3.14 is a double, mypi2 is a float.

– Swordfish
Nov 22 '18 at 0:34







3.14 is a double, mypi2 is a float.

– Swordfish
Nov 22 '18 at 0:34















Hint: replace the definition of mypi1 with 3.14f and observe the output of the program

– Govind Parmar
Nov 22 '18 at 0:35





Hint: replace the definition of mypi1 with 3.14f and observe the output of the program

– Govind Parmar
Nov 22 '18 at 0:35












1 Answer
1






active

oldest

votes


















1














#define mypi1 3.14
float mypi2 = 3.14;


The first of those is a double type, the second is a double coerced into a float.



The expression mypi1==mypi2 will first convert the float back to a double before comparing (the idea is that, if one type is of lesser range/precision than the other, it's converted so that both types are identical).



Hence, if the if statement is failing, it's likely that you lose information in the double -> float -> double round-trip(a).



To be honest, unless you're using a great many floating point values (and storage space is a concern), you should probably just use double everywhere. If you do need float types, use that for both values:



#define mypi1 3.14f
float mypi2 = 3.14f;


Comparing two float variables will not involve any conversions.





(a) See, for example, the following complete program:



#include <stdio.h>
#define x 3.14
int main(void) {
float y = 3.14; // double -> float
double z = y; // -> double
printf("%.50fn", x);
printf("%.50fn", z);
}


In this, x is a double and z is a double that's gone through the round-trip conversion discussed above. The output shows the difference that can happen:



3.14000000000000012434497875801753252744674682617188
3.14000010490417480468750000000000000000000000000000





share|improve this answer


























  • This is very clear, thanks. However, I tried changing the value to 10.5 and the output return is 1 which indicates they are identical. Could you please explain this?

    – lollalolla
    Nov 22 '18 at 1:06











  • @lollalolla: See Is floating point math broken?. Succinctly, there's an exact binary representation of 10.5 that both float and double can store; there isn't an exact binary representation of 3.14 (period), and float and double can only store different approximations to it (because they have different numbers of bits to store the value), and when the float is converted to double, what it stored isn't the same as what the double stored from the start.

    – Jonathan Leffler
    Nov 22 '18 at 2:44











  • @lollalolla, Jonathan is correct. Basically, numbers that can be built from constituents that are powers of two within the bit precision of the type (such as 2^3 + 2^1 + 2^-1 = 8 + 2 + 0.5 = 10.5) can be represented exactly. For 3.14, you can get 3 from 2 + 1 but the 0.14 bit is problematic.

    – paxdiablo
    Nov 22 '18 at 6:24













  • Thanks all. Now it makes perfect sense to me!

    – lollalolla
    Nov 22 '18 at 12:45


















1 Answer
1






active

oldest

votes








1 Answer
1






active

oldest

votes









active

oldest

votes






active

oldest

votes









1














#define mypi1 3.14
float mypi2 = 3.14;


The first of those is a double type, the second is a double coerced into a float.



The expression mypi1==mypi2 will first convert the float back to a double before comparing (the idea is that, if one type is of lesser range/precision than the other, it's converted so that both types are identical).



Hence, if the if statement is failing, it's likely that you lose information in the double -> float -> double round-trip(a).



To be honest, unless you're using a great many floating point values (and storage space is a concern), you should probably just use double everywhere. If you do need float types, use that for both values:



#define mypi1 3.14f
float mypi2 = 3.14f;


Comparing two float variables will not involve any conversions.





(a) See, for example, the following complete program:



#include <stdio.h>
#define x 3.14
int main(void) {
float y = 3.14; // double -> float
double z = y; // -> double
printf("%.50fn", x);
printf("%.50fn", z);
}


In this, x is a double and z is a double that's gone through the round-trip conversion discussed above. The output shows the difference that can happen:



3.14000000000000012434497875801753252744674682617188
3.14000010490417480468750000000000000000000000000000





share|improve this answer


























  • This is very clear, thanks. However, I tried changing the value to 10.5 and the output return is 1 which indicates they are identical. Could you please explain this?

    – lollalolla
    Nov 22 '18 at 1:06











  • @lollalolla: See Is floating point math broken?. Succinctly, there's an exact binary representation of 10.5 that both float and double can store; there isn't an exact binary representation of 3.14 (period), and float and double can only store different approximations to it (because they have different numbers of bits to store the value), and when the float is converted to double, what it stored isn't the same as what the double stored from the start.

    – Jonathan Leffler
    Nov 22 '18 at 2:44











  • @lollalolla, Jonathan is correct. Basically, numbers that can be built from constituents that are powers of two within the bit precision of the type (such as 2^3 + 2^1 + 2^-1 = 8 + 2 + 0.5 = 10.5) can be represented exactly. For 3.14, you can get 3 from 2 + 1 but the 0.14 bit is problematic.

    – paxdiablo
    Nov 22 '18 at 6:24













  • Thanks all. Now it makes perfect sense to me!

    – lollalolla
    Nov 22 '18 at 12:45
















1














#define mypi1 3.14
float mypi2 = 3.14;


The first of those is a double type, the second is a double coerced into a float.



The expression mypi1==mypi2 will first convert the float back to a double before comparing (the idea is that, if one type is of lesser range/precision than the other, it's converted so that both types are identical).



Hence, if the if statement is failing, it's likely that you lose information in the double -> float -> double round-trip(a).



To be honest, unless you're using a great many floating point values (and storage space is a concern), you should probably just use double everywhere. If you do need float types, use that for both values:



#define mypi1 3.14f
float mypi2 = 3.14f;


Comparing two float variables will not involve any conversions.





(a) See, for example, the following complete program:



#include <stdio.h>
#define x 3.14
int main(void) {
float y = 3.14; // double -> float
double z = y; // -> double
printf("%.50fn", x);
printf("%.50fn", z);
}


In this, x is a double and z is a double that's gone through the round-trip conversion discussed above. The output shows the difference that can happen:



3.14000000000000012434497875801753252744674682617188
3.14000010490417480468750000000000000000000000000000





share|improve this answer


























  • This is very clear, thanks. However, I tried changing the value to 10.5 and the output return is 1 which indicates they are identical. Could you please explain this?

    – lollalolla
    Nov 22 '18 at 1:06











  • @lollalolla: See Is floating point math broken?. Succinctly, there's an exact binary representation of 10.5 that both float and double can store; there isn't an exact binary representation of 3.14 (period), and float and double can only store different approximations to it (because they have different numbers of bits to store the value), and when the float is converted to double, what it stored isn't the same as what the double stored from the start.

    – Jonathan Leffler
    Nov 22 '18 at 2:44











  • @lollalolla, Jonathan is correct. Basically, numbers that can be built from constituents that are powers of two within the bit precision of the type (such as 2^3 + 2^1 + 2^-1 = 8 + 2 + 0.5 = 10.5) can be represented exactly. For 3.14, you can get 3 from 2 + 1 but the 0.14 bit is problematic.

    – paxdiablo
    Nov 22 '18 at 6:24













  • Thanks all. Now it makes perfect sense to me!

    – lollalolla
    Nov 22 '18 at 12:45














1












1








1







#define mypi1 3.14
float mypi2 = 3.14;


The first of those is a double type, the second is a double coerced into a float.



The expression mypi1==mypi2 will first convert the float back to a double before comparing (the idea is that, if one type is of lesser range/precision than the other, it's converted so that both types are identical).



Hence, if the if statement is failing, it's likely that you lose information in the double -> float -> double round-trip(a).



To be honest, unless you're using a great many floating point values (and storage space is a concern), you should probably just use double everywhere. If you do need float types, use that for both values:



#define mypi1 3.14f
float mypi2 = 3.14f;


Comparing two float variables will not involve any conversions.





(a) See, for example, the following complete program:



#include <stdio.h>
#define x 3.14
int main(void) {
float y = 3.14; // double -> float
double z = y; // -> double
printf("%.50fn", x);
printf("%.50fn", z);
}


In this, x is a double and z is a double that's gone through the round-trip conversion discussed above. The output shows the difference that can happen:



3.14000000000000012434497875801753252744674682617188
3.14000010490417480468750000000000000000000000000000





share|improve this answer















#define mypi1 3.14
float mypi2 = 3.14;


The first of those is a double type, the second is a double coerced into a float.



The expression mypi1==mypi2 will first convert the float back to a double before comparing (the idea is that, if one type is of lesser range/precision than the other, it's converted so that both types are identical).



Hence, if the if statement is failing, it's likely that you lose information in the double -> float -> double round-trip(a).



To be honest, unless you're using a great many floating point values (and storage space is a concern), you should probably just use double everywhere. If you do need float types, use that for both values:



#define mypi1 3.14f
float mypi2 = 3.14f;


Comparing two float variables will not involve any conversions.





(a) See, for example, the following complete program:



#include <stdio.h>
#define x 3.14
int main(void) {
float y = 3.14; // double -> float
double z = y; // -> double
printf("%.50fn", x);
printf("%.50fn", z);
}


In this, x is a double and z is a double that's gone through the round-trip conversion discussed above. The output shows the difference that can happen:



3.14000000000000012434497875801753252744674682617188
3.14000010490417480468750000000000000000000000000000






share|improve this answer














share|improve this answer



share|improve this answer








edited Nov 22 '18 at 0:43

























answered Nov 22 '18 at 0:36









paxdiablopaxdiablo

643k17712681689




643k17712681689













  • This is very clear, thanks. However, I tried changing the value to 10.5 and the output return is 1 which indicates they are identical. Could you please explain this?

    – lollalolla
    Nov 22 '18 at 1:06











  • @lollalolla: See Is floating point math broken?. Succinctly, there's an exact binary representation of 10.5 that both float and double can store; there isn't an exact binary representation of 3.14 (period), and float and double can only store different approximations to it (because they have different numbers of bits to store the value), and when the float is converted to double, what it stored isn't the same as what the double stored from the start.

    – Jonathan Leffler
    Nov 22 '18 at 2:44











  • @lollalolla, Jonathan is correct. Basically, numbers that can be built from constituents that are powers of two within the bit precision of the type (such as 2^3 + 2^1 + 2^-1 = 8 + 2 + 0.5 = 10.5) can be represented exactly. For 3.14, you can get 3 from 2 + 1 but the 0.14 bit is problematic.

    – paxdiablo
    Nov 22 '18 at 6:24













  • Thanks all. Now it makes perfect sense to me!

    – lollalolla
    Nov 22 '18 at 12:45



















  • This is very clear, thanks. However, I tried changing the value to 10.5 and the output return is 1 which indicates they are identical. Could you please explain this?

    – lollalolla
    Nov 22 '18 at 1:06











  • @lollalolla: See Is floating point math broken?. Succinctly, there's an exact binary representation of 10.5 that both float and double can store; there isn't an exact binary representation of 3.14 (period), and float and double can only store different approximations to it (because they have different numbers of bits to store the value), and when the float is converted to double, what it stored isn't the same as what the double stored from the start.

    – Jonathan Leffler
    Nov 22 '18 at 2:44











  • @lollalolla, Jonathan is correct. Basically, numbers that can be built from constituents that are powers of two within the bit precision of the type (such as 2^3 + 2^1 + 2^-1 = 8 + 2 + 0.5 = 10.5) can be represented exactly. For 3.14, you can get 3 from 2 + 1 but the 0.14 bit is problematic.

    – paxdiablo
    Nov 22 '18 at 6:24













  • Thanks all. Now it makes perfect sense to me!

    – lollalolla
    Nov 22 '18 at 12:45

















This is very clear, thanks. However, I tried changing the value to 10.5 and the output return is 1 which indicates they are identical. Could you please explain this?

– lollalolla
Nov 22 '18 at 1:06





This is very clear, thanks. However, I tried changing the value to 10.5 and the output return is 1 which indicates they are identical. Could you please explain this?

– lollalolla
Nov 22 '18 at 1:06













@lollalolla: See Is floating point math broken?. Succinctly, there's an exact binary representation of 10.5 that both float and double can store; there isn't an exact binary representation of 3.14 (period), and float and double can only store different approximations to it (because they have different numbers of bits to store the value), and when the float is converted to double, what it stored isn't the same as what the double stored from the start.

– Jonathan Leffler
Nov 22 '18 at 2:44





@lollalolla: See Is floating point math broken?. Succinctly, there's an exact binary representation of 10.5 that both float and double can store; there isn't an exact binary representation of 3.14 (period), and float and double can only store different approximations to it (because they have different numbers of bits to store the value), and when the float is converted to double, what it stored isn't the same as what the double stored from the start.

– Jonathan Leffler
Nov 22 '18 at 2:44













@lollalolla, Jonathan is correct. Basically, numbers that can be built from constituents that are powers of two within the bit precision of the type (such as 2^3 + 2^1 + 2^-1 = 8 + 2 + 0.5 = 10.5) can be represented exactly. For 3.14, you can get 3 from 2 + 1 but the 0.14 bit is problematic.

– paxdiablo
Nov 22 '18 at 6:24







@lollalolla, Jonathan is correct. Basically, numbers that can be built from constituents that are powers of two within the bit precision of the type (such as 2^3 + 2^1 + 2^-1 = 8 + 2 + 0.5 = 10.5) can be represented exactly. For 3.14, you can get 3 from 2 + 1 but the 0.14 bit is problematic.

– paxdiablo
Nov 22 '18 at 6:24















Thanks all. Now it makes perfect sense to me!

– lollalolla
Nov 22 '18 at 12:45





Thanks all. Now it makes perfect sense to me!

– lollalolla
Nov 22 '18 at 12:45





Popular posts from this blog

鏡平學校

ꓛꓣだゔៀៅຸ໢ທຮ໕໒ ,ໂ'໥໓າ໼ឨឲ៵៭ៈゎゔit''䖳𥁄卿' ☨₤₨こゎもょの;ꜹꟚꞖꞵꟅꞛေၦေɯ,ɨɡ𛃵𛁹ޝ޳ޠ޾,ޤޒޯ޾𫝒𫠁သ𛅤チョ'サノބޘދ𛁐ᶿᶇᶀᶋᶠ㨑㽹⻮ꧬ꧹؍۩وَؠ㇕㇃㇪ ㇦㇋㇋ṜẰᵡᴠ 軌ᵕ搜۳ٰޗޮ޷ސޯ𫖾𫅀ल, ꙭ꙰ꚅꙁꚊꞻꝔ꟠Ꝭㄤﺟޱސꧨꧼ꧴ꧯꧽ꧲ꧯ'⽹⽭⾁⿞⼳⽋២៩ញណើꩯꩤ꩸ꩮᶻᶺᶧᶂ𫳲𫪭𬸄𫵰𬖩𬫣𬊉ၲ𛅬㕦䬺𫝌𫝼,,𫟖𫞽ហៅ஫㆔ాఆఅꙒꚞꙍ,Ꙟ꙱エ ,ポテ,フࢰࢯ𫟠𫞶 𫝤𫟠ﺕﹱﻜﻣ𪵕𪭸𪻆𪾩𫔷ġ,ŧآꞪ꟥,ꞔꝻ♚☹⛵𛀌ꬷꭞȄƁƪƬșƦǙǗdžƝǯǧⱦⱰꓕꓢႋ神 ဴ၀க௭எ௫ឫោ ' េㇷㇴㇼ神ㇸㇲㇽㇴㇼㇻㇸ'ㇸㇿㇸㇹㇰㆣꓚꓤ₡₧ ㄨㄟ㄂ㄖㄎ໗ツڒذ₶।ऩछएोञयूटक़कयँृी,冬'𛅢𛅥ㇱㇵㇶ𥄥𦒽𠣧𠊓𧢖𥞘𩔋цѰㄠſtʯʭɿʆʗʍʩɷɛ,əʏダヵㄐㄘR{gỚṖḺờṠṫảḙḭᴮᵏᴘᵀᵷᵕᴜᴏᵾq﮲ﲿﴽﭙ軌ﰬﶚﶧ﫲Ҝжюїкӈㇴffצּ﬘﭅﬈軌'ffistfflſtffतभफɳɰʊɲʎ𛁱𛁖𛁮𛀉 𛂯𛀞నఋŀŲ 𫟲𫠖𫞺ຆຆ ໹້໕໗ๆทԊꧢꧠ꧰ꓱ⿝⼑ŎḬẃẖỐẅ ,ờỰỈỗﮊDžȩꭏꭎꬻ꭮ꬿꭖꭥꭅ㇭神 ⾈ꓵꓑ⺄㄄ㄪㄙㄅㄇstA۵䞽ॶ𫞑𫝄㇉㇇゜軌𩜛𩳠Jﻺ‚Üမ႕ႌႊၐၸဓၞၞၡ៸wyvtᶎᶪᶹစဎ꣡꣰꣢꣤ٗ؋لㇳㇾㇻㇱ㆐㆔,,㆟Ⱶヤマފ޼ޝަݿݞݠݷݐ',ݘ,ݪݙݵ𬝉𬜁𫝨𫞘くせぉて¼óû×ó£…𛅑הㄙくԗԀ5606神45,神796'𪤻𫞧ꓐ㄁ㄘɥɺꓵꓲ3''7034׉ⱦⱠˆ“𫝋ȍ,ꩲ軌꩷ꩶꩧꩫఞ۔فڱێظペサ神ナᴦᵑ47 9238їﻂ䐊䔉㠸﬎ffiﬣ,לּᴷᴦᵛᵽ,ᴨᵤ ᵸᵥᴗᵈꚏꚉꚟ⻆rtǟƴ𬎎

Why https connections are so slow when debugging (stepping over) in Java?