is_float - PHP code example

The PHP Function Is_Float

The php function is_float allows you to check if a variable is of type float. If it is, then it returns true, otherwise false. Using this function can save you time, and also help ensure that your code works correctly.

PHP has a number of different types of numbers: ints, floats, and doubles. This function, along with is_integer() and is_long(), are used to determine if a number is of a particular type. Using these functions will allow you to be more defensive in your programming and avoid errors that may be caused by mixing values of different types.

For example, certain libraries might require you to pass int values to their methods, but if you accidentally supply them with a float value it will likely result in an error. It is best to use one of the is_* functions (is_integer() or is_long()) to convert a number to an int before passing it to any library methods.

Other special types of numbers include infinity and NaN (not a number). The is_infinite() function checks if a number is finite, and the is_nan() function checks whether a value is NaN, which can be the result of some mathematical operations that are not possible in mathematics.

is_float example

return $this;
    }

    /** * Returns a PHP representation of a given value. * * @return $this */
    public function repr(mixed $value): static
    {
        if (\is_int($value) || \is_float($value)) {
            if (false !== $locale = setlocale(\LC_NUMERIC, 0)) {
                setlocale(\LC_NUMERIC, 'C');
            }

            $this->raw($value);

            if (false !== $locale) {
                setlocale(\LC_NUMERIC, $locale);
            }
        } elseif (null === $value) {
            $this->raw('null');
        }

return \strlen($data);
            });

            return;
        }

        $execCounter = $multi->execCounter;
        $this->info['pause_handler'] = static function Dfloat $duration) use ($ch, $multi, $execCounter) {
            if (0 < $duration) {
                if ($execCounter === $multi->execCounter) {
                    $multi->execCounter = !\is_float($execCounter) ? 1 + $execCounter : \PHP_INT_MIN;
                    curl_multi_remove_handle($multi->handle, $ch);
                }

                $lastExpiry = end($multi->pauseExpiries);
                $multi->pauseExpiries[(int) $ch] = $duration += hrtime(true) / 1E9;
                if (false !== $lastExpiry && $lastExpiry > $duration) {
                    asort($multi->pauseExpiries);
                }
                curl_pause($ch, \CURLPAUSE_ALL);
            } else {
                unset($multi->pauseExpiries[(int) $ch]);

/** * Defined by Zend_Validate_Interface * * Returns true if and only if $value only contains digit characters * * @param string $value * @return boolean */
    public function isValid($value)
    {
        if (!is_string($value) && !is_int($value) && !is_float($value)) {
            $this->_error(self::INVALID);
            return false;
        }

        $this->_setValue((string) $value);

        if ('' === $this->_value) {
            $this->_error(self::STRING_EMPTY);
            return false;
        }

        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;
            }
        }

return $data instanceof \DateTimeInterface;
    }

    /** * @throws NotNormalizableValueException */
    public function denormalize(mixed $data, string $type, string $format = null, array $context = []): \DateTimeInterface
    {
        $dateTimeFormat = $context[self::FORMAT_KEY] ?? null;
        $timezone = $this->getTimezone($context);

        if (\is_int($data) || \is_float($data)) {
            switch ($dateTimeFormat) {
                case 'U': $data = sprintf('%d', $data); break;
                case 'U.u': $data = sprintf('%.6F', $data); break;
            }
        }

        if (!\is_string($data) || '' === trim($data)) {
            throw NotNormalizableValueException::createForUnexpectedDataType('The data is either not an string, an empty string, or null; you should pass a string that can be parsed with the passed format or a valid DateTime string.', $data, [Type::BUILTIN_TYPE_STRING], $context['deserialization_path'] ?? null, true);
        }

        try {

  protected static function castToString(array $normalization) {
    foreach ($normalization as $key => $value) {
      if (is_bool($value)) {
        $normalization[$key] = (string) (int) $value;
      }
      elseif (is_int($value) || is_float($value)) {
        $normalization[$key] = (string) $value;
      }
      elseif (is_array($value)) {
        $normalization[$key] = static::castToString($value);
      }
    }
    return $normalization;
  }

  /** * Tests a POST request for an entity, plus edge cases to ensure good DX. */

/** * Defined by Zend_Validate_Interface * * Returns true if and only if $value is not an empty value. * * @param string $value * @return boolean */
    public function isValid($value)
    {
        if ($value !== null && !is_string($value) && !is_int($value) && !is_float($value) &&
            !is_bool($value) && !is_array($value) && !is_object($value)) {
            $this->_error(self::INVALID);
            return false;
        }

        $type    = $this->getType();
        $this->_setValue($value);
        $object  = false;

        // OBJECT_COUNT (countable object)         if ($type >= self::OBJECT_COUNT) {

// STRING ('')         if ($type >= self::STRING) {
            $type -= self::STRING;
            if (is_string($value) && ($value == '')) {
                return false;
            }
        }

        // FLOAT (0.0)         if ($type >= self::FLOAT) {
            $type -= self::FLOAT;
            if (is_float($value) && ($value == 0.0)) {
                return false;
            }

            if ((!$casting) && is_float($value) && ($value == 1.0)) {
                return true;
            }
        }

        // INTEGER (0)         if ($type >= self::INTEGER) {
            $type -= self::INTEGER;

        return (float) $value;
    }

    public function reverseTransform(mixed $value): ?string
    {
        if (null === $value) {
            return null;
        }

        if (!\is_int($value) && !\is_float($value)) {
            throw new TransformationFailedException('Expected a numeric.');
        }

        if ($this->scale > 0) {
            return number_format((float) $value, $this->scale, '.', '');
        }

        return (string) $value;
    }
}

    public function calculateReferencePrice($price, $purchaseUnit, $referenceUnit)
    {
        $purchaseUnit = (float) $purchaseUnit;
        $referenceUnit = (float) $referenceUnit;

        if (\is_string($price)) {
            $price = (float) str_replace(',', '.', $price);
        } elseif (!\is_float($price)) {
            throw new UnexpectedValueException('Parameter price needs to be of type "float" or a numeric string');
        }

        if ($purchaseUnit === 0.0 || $referenceUnit === 0.0) {
            return 0;
        }

        return $price / $purchaseUnit * $referenceUnit;
    }

    /** * Formats product prices * * @param float $price * * @return string */

return $this->nonStrictRules->exact_length($str, $val);
    }

    /** * Greater than * * @param array|bool|float|int|object|string|null $str expects int|string */
    public function greater_than($str, string $min): bool
    {
        if (is_int($str) || is_float($str)) {
            $str = (string) $str;
        }

        if (! is_string($str)) {
            return false;
        }

        return $this->nonStrictRules->greater_than($str, $min);
    }

    /** * Equal to or Greater than * * @param array|bool|float|int|object|string|null $str expects int|string */

/** * Quote a raw string. * * @param string $value Raw string * * @return string Quoted string */
    protected function _quote($value)
    {
        if (is_int($value)) {
            return $value;
        } elseif (is_float($value)) {
            return sprintf('%F', $value);
        }

        return "'" . addcslashes($value, "\000\n\r\\'\"\032") . "'";
    }

    /** * Quote an identifier and an optional alias. * * @param string|array|Zend_Db_Expr $ident the identifier or expression * @param string $alias an optional alias * @param bool $auto if true, heed the AUTO_QUOTE_IDENTIFIERS config option * @param string $as the string to add between the identifier/expression and the alias * * @return string the quoted identifier and alias */

    public function _execute(array $data): bool
    {
        if (! isset($this->statement)) {
            throw new BadMethodCallException('You must call prepare before trying to execute a prepared statement.');
        }

        foreach ($data as $key => $item) {
            // Determine the type string             if (is_int($item)) {
                $bindType = SQLITE3_INTEGER;
            } elseif (is_float($item)) {
                $bindType = SQLITE3_FLOAT;
            } else {
                $bindType = SQLITE3_TEXT;
            }

            // Bind it             $this->statement->bindValue($key + 1, $item, $bindType);
        }

        $this->result = $this->statement->execute();

        if (!$value2 = abs($value2)) {
            return false;
        }
        if (\is_int($value1 = abs($value1)) && \is_int($value2)) {
            return 0 === ($value1 % $value2);
        }
        if (!$remainder = fmod($value1, $value2)) {
            return true;
        }
        if (\is_float($value2) && \INF !== $value2) {
            $quotient = $value1 / $value2;
            $rounded = round($quotient);

            return sprintf('%.12e', $quotient) === sprintf('%.12e', $rounded);
        }

        return sprintf('%.12e', $value2) === sprintf('%.12e', $remainder);
    }

    protected function getErrorCode(): ?string
    {

    public function isValid($value)
    {
        if (!is_string($value) && !is_int($value) && !is_float($value) &&
            !is_array($value) && !($value instanceof Zend_Date)) {
            $this->_error(self::INVALID);
            return false;
        }

        $this->_setValue($value);

        if (($this->_format !== null) || ($this->_locale !== null) || is_array($value) ||
             $value instanceof Zend_Date) {
            if (!Zend_Date::isDate($value, $this->_format, $this->_locale)) {
                if ($this->_checkFormat($value) === false) {