Help dealing with int conversions from C++ to PHP

[98InTheHole]

Hey, first post here, hopefully you guys can help.

I have some legacy C++ code I need to convert to PHP, I have a running version of the C++ routine, as well as the code for that routine.

Here's the C++ line:

(I have simplified it a bit to display the problem)

	int n_1,n_2,n_3,n_4;

n_1 = 947;
n_2 = 1842;
n_4 = 7609;

n_3 = ((((n_1 * n_2) * (n_4 + 6)) + n_4 + 29) / (n_1)) * n_1;		

    while (n_3 > 9999)
	n_3 -= 8888;
while (n_3 < 1000)
	n_3 += 1237;

In C++ the result is n_3 = 2443;

As you can see there are several issues here, the most critical is that the calculation of n_3 "overflows" because of the int maximum values.
The other "debugging" problem is that the "while's" prevent me from seeing what the actual calculation returned.

When I run this in PHP:

	$n_1 = 947;
	$n_2 = 1842;
	$n_4 = 7609;

$n_3 = (((($n_1 * $n_2) * ($n_4 + 6)) + $n_4 + 29) / ($n_1)) * $n_1;

while ($n_3 > 9999)
	$n_3 -= 8888;
while ($n_3 < 1000)
	$n_3 += 1237;

$n_3 = 6344;

As far as I can tell, the PHP code is actually correct, and the C++ code is buggy because of the "misuse" of the int type, however I need to replicate this "bug" in PHP so that I can get the exact same value of $n_3 as C++ would give me.

Any help would be most appreciated, I have played with decbin and bindec to remove bits from the number after and during the calculation, however I think I'm probably missing a fundamental understanding of how int works in C++

Thanks again!

[bradgrafelman]

98InTheHole;10998882 wrote:

The other "debugging" problem is that the "while's" prevent me from seeing what the actual calculation returned.

That's not really true - just set a break point on the while() condition and step through the code in your debugger.

98InTheHole;10998882 wrote:

When I run this in PHP:
...
$n_3 = 6344;

Actually, that's not quite true. It would be more correct to say:

$n_3 = 6344.;

or (more explicitly):

$n_3 = (float)(6344);

since PHP will convert $n_3 to a floating point number rather than allowing the integer to overflow.

Example that illustrates the differences...

C++ code:

  printf("(n_1 * n_2) is: %d\n", (n_1 * n_2));
  printf("((n_1 * n_2) * (n_4 + 6)) is: %d\n", ((n_1 * n_2) * (n_4 + 6)));
  printf("(((n_1 * n_2) * (n_4 + 6)) + n_4 + 29) is: %d\n", (((n_1 * n_2) * (n_4 + 6)) + n_4 + 29));
  printf("((((n_1 * n_2) * (n_4 + 6)) + n_4 + 29) / (n_1)) is: %d\n", ((((n_1 * n_2) * (n_4 + 6)) + n_4 + 29) / (n_1)));

output:

(n_1 * n_2) is: 1744374
((n_1 * n_2) * (n_4 + 6)) is: 398506122
(((n_1 * n_2) * (n_4 + 6)) + n_4 + 29) is: 398513760
((((n_1 * n_2) * (n_4 + 6)) + n_4 + 29) / (n_1)) is: 420817

PHP code:

  print("(n_1 * n_2) is: "); var_dump(($n_1 * $n_2));
  print("((n_1 * n_2) * (n_4 + 6)) is: "); var_dump((int)(($n_1 * $n_2) * ($n_4 + 6)));
  print("(((n_1 * n_2) * (n_4 + 6)) + n_4 + 29) is: "); var_dump(((($n_1 * $n_2) * ($n_4 + 6)) + $n_4 + 29));
  print("((((n_1 * n_2) * (n_4 + 6)) + n_4 + 29) / (n_1)) is: "); var_dump((((($n_1 * n_2) * ($n_4 + 6)) + $n_4 + 29) / ($n_1)));

output:

(n_1 * n_2) is: int(1744374)
((n_1 * n_2) * (n_4 + 6)) is: float(13283408010)
(((n_1 * n_2) * (n_4 + 6)) + n_4 + 29) is: float(13283415648)
((((n_1 * n_2) * (n_4 + 6)) + n_4 + 29) / (n_1)) is: float(8.065469904963)

What you need to do is override PHP's automatic promotion to the float numeric type by explicitly casting the result back to an int. Example:

    $n_3 = (int)((int)(((int)(($n_1 * $n_2) * ($n_4 + 6)) + $n_4 + 29) / ($n_1)) * $n_1); 
    var_dump($n_3);

output:

int(398513699)

(which matches what the C++ code computes before the while() loops).

[98InTheHole]

Thank a lot for the comprehensive reply, it helped clear a few points, however something is still weird, when I used the calculation as you suggested, I don't get the same value you do.

When I run this:

$n_3 = (int)((int)(((int)(($n_1 $n_2) ($n_4 + 6)) + $n_4 + 29) / ($n_1)) * $n_1);

I get:

$n_3 = 13283415586

Am I missing something?

[bradgrafelman]

Which OS (including architecture - e.g. x86/32-bit or x64/64-bit) are you using when you got that result? Sounds like it might've been a 64-bit OS and that PHP is using a 64-bit integer for 'int' variables (which makes sense, but has the unfortunate side effect of being more efficient than what you want).

A truly portable (e.g. architecture-independent) solution is going to involve explicitly masking the result of each calculation to force it to be within the range of a 32-bit value. In other words, you're going to have to simulate a 32-bit overflow condition in code for every mathematical operation.

Sound complicated (or at least a lot more complicated than it needs to be)? It is; blame whoever wrote that C code, because they definitely didn't do a very good job of it. :p

EDIT: To illustrate that the difference in values is indeed due to architecture, executing this code:

var_dump((int)13283415586);

on a 32-bit OS results in:

int(398513698)

The reason becomes much clearer when you look at the binary representation of the two numbers:

13283415586 = 1100010111110000001101011000100010    

398513698   =      10111110000001101011000100010

Note that the lower 32-bits of the two numbers are the same, and that a 32-bit OS/hardware can, of course, only deal with 32 bits at a time.

EDIT2: Forgot to clarify, the above assumes we're talking about a big-endian representation.

[bradgrafelman]

Apologies for the double post, but the above post seemed long enough.

As an example of this:

bradgrafelman;10998921 wrote:

explicitly masking the result of each calculation to force it to be within the range of a 32-bit value

try executing the following code and tell us what it outputs:

function int32( $int )
{
  return( ( ( int )$int ) & 0xFFFFFFFF );
}

$number = ( int )13283415586

echo "Before: "; var_dump( $number )
echo "After:  "; var_dump( int32( $number ) );

[Derokorian]

Question: I thought the max signed int on a 32bit system was 2 billion and change?

[bradgrafelman]

Derokorian;10998927 wrote:

Question: I thought the max signed int on a 32bit system was 2 billion and change?

Aye, the interval is [-2^31, 2^31). Why do you ask... did I contradict that somewhere?

[Derokorian]

I'm not sure, I'm just confused then why var_dump((int)13283415586); is 398513698 which is less than half a billion. I know its not wrong, because I obviously checked. I'm just confused why casting as int doesn't return 2147483647.

[bradgrafelman]

Again, that's because a 32-bit OS can only deal with 32 bits at a time:

bradgrafelman;10998921 wrote:

The reason becomes much clearer when you look at the binary representation of the two numbers:

13283415586 = 1100010111110000001101011000100010    

398513698   =      10111110000001101011000100010

Note that the lower 32-bits of the two numbers are the same, and that a 32-bit OS/hardware can, of course, only deal with 32 bits at a time.

Thus 13283415586 and 398513698 are the same value on a 32-bit OS/machine since their lower 32 bits are the same.

[bradgrafelman]

Derokorian;10998929 wrote:

I'm just confused why casting as int doesn't return 2147483647.

Casting is different than rounding or saturating; casting simply means you're telling the machine "Hey, look at these X bits and treat them as if they were (an integer)."

[Derokorian]

OH oh ok I get it now its just truncating the value as stored in memory as opposed to reducing it to within the acceptable limits. My confusion came from MySQL as that uses the integer closest to the value supplied within range as opposed to truncating the bits. Sorry for the side-bar but I didn't understand what was going on =D

[98InTheHole]

bradgrafelman;10998924 wrote:

Apologies for the double post, but the above post seemed long enough.

As an example of this: try executing the following code and tell us what it outputs:

function int32( $int )
{
  return( ( ( int )$int ) & 0xFFFFFFFF );
}

$number = ( int )13283415586

echo "Before: "; var_dump( $number )
echo "After:  "; var_dump( int32( $number ) );

I agree with you, that c++ code is BAD :-)

Anyway, I ran the code you sent, here's the results:

Before: int(13283415586)
After: int(398513698)

As you suspected, I am indeed running a 64bit system.

I tried using that "int32" function on $n_3, and also during the calculation, like this:

$n_3 = int32(((int32((int32(($n_1 * $n_2)) * ($n_4 + 29))) + $n_4 + 6) / ($n_1)) * $n_1);

The result was close (missed it by 1), however it's not there, I plugged in other samples I have, and I'm not getting the right result.

What else can I try?

[bradgrafelman]

98InTheHole;10998935 wrote:

I plugged in other samples I have, and I'm not getting the right result.

Can you show us an example?

[98InTheHole]

bradgrafelman;10998936 wrote:

Can you show us an example?

Sure, I can produce these numbers as I please, so I can give you as many as you want :-)

Here you go:

n1: 426
n2: 7960
n4: 4035

expected n3: 8480

n1: 671
n2: 2262
n4: 9235

expected n3: 2805

n1: 767
n2: 2642
n4: 3957

expected n3: 1971

Let me know if you want a few more.

Thanks.

[Derokorian]

Try this out =D

<?php
/* C++ code
	int n_1,n_2,n_3,n_4;

n_1 = 947;
n_2 = 1842;
n_4 = 7609;

n_3 = ((((n_1 * n_2) * (n_4 + 6)) + n_4 + 29) / (n_1)) * n_1;		

    while (n_3 > 9999)
	n_3 -= 8888;
while (n_3 < 1000)
	n_3 += 1237;
 */

$tests = array(
	2443 => array(947,1842,7609),
	8480 => array(426,7960,4035),
	2805 => array(671,2262,9235),
	1971 => array(767,2642,3957)
);

echo '<pre>';
foreach( $tests as $expected => $test ) {
	$actual = InTheHole($test[0],$test[1],$test[2]);
	echo "Expected to get: $expected\nActually got: $actual\n\n";
}
echo '</pre>';

function InTheHole($n1,$n2,$n4) {
	$part1 = (int) $n1 * $n2;
	$part2 = (int) $n4 + 6;
	$part3 = (int) $part1 * $part2;
	$part4 = (int) $n4 + 29;
	$part5 = (int) $part3 + $part4;
	$n3 = (int) $part5 / $n1;
	$n3 = (int) $n3 * $n1;
	while( $n3 > 9999 )
		$n3 -= 8888;
	while( $n3 < 1000 )
		$n3 += 1237;
	return $n3;
}

Which produces this output:

Expected to get: 2443
Actually got: 2443

Expected to get: 8480
Actually got: 8480

Expected to get: 2805
Actually got: 2805

Expected to get: 1971
Actually got: 1971

[bradgrafelman]

Derokorian;10998939 wrote:

Which produces this output:

Expected to get: 2443
Actually got: 2443

Expected to get: 8480
Actually got: 8480

Expected to get: 2805
Actually got: 2805

Expected to get: 1971
Actually got: 1971

... on a 32-bit system only. 😉

[Derokorian]

bradgrafelman;10998940 wrote:

... on a 32-bit system only. 😉

Aww damn I didn't realize I had 32bit PHP on my 64bit Win7 ha. I failed =\

[bradgrafelman]

I haven't had time to look into the past couple of responses to this thread in depth (probably won't until later this evening), but...

@: Could you execute Derkorian's test code and let us know if you get different results?

[98InTheHole]

Derokorian;10998939 wrote:

Try this out =D

<?php
/* C++ code
	int n_1,n_2,n_3,n_4;

n_1 = 947;
n_2 = 1842;
n_4 = 7609;

n_3 = ((((n_1 * n_2) * (n_4 + 6)) + n_4 + 29) / (n_1)) * n_1;		

    while (n_3 > 9999)
	n_3 -= 8888;
while (n_3 < 1000)
	n_3 += 1237;
 */

$tests = array(
	2443 => array(947,1842,7609),
	8480 => array(426,7960,4035),
	2805 => array(671,2262,9235),
	1971 => array(767,2642,3957)
);

echo '<pre>';
foreach( $tests as $expected => $test ) {
	$actual = InTheHole($test[0],$test[1],$test[2]);
	echo "Expected to get: $expected\nActually got: $actual\n\n";
}
echo '</pre>';

function InTheHole($n1,$n2,$n4) {
	$part1 = (int) $n1 * $n2;
	$part2 = (int) $n4 + 6;
	$part3 = (int) $part1 * $part2;
	$part4 = (int) $n4 + 29;
	$part5 = (int) $part3 + $part4;
	$n3 = (int) $part5 / $n1;
	$n3 = (int) $n3 * $n1;
	while( $n3 > 9999 )
		$n3 -= 8888;
	while( $n3 < 1000 )
		$n3 += 1237;
	return $n3;
}

Which produces this output:

Expected to get: 2443
Actually got: 2443

Expected to get: 8480
Actually got: 8480

Expected to get: 2805
Actually got: 2805

Expected to get: 1971
Actually got: 1971

Thanks for this, however these are NOT the results I'm getting, could it be again the 32bit vs 64bit issue?

These are my results:

Expected to get: 2443
Actually got: 6282

Expected to get: 8480
Actually got: 3618

Expected to get: 2805
Actually got: 6413

Expected to get: 1971
Actually got: 1221

What's going on? :-)

[Derokorian]

Hmm this is very confusing. Brad I hope you can clear this up but if I change the function I made to this:

function InTheHole($n1,$n2,$n4) {
	$part1 = int32($n1 * $n2);
	$part2 = int32($n4 + 6);
	$part3 = int32($part1 * $part2);
	$part4 = int32($n4 + 29);
	$part5 = int32($part3 + $part4);
	$n3 = int32($part5 / $n1);
	$n3 = int32($n3 * $n1);
	while( $n3 > 9999 )
		$n3 = int32($n3-8888);
	while( $n3 < 1000 )
		$n3 = int32($n3+1237);
	return $n3;
}
function int32( $int ) { 
  return( ( ( int )$int ) & 0xFFFFFFFF ); 
}

I get 3/4 answers correct. And the last one is WAY off:

Expected to get: 2443
Actually got: 2443

Expected to get: 8480
Actually got: 8480

Expected to get: 2805
Actually got: 2805

Expected to get: 1971
Actually got: 8526

This is on a real 64bit system (my webhost not my local machine) where I got the same output as 98InTheHole before changing it.