is_nan - PHP code example

The PHP Function is_Nan

The php function is_nan is used to check whether a value is not a number, also known as a Non-Number (NaN). NaN values are the result of certain mathematical operations, such as dividing zero by zero.

In addition to the normal float value range, there are special values such as INF and -INF. INF is a number that represents infinity, while -INF is the opposite of a number and equals to -INF 1. Whenever any function calls the is_nan() function, the value passed must be one of these values or else the return will be false.

It's important to understand the semantics of floating point numbers as they are represented in PHP and other statically-typed languages. For example, most statically-typed languages interpret division of two integers in a way that preserves the fractional part of the result. This is in contrast to the float representation that uses underscores as separators between digits in a numeric literal.

In the next chapter we will explore functional programming and start to see how PHP enables you to write functional code by taking advantage of first-class, higher-order functions and closures. Moreover, we will learn how to glue these functions together in a flow that will create immutable data structures that you can use as the foundation of your applications.

is_nan example

if (null === $value) {
            return;
        }

        $types = (array) $constraint->type;

        foreach ($types as $type) {
            $type = strtolower($type);
            if (isset(self::VALIDATION_FUNCTIONS[$type]) && match ($type) {
                'finite-float' => \is_float($value) && is_finite($value),
                'finite-number' => \is_int($value) || \is_float($value) && is_finite($value),
                'number' => \is_int($value) || \is_float($value) && !is_nan($value),
                default => self::VALIDATION_FUNCTIONS[$type]($value),
            }) {
                return;
            }

            if ($value instanceof $type) {
                return;
            }
        }

        $this->context->buildViolation($constraint->message)

case 'double':
                $style = 'num';

                if (isset($this->styles['float'])) {
                    $style = 'float';
                }

                $value = match (true) {
                    \INF === $value => 'INF',
                    -\INF === $value => '-INF',
                    is_nan($value) => 'NAN',
                    default => !str_contains($value = (string) $value, $this->decimalPoint) ? $value .= $this->decimalPoint.'0' : $value,
                };
                break;

            case 'NULL':
                $value = 'null';
                break;

            case 'boolean':
                $value = $value ? 'true' : 'false';
                break;

return $a <=> (string) $b;
        }
        if ((int) $aTrim == $aTrim) {
            return (int) $aTrim <=> $b;
        } else {
            return (float) $aTrim <=> (float) $b;
        }
    }

    // float <=> string     if (\is_float($a) && \is_string($b)) {
        if (is_nan($a)) {
            return 1;
        }
        $bTrim = trim($b, " \t\n\r\v\f");
        if (!is_numeric($bTrim)) {
            return (string) $a <=> $b;
        }

        return $a <=> (float) $bTrim;
    }
    if (\is_string($a) && \is_float($b)) {
        if (is_nan($b)) {

function wp_convert_bytes_to_hr( $bytes ) {
    _deprecated_function( __FUNCTION__, '3.6.0', 'size_format()' );

    $units = array( 0 => 'B', 1 => 'KB', 2 => 'MB', 3 => 'GB', 4 => 'TB' );
    $log   = log( $bytes, KB_IN_BYTES );
    $power = (int) $log;
    $size  = KB_IN_BYTES ** ( $log - $power );

    if ( ! is_nan( $size ) && array_key_exists( $power, $units ) ) {
        $unit = $units[ $power ];
    } else {
        $size = $bytes;
        $unit = $units[0];
    }

    return $size . $unit;
}

/** * Formerly used internally to tidy up the search terms. * * @since 2.9.0 * @access private * @deprecated 3.7.0 * * @param string $t Search terms to "tidy", e.g. trim. * @return string Trimmed search terms. */

$scale = Zend_Locale_Math_PhpMath::$defaultScale;
        }

        $op1 = self::normalize($op1);
        $op2 = self::normalize($op2);

        // BCMath extension doesn't use decimal part of the power         // Provide the same behavior         $op2 = ($op2 > 0) ? floor($op2) : ceil($op2);

        $result = pow($op1, $op2);
        if (is_infinite($result)  or  is_nan($result)) {
            throw new Zend_Locale_Math_Exception("power overflow: $op1 ^ $op2", $op1, $op2, $result);
        }

        return self::round(self::normalize($result), $scale);
    }

    public static function Mul($op1, $op2, $scale = null)
    {
        if ($scale === null) {
            $scale = Zend_Locale_Math_PhpMath::$defaultScale;
        }