PHP Integers, Floats, and Number Strings (2023)

Working with numbers in PHP seems to be a trivial concept, but it can be quite confusing. It looks easy at first because PHP provides automatic type conversion. For example, you can assign an integer value to a variable, and the type of that variable will be an integer. On the next line, you can assign a string to the same variable, and the type will change to a string. Unfortunately, this automatic conversion can sometimes break your code.

There are a lot of types for numeric values as well. In this tutorial, you'll learn about integers and floats in PHP, as well as the functions which can be used to determine the type of numbers that we are dealing with and convert between them. You'll also learn how to convert integers and floats to and from numerical strings.

Different Types of Numbers in PHP

Integers

The most basic type of number in PHP is the integer. As you might already know, integers are numbers without any decimal part. For example, 2 is an integer, and so is 235298 or -235298. On the other hand, 2.0 and 3.58 are floats. We will discuss them in more detail later.

One important thing to remember is that it is not necessary that a number be of typeintif it does not have a decimal part. For example,16 * 2.5is exactly40, but the type of this result will still be afloat. When you are multiplying numbers, the final result will be of type float if at least one of the operands was a float. It doesn't matter if the final number has a decimal part or not.

Also, the maximum possible value an integer can have in PHP on your system can be obtained using the constantPHP_INT_MAX. A value greater in magnitude than the value returned byPHP_INT_MAXwill be stored as a float even if it looks like an integer.

Generally, you would expect the result of the multiplication of two variables of typeintto be of typeint. However, it is not true in the case of an overflow. Multiplication of five or six different numbers can easily take you outside the bounds of theinttype. For example, the result of128*309*32*43*309is a float on my system because it exceeds the value ofPHP_INT_MAX, which is2147483647.

You can use theis_int($value)function to check if a number is of type integer. There are two aliases of this function, calledis_integer($value)andis_long($value). Both of them will give the same result.

Floats

The next most common type of number that you will deal with is a float. Unlike integers, which were simply numbers without decimal points in most cases, a number of typefloatcan be represented in a variety of ways. The values3.14,12.0,5.87E+10, and3.56E-5are all floats.

PHP will automatically convert a number to thefloattype whenever decimals or very large numbers are involved. Thefloattype can commonly store numbers with magnitude approximately equal to1.7976931348623E+308. However, this is platform dependent.

The value1.7976931348623E+308may seem like a very large value—and it is!—but floats have a maximum precision of only about 14 digits. Any number with more digits than that will lose its precision. That means you can store a very large number, but you won't be able to keep the information about its exact value—in many cases, a float is only an approximation.

There are two functions which can be used to determine if the value you are dealing with is a float. These functions areis_float()andis_double(). Actually,is_double()is just an alias ofis_float(), so you can use any one of them and get the same result.

Infinity and NaN

There are two more kinds of numerical values that you might have to deal with when writing programs related to mathematics. These values are infinity andNaN(not a number). Both these values require a little explanation because they are different from what you might expect.

Infinity in PHP is different from infinity in real life. In PHP, any numerical value above approximatelyPHP_FLOAT_MAXon a platform is considered infinity. So1.8e308will give youfloat(INF)onvar_dump(). You can check if a numerical value is finite or infinite using theis_finite()andis_infinite()functions.

Similarly,NaNstands forNotaNumber, but it doesn't check if a value is numerical or not. The valueNaNis used for the result of mathematical operations which are not possible in mathematics. For example,log(-1)will beNaN. Similarly,acos(5)will also beNaN. You can check if the value returned by a mathematical operation is not a number by using the functionis_nan().

Numerical Strings in PHP

Just as PHP dynamically changes the type of different numbers based on how their values are used or assigned, it can also infer the value of different numerical strings for you to convert them to numbers.

The functionis_numeric()can help you determine if a string or variable is indeed numeric or not. This function will returntruefor numbers written in octal, binary, or hexadecimal notation. It will also returntrueif the numbers are written in exponential notation like+16.52e39.

Starting from PHP 7.0.0, when you pass a string tois_numeric(), it only returnstrueif the string consists of an optional sign, some digits, an optional decimal, and an optional exponential part. This means that a numerical string written in hexadecimal or binary format will returnfalsefrom PHP 7.0.0 onward.

PHP will implicitly cast any valid numerical string to a number when the need arises. The following examples should help you understand this process better.

1

<?php

2

3

$num = "3258712" + 12380;

4

// Output: int(3271092)

5

var_dump($num);

6

7

$num = "3258712" + "12380";

8

// Output: int(3271092)

9

var_dump($num);

10

11

$num = 3258712 + "12380";

12

// Output: int(3271092)

13

var_dump($num);

14

15

$num = 3258712 * "12380";

16

// Output: float(40342854560)

17

var_dump($num);

18

19

$num = 3258712 / "12380";

20

// Output: float(263.2239095315)

21

var_dump($num);

22

23

$num = 3258712 / "8";

24

// Output: int(407339)

25

var_dump($num);

26

27

$num = "53.9e4" + 10;

28

// Output: float(539010)

29

var_dump($num);

30

31

$num = "398.328" + 10;

32

// Output: float(408.328)

33

var_dump($num);

34

35

$num = "398328" + 0xfedd24;

36

// Output: int(17101084)

37

var_dump($num);

38

39

$num = 398328 + "0xfedd24";

40

// Output: int(398328)

41

var_dump($num);

42

43

?>

As you can see, all valid numerical strings were converted to their respective values before addition or other operations were performed. The type of$numin the end depends on its final value.

In the last case, the hexadecimal string"0xfedd24"is not converted to its decimal value because PHP 7 does not consider it to be a valid numerical string.

Casting Strings and Floats to Integers

Every now and then, you will need to cast one type of numerical value into another. PHP has a variety of functions and techniques to do so. Most of the time, the conversion will be implicit, and you won't have to worry about it. However, if you have to do the conversion explicitly, the techniques mentioned here will definitely help.

You can use(int)or(integer)to convert any value to an integer. In the case of floats, the values will always be rounded towards zero. Another way to cast strings and floats to integers is with the help of theintval()function. Both(int)andintval()work in the same manner.

1

<?php

2

3

$float_a = 3598723.8258;

4

$int_cast = (int)$float_a;

5

// Output: 3598723

6

echo $int_cast;

7

8

$string_a = "98723.828";

9

$int_cast = (int)$string_a;

10

// Output: 98723

11

echo $int_cast;

12

13

$string_b = "987233498349834828";

14

$int_cast = (int)$string_b;

15

// Output: 2147483647 on a 32 Bit Machine

16

echo $int_cast;

17

// Output: 987233498349834828 on a 64 Bit Machine

18

echo $int_cast;

19

20

21

22

$float_b = 21474836473492789;

23

$int_cast = (int)$float_b;

24

// Output: -6507212

25

echo $int_cast;

26

?>

You should note that casting overflowing strings to integers will set the final value to the maximum permissible integer value. However, casting a float whose value is more than the maximum permissible integer value will result in the value oscillating between-2147483648and2147483647!

In certain situations, you might need to deal with very large numbers without losing any precision. For example, it is impossible to get an accurate result of the multiplication of987233498349834828and3487197512using the*operator. It will give you3.4426781992086E+27after float conversion. Calculating the actual answer, which is3442678199208600117812547936, will require the use of libraries likeBCMath. BCMath works by storing numbers as strings and doing arithmetic operations on them manually. Just remember that if you use BCMath, you will be dealing with strings instead of integers and floats.

Certain libraries will want you to only pass numbers of typeintto their methods, but you might unknowingly supply them a float value. This might happen because the value seems like an int because it doesn't have a decimal part. This would almost certainly result in an error if the library uses a function likeis_int()to check if the passed number is of integer type. In such cases, it is always wise to first cast that number to int using either(int)orintval()and then pass it to any functions or methods of the library.

One example of when such a situation could come up would be when you are dealing with mathematical functions likefloor(),ceil(), etc.floor()andceil()will always return a float, even if you pass them an int!

1

<?php

2

3

$int_a = 15*12;

4

// Output: int(180)

5

var_dump($int_a);

6

7

$num = floor($int_a);

8

// Output: float(180)

9

var_dump($num);

10

11

?>

One problem with casting floats to integers is that you will lose the decimal part of the numbers. This may or may not be desirable. In such cases, you can use functions likefloor()and only cast the number to int type if its actual value is equal to the value returned byfloor().

1

<?php

2

3

$number = 16*2.5;

4

5

if(floor($number) == $number) {

6

 $fraction->setNumerator((int)$number);

7

} else {

8

 echo 'Did not set the numerator.';

9

 doSomethingElse();

10

}

11

12

?>

Let's say you have a library which allows you to do fractional arithmetic, and it throws exceptions when you pass a number to itssetNumerator()method that is not of type int. A variety of operations might turn a number into type float even if it is still an integer within the minimum and maximum bounds of type int. Using something like the code above will help you deal with such cases easily.

Tips for Working With Numbers in PHP

Numbers themselves can be infinitely large, but our computers have limited computer memory. This can lead to problems when working with numbers in a programming language.

Problems With Fixed-Size Integers

The largest number you can store as a standard integer on a 64-bit machine is 9223372036854775807. Any calculations with a result greater than that cannot be done with simple integers and require other solutions. This means that you should not use regular integers when there is a chance that the result might go above these limits. One option for larger numbers is to use floating-point numbers. However, they have their own drawbacks!

Problems With Floating-Point Numbers

Floating-point numbers are very common for everyday calculations. However, anything that you do with numbers which relies on comparing them for equality can result in problems. This is because floating-point numbers have limited precision, so comparisons between them aren't always perfect. Not only that, but computers are binary systems, and our number systems are decimal. The conversion between them is not always accurate. For example, 0.1 cannot be accurately represented in binary—similar to how 1/3 cannot be exactly represented in a fixed number of decimal digits. There is always some loss of precision.

For applications like graphics rendering or games, this loss of precision is not a problem. However, for banking or eCommerce applications, it could create major issues. One way to avoid this error is to convert the numbers you are working with into integers! For example, anything that costs $12.01 can be stored with integers internally as 1201 cents. Always consider using regular integers instead of floating points when precision is necessary.

Unlimited Precision Numbers

The best way to get around the limitations mentioned in the above two points is to store numbers as strings. An arbitrary precision library like BCMathin PHP can help you with this. It comes with many useful functions to make it easier for you to add, subtract, divide and multiply very large numbers without losing precision.

1

<?php

2

3

// Output: 3072022.352153

4

echo pow(145.37, 3);

5

6

// Output: 3072022.352153

7

echo bcpow('145.37', '3', 6);

8

9

// Output: 3072022.35215300000000000000

10

echo bcpow('145.37', '3', 20);

11

12

// Output: 7.485894688036E+64

13

echo pow(145.37, 30);

14

15

// Output: 74858946880359568408424850947105278367228015491111279108371943756.809526

16

echo bcpow('145.37', '30', 6);

17

18

// Output: 74858946880359568408424850947105278367228015491111279108371943756.809526310877954976795991720196399964284058833429514016256049

19

echo bcpow('145.37', '30', 60);

20

?>

As you can see, thebcpow()function can set the precision to an arbitrary value defined by the third parameter.

Of course, this functionality comes at a cost—using BCMath is significantly slower than the built-in number types in PHP. It's best to use the built-in numeric types unless you need the extra precision and range.

Final Thoughts

This tutorial has covered different ways in which PHP stores numbers and how you can determine if a number is of a particular type. For example, you can use functions like is_int()andis_float()to determine the type of a number and proceed accordingly.

As you saw in the tutorial, PHP supports automatic type conversion. This means that sometimes smaller integers like5or476could have been stored as floats without you realizing it.Using these numbers in functions which only acceptintvalues might result in exceptions or errors. We learned that a simple solution to this problem is to explicitly cast such numbers tointif they don't have a decimal part and their values don't change upon casting.

After reading this tutorial, you should be able to determine the type of a number or the final type of a result after using a variety of operations with predefined functions and also explicitly cast them to a specific type after doing some checks.

As always, if you have any questions or additional tips, you are welcome to comment.

Learn PHP With a Free Online Course

If you want to learn PHP, check out ourfree online course on PHP fundamentals!

In this course, you'll learn the fundamentals of PHP programming. You'll start with the basics, learning how PHP works and writing simple PHP loops and functions. Then you'll build up to coding classes for simple object-oriented programming (OOP). Along the way, you'll learn all the most important skills for writing apps for the web: you'll get a chance to practice responding to GET and POST requests, parsing JSON, authenticating users, and using a MySQL database.

• PHP FundamentalsJeremy McPeak29 Oct 2021