Type casting with (int) = unexpected results

[bunner_bob]

$myval = 115678948950;

echo (int)$myval;

// displays 2147483647

Wha.....?

[bretticus]

PHP converts type by context. For example, your $myval variable is already an integer (it was declared that way and context dictates type in that instance too.) When you echo a variable, context dictates that the variable should be converted to a string. By "pre"-casting the variable to an int, you force echo to evaluate the variable as an integer instead of a string. I have no idea why it produces the specific result you see (my test produced -285168042.)

[illzz]

Your value is too large for an Integer value (i'm guessing because of memory constraints). The value you were getting is the largest integer value for PHP, any number larger gets converted to a float, although i got the same results as bretticus in my testing.

PHP: Integers

Integer overflow

If PHP encounters a number beyond the bounds of the integer type, it will be interpreted as a float instead. Also, an operation which results in a number beyond the bounds of the integer type will return a float instead.

<?php
$large_number =  2147483647;
var_dump($large_number);
// output: int(2147483647)

$large_number =  2147483648;
var_dump($large_number);
// output: float(2147483648)

// it's true also for hexadecimal specified integers between 2^31 and 2^32-1:
var_dump( 0xffffffff );
// output: float(4294967295)

// this doesn't go for hexadecimal specified integers above 2^32-1:
var_dump( 0x100000000 );
// output: int(2147483647)

$million = 1000000;
$large_number =  50000 * $million;
var_dump($large_number);
// output: float(50000000000)
?>

[bretticus]

illzz, you must be right! I was wondering about the result too. That makes perfect sense. Which means, when setting the value to 115678948950, PHP must have an algorithm that stipulates a cast to integer only if the value fits into the allowed integer range. Since this is greater than the upper limit, it is automatically cast as a float. When forced to be cast as an integer, the value cannot go beyond it's upper limit so the value gets changed. echo then takes that new value and converts it back to a string before printing to buffer.

<?php
$myval = 115678948950;
echo gettype($myval);
?>

returns 'double'

<?php
$myval = 115678948950;
echo (double)$myval;
?>

returns 115678948950

This proves my first post was complete bunk! Thanks for helping me learn something illzz. The context stuff is correct, my theory that echo didn't do a type conversion because of the cast is "bunk" though.

Oh, and yes...

<?php
$myval = 50;
echo gettype($myval);
?>

returns 'integer'

[illzz]

I think I can see why he got the result he did (the largest integer).

But i'm still kind of confused on why we got the results we did (-285168042)....

There must be some reasoning for it, but initially I would think it should return false or some other error message...

[illzz]

That's what I like about forums like this.... you can always learn new things or better ways to do something.

[bretticus]

Yeah, I guess PHP is very forgiving even in a cast ( I agree with you that the compiler should throw an exception. ) Also, not sure why we get a negative value (signed zero equivalent perhaps?) I did want to mention that my results come from Zend Studio debugger.

[bunner_bob]

Thanks for the help, folks. I'll have to rethink part of my validation system. What I have now is

// if value is supposed to be an integer:

$integer = (int)$fieldvalue;

if ((string)$fieldvalue <> (string)$integer)
{
	$this->errors[$fieldname] = ' must be a number';
}

Obviously (now) this will break if the integer is bigger than the PHP max.

I guess I could do a preg_match and make sure all characters are numerical...

[illzz]

oohhhhh.... I didn't know that that's what you wanted.

you can use ctype_digit() to make sure that each of the characters are numeric.

[bretticus]

bunner bob wrote:

Thanks for the help, folks. I'll have to rethink part of my validation system. What I have now is

// if value is supposed to be an integer:

$integer = (int)$fieldvalue;

if ((string)$fieldvalue <> (string)$integer)
{
	$this->errors[$fieldname] = ' must be a number';
}

Obviously (now) this will break if the integer is bigger than the PHP max.

I guess I could do a preg_match and make sure all characters are numerical...

is_numeric() works just fine. Which is probably what you are after really (not so much a literal integer really.)

Also, I like to keep it strings with preg_match() like you mentioned you could do. PHP is missing all those parseType methods that are so useful in other languages. I think this came about because (like perl) PHP does alot of type juggling.

if ( !preg_match("/^[0-9]+$/", $fieldvalue) ) { //...

[bretticus]

illzz wrote:

oohhhhh.... I didn't know that that's what you wanted.

you can use ctype_digit() to make sure that each of the characters are numeric.

Wasn't aware of that function. Pretty much does the same thing as the preg_match function.

[illzz]

I also used is_numeric(), as you stated, until I came across that function from laserlight in a different thread.

One big difference that is helpful is that ctype_digit() fails if it is a decimal whereas is_numeric() returns true. So it all depends on your needs...

[bretticus]

illzz wrote:

I also used is_numeric(), as you stated, until I came across that function from laserlight in a different thread.

One big difference that is helpful is that ctype_digit() fails if it is a decimal whereas is_numeric() returns true. So it all depends on your needs...

Right, that's why I tend to use preg_match() instead. Had I been aware of ctype_digit() in the past, I would have used it too since it does exactly what my preg_match code does.

[Weedpacket]

illzz wrote:

But i'm still kind of confused on why we got the results we did (-285168042)....

PHP uses the IEEE-754 format to represent floating-point numbers. In 64 bits, to be precise. So it can represent numbers of the form $s$m(1<<$e) - where $s = +/-1 (the sign bit), 0 < $m < (1<<53) (the mantissa) and -1075 <= $e <= 970 (the exponent).

For 115678948950 those values are
$s = 1
$e = 0
$m = 115678948950

Written out in 64 bits that's

00000000000000000000000000011010 11101111000000001010111001010110
seeeeeeeeeeemmmmmmmmmmmmmmmmmmmm mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm

(The sign bit is 0 for positive numbers, 1 for negative).
A PHP integer is only 32 bits of that: the rightmost 32 bits. So when you force that into an integer you're left with

11101111000000001010111001010110

The leftmost bit of that is a 1 so this represents a negative integer (two's complement notation is used). So to make it a positive integer you flip all the bits and add 1.

00010000111111110101000110101010

That's the binary representation of 285168042. So the negative integer was -285168042.

My confusion is where the 2147483647 came from. What version of PHP / what platform was this running on?

[illzz]

Thanks for the insight Weedpacket.

The reason for the 2147483647 is that it look as if PHP, like MySQL, uses 4 bytes to store integer values. Since it uses signed integers by default, 1 bit is reserved for the sign.

If the remaining 31 bits are on, you get 01111111111111111111111111111111, which is equal to 2147483647.

[Weedpacket]

I know, but I'm wondering how one gets from 11101111000000001010111001010110 to 01111111111111111111111111111111.

[illzz]

illzz wrote:

you can use ctype_digit() to make sure that each of the characters are numeric.

One thing I just came across with this function is that the parameter MUST BE A STRING.

That is if you try to pass it an Integer, it will return false...