# PHP Numbers

### PHP Floats

In PHP, floats (or floating-point numbers) are numbers with a decimal point or an exponent. They are used to represent fractional or decimal values in PHP, such as 3.14 or 2.5e-3.

Floats in PHP are represented by the float data type, which is a primitive type in the language. The range of values that can be represented by floats depends on the system’s architecture and the implementation of the floating-point format used.

To define a float in PHP, you can simply assign a value with a decimal point or an exponent to a variable:

```\$float_var = 3.14;
\$scientific_notation = 2.5e-3;```

You can also perform arithmetic operations on floats, such as addition, subtraction, multiplication, and division:

```\$float1 = 3.14;
\$float2 = 2.5;
\$result = \$float1 + \$float2;  // \$result is 5.64```

When performing arithmetic operations on floats, it’s important to be aware of the limitations of floating-point arithmetic. Due to the nature of floating-point representation, certain operations may produce unexpected results, such as rounding errors or imprecise values. To avoid these issues, you can use the round() function to round floats to a specified number of decimal places:

```\$float1 = 3.14159265359;
\$rounded = round(\$float1, 2);  // \$rounded is 3.14```

In summary, floats in PHP are used to represent decimal or fractional values, and are represented by the float data type. They can be used in arithmetic operations, but it’s important to be aware of the limitations of floating-point arithmetic.

### PHP Infinity

In PHP, INF is a special constant that represents infinity, a concept used in mathematics to describe a quantity that is larger than any finite number. The INF constant can be used in PHP to represent a number that is too large to be stored in a normal numeric variable.

Here’s an example of how to use the INF constant in PHP:

```<?php
\$big_number = 1.0e100;
if (\$big_number == INF) {
echo "This number is too big!";
}
?>```

In this example, we’ve assigned a very large number to a variable called \$big_number . We then check if the value of \$big_number is equal to INF , which it will be since the number is too large to be represented by a normal numeric variable.

You can also use negative infinity by prefixing the INF constant with a minus sign ( –INF ).

It’s worth noting that arithmetic operations involving infinity in PHP behave according to certain rules of mathematics. For example, adding or subtracting infinity from a finite number will result in infinity, while multiplying or dividing infinity by a finite number will also result in infinity.

### PHP NaN

In PHP, NaN stands for “Not a Number” and is a special value that represents an undefined or unrepresentable numeric value. It is often used to indicate errors in mathematical operations that result in values that are undefined or not representable in PHP.

Here’s an example of how to use the NaN constant in PHP:

```<?php
\$result = sqrt(-1);
if (is_nan(\$result)) {
echo "Error: result is not a number!";
}
?>```

In this example, we’ve used the sqrt() function to calculate the square root of a negative number, which is not defined. The result of this calculation is NaN  , which we then check for using the is_nan() function. If the result is NaN , we print an error message.

You can also create NaN values by performing other undefined or invalid mathematical operations, such as dividing zero by zero or taking the logarithm of a negative number.

It’s worth noting that NaN values are not equal to any other value, including other NaN values. You can check for NaN values using the is_nan() function in PHP.

### PHP Numerical Strings

In PHP, a numerical string is a string that contains only numeric characters and an optional decimal point. PHP provides several built-in functions for working with numerical strings, including:

• is_numeric() : Checks whether a value is numeric.
• intval() : Converts a string to an integer.
• floatval() : Converts a string to a floating-point number.
• number_format() : Formats a number with a specified number of decimal places and thousands separators.

Here’s an example of how to use these functions with numerical strings:

```<?php
\$num_string = "1234.5678";
if (is_numeric(\$num_string)) {
\$num_int = intval(\$num_string);
\$num_float = floatval(\$num_string);
\$num_formatted = number_format(\$num_float, 2, '.', ',');
echo "Original string: \$num_string<br>";
echo "As integer: \$num_int<br>";
echo "As float: \$num_float<br>";
echo "Formatted: \$num_formatted";
}
?>```

In this example, we have a numerical string “1234.5678”. We use the is_numeric() function to check whether it is numeric, and then convert it to an integer using intval() and to a floating-point number using floatval(). Finally, we format the floating-point number with two decimal places and thousands separators using number_format() .

By working with numerical strings in PHP, you can perform various calculations and manipulations on numeric data that is stored as strings.

### PHP Casting Strings and Floats to Integers

In PHP, you can convert strings and floats to integers using casting or the built-in intval() function. When casting a string or a float to an integer, PHP simply truncates the decimal part and returns the integer portion of the value.

Here’s an example of casting a string to an integer:

```<?php
\$str = "1234";
\$int = (int)\$str;
echo "String: \$str, Integer: \$int";
?>```

In this example, we have a string “1234” . We cast it to an integer using (int) and assign the result to the variable \$int . The output of the program will be: “String: 1234, Integer: 1234”.

Here’s an example of converting a float to an integer using the intval() function:

```<?php
\$float = 12.34;
\$int = intval(\$float);
echo "Float: \$float, Integer: \$int";
?>```

In this example, we have a float 12.34 . We use the intval() function to convert it to an integer and assign the result to the variable \$int . The output of the program will be: “Float: 12.34, Integer: 12”.

It’s worth noting that when casting or converting a value to an integer, PHP will round towards zero, which means that positive numbers will be rounded down and negative numbers will be rounded up. If the value is not a valid numeric string or float, PHP will return 0

Scroll to Top