Difference in floating point arithmetics between x86 and x64
The issue hinges on this expression:
bool bLarger2 = (a*c)<b;
I looked at the code generated under VS2008, not having VS2010 to hand. For 64 bit the code is:
000000013FD51100 movss xmm1,dword ptr [a] 000000013FD51106 mulss xmm1,dword ptr [c] 000000013FD5110C movss xmm0,dword ptr [b] 000000013FD51112 comiss xmm0,xmm1
For 32 bit the code is:
00FC14DC fld dword ptr [a] 00FC14DF fmul dword ptr [c] 00FC14E2 fld dword ptr [b] 00FC14E5 fcompp
So under 32 bit the calculation is performed in the x87 unit, and under 64 bit it is performed by the x64 unit.
And the difference here is that the x87 operations are all performed to higher than single precision. By default the calculations are performed to double precision. On the other hand the SSE unit operations are pure single precision calculations.
You can persuade the 32 bit unit to perform all calculations to single precision accuracy like this:
_controlfp(_PC_24, _MCW_PC);
When you add that to your 32 bit program you will find that the booleans are both set to false.
There is a fundamental difference in the way that the x87 and SSE floating point units work. The x87 unit uses the same instructions for both single and double precision types. Data is loaded into registers in the x87 FPU stack, and those registers are always 10 byte Intel extended. You can control the precision using the floating point control word. But the instructions that the compiler writes are ignorant of that state.
On the other hand, the SSE unit uses different instructions for operations on single and double precision. Which means that the compiler can emit code that is in full control of the precision of the calculation.
So, the x87 unit is the bad guy here. You can maybe try to persuade your compiler to emit SSE instructions even for 32 bit targets. And certainly when I compiled your code under VS2013 I found that both 32 and 64 bit targets emitted SSE instructions.