Bitwise server calculation

CrashRoX

Heres a head spin for you...

$x = (4653896912 >> 13);
echo $x;

I ran that on two different servers.

Server A gave me: 43814
Server B gave me: 568102

Any clue why that would happen? Maybe a work around or another way of doing that calculation? Thanks in advance.

bpat1434

Couldn't tell you... but for reference, I got 43814....

CrashRoX

I actually just found out that server B is 64bit. How can I account for that?

laserlight

a >> b = a * 2b, where denotes exponentiation.
As such, the correct answer is 568102

Reading the PHP Manual on the integer type, one finds that: "If you specify a number beyond the bounds of the integer type, it will be interpreted as a float instead. Also, if you perform an operation that results in a number beyond the bounds of the integer type, a float will be returned instead."

Now, the bitwise operators operate on integers. On server A, the largest integer possible is probably 231-1, while on server B it could be 263-1
Since 4653896912 cannot fit into an integer type on server A, it is treated as floating point. Now, when you try to use bitwise operator>> on it, the conversion causes loss of precision, leading to an unexpected result. This does not happen on server B, hence server B's calculation gives the correct answer.

Maybe a work around or another way of doing that calculation?

That's easy enough:

$x = 4653896912 / pow(2, 13);
echo $x;

You can cast $x to an integer if necessary.

CrashRoX

I appreciate your suggestion. Even though the results on the 32-bit system are incorrect that is the answer I needed. Someone on another forum recommended:

$x = 4653896912;
$y = $x & 0xFFFFFFFF;
$z = $y >> 13;
echo $z;

So far that seems to be working.

dream_scape

no the results are not incorrect. They are within the mathematical limits of what a 32 bit system is capable of. They truly are not the desired results, but they are not incorrect for the system. PHP 5 handles this a tiny bit better by returning -1 for any cast integer too large for the system. And arguable the bitwise operators should be able to operate on floats, but such is not the case currently.

CrashRoX

Although incorrect the system was built with the assumption of the 32bit result. So that bit of code has really helped in getting the same result as a 32bit system would return regardless if it is 64 or 32. Im trying to come up with a similar "workaround" for xor; something like $b ⁼ $c ... Any suggestions?

dream_scape

Crash, FYI, your code snippet does no work under PHP 5. In PHP 5, any number that overflows the integer limit is turned to -1 when cast to an integer. So with your method, you will always get a final result of -1 under PHP 5 on a 32 bit system when $x overflows the integer limit.

Maybe this will hep explain why:

/**
 * 4653896912 overflows the
 * 32bit integer limit, so
 * $x is now a float
 */
$x = 4653896912;


/**
 * $x, a float, is converted
 * to an integer for the
 * bitwise operation.
 * But, as an integer, $x
 * overflows a 32bit system, so
 * -1 is returned.
 * The result is then -1, since
 * -1 & 0xFFFFFFFF = -1
 */
$y = $x & 0xFFFFFFFF;


/**
 * $y here is -1.
 * And -1 shifted any amount to
 * the right is -1, so the answer
 * is -1
 */
$z = $y >> 13;

/**
 * echos -1
 */
echo $z;

laserlight's suggestion will work fine on PHP 5 though.

You could do a XOR the same way by using its mathematical formula, which I don't know off the top of my head, but I'm sure can be found online.

laserlight

no the results are not incorrect. They are within the mathematical limits of what a 32 bit system is capable of. They truly are not the desired results, but they are not incorrect for the system.

Mathematical limits? A 32 bit system is capable of arbitrary precision arithmetic (as is any other system, with the appropriate software and possibly hardware).
The fact is that the answer given by server A's calculation is incorrect, even if the result of its calculation is correct.

CrashRoX

dream.scape; I ran your code on my 32bit machine running PHP 5.0.4 and the output was 43814. I have also been looking for a usable XOR formula to always generate the 32bit response. The only formula I found was one that forced a 64bit response. So I am still looking for that formula.

dream_scape

laserlight wrote:
Mathematical limits? A 32 bit system is capable of arbitrary precision arithmetic (as is any other system, with the appropriate software and possibly hardware).

Yes processors have specific limits within which they can calculate integer arithmetic. From there you have to do floating point arithmetic. PHP is usually very nice about this and will choose the correct arithmetic to perform, but given that the PHP bitwise operators convert numbers to integers before doing the operation, then no it is not an incorrect answer. Yes to a human brain it is incorrect, but if you try to do a bitwise operation on an number too large for the system to handle in integer arithmetic, the the results will appear incorrect because you have surpassed the systems limitations. We think it is incorrect, but in fact it is exactly how the computer and language are told to & designed to perform, and it is the result to be expected if you understand how the language performs the calculation. Whether or not the language performs the calculation how you think it should is a rather moot point when you are not the one in control of designing the language.

CrashRoX, PHP 5.1.2 on my 32 bit machine (PPC running OS X) returns -1 for any integer that overflows the machine limit. Perhaps this changed somewhere between 5.0.4 and 5.1.2, or perhaps is a difference between x86 and PPC or between OS X and other OSes, I'm not sure.

I've got an old programming algorithm book lying around here somewhere. I'll see if I can dig it out and see if it has a XOR algo in it. Even pseudo code would suffice.

PS. why still run 5.0.4 on your machine? From what I gather the 5.0.x branch isn't the most stable; compared to the 4.3 or 5.1 branch that is.

laserlight

Yes processors have specific limits within which they can calculate integer arithmetic. From there you have to do floating point arithmetic.

Or you can switch to arbitrary precision integer arithmetic, but as you noted this is a decision of the language designers, unless you are willing to use or write such a library yourself.

We think it is incorrect, but in fact it is exactly how the computer and language are told to & designed to perform, and it is the result to be expected if you understand how the language performs the calculation.

That's true, but it depends on your point of view. The results of the calculation of server A are correct with respect to the implementation, but incorrect with respect to the mathematical definition.

CrashRoX

Interesting. I appreciate all feedback and comments. I guess I never looked at it from that point of view. The results that were desired were the results that a 32bit machine would return. Which I guess in that case are not incorrect as they are the processors desired results 🙂

I should upgrade my version of PHP. Which by the way is running on x86. It hasnt really been a concern as the server is running local and no one but myself uses it. Unfortunately the bulk of my hosts are still using 4.x. Which has really hindered my ability to break into version 5.

Thanks for all the help. If you happen to stumble upon that algorithm it would be interesting to see. Thanks.

bpat1434

Along these lines, are there any really good write-ups on Bitwise calculations for newbs? I have no idea what they'd be used for, but they seem interesting and I love math. So... any links would be helpful....