PHP is_infinite函数代码示例

 /**
  * @param mixed $value
  * @param int   $depth
  *
  * @return string
  */
 public static function stringify($value, $depth = 1)
 {
     if ($depth >= self::$maxDepthStringify) {
         return self::$maxReplacementStringify;
     }
     if (is_array($value)) {
         return static::stringifyArray($value, $depth);
     }
     if (is_object($value)) {
         return static::stringifyObject($value, $depth);
     }
     if (is_resource($value)) {
         return sprintf('`[resource] (%s)`', get_resource_type($value));
     }
     if (is_float($value)) {
         if (is_infinite($value)) {
             return ($value > 0 ? '' : '-') . 'INF';
         }
         if (is_nan($value)) {
             return 'NaN';
         }
     }
     $options = 0;
     if (version_compare(PHP_VERSION, '5.4.0', '>=')) {
         $options = JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE;
     }
     return @json_encode($value, $options) ?: $value;
 }

 public function testINF()
 {
     $this->assertTrue(is_infinite(GreatestCommonDivisor::greatestCommonDivisor([10, INF])));
     $this->assertTrue(is_infinite(GreatestCommonDivisor::greatestCommonDivisor([INF, INF])));
     $this->assertTrue(is_infinite(GreatestCommonDivisor::greatestCommonDivisor([INF, 10])));
     $this->assertTrue(is_infinite(GreatestCommonDivisor::greatestCommonDivisor([10, INF, 10])));
 }

 /**
  * Dumps a given PHP variable to a YAML string.
  *
  * @param mixed $value The PHP variable to convert
  *
  * @return string The YAML string representing the PHP array
  *
  * @throws DumpException When trying to dump PHP resource
  */
 public static function dump($value)
 {
     switch (true) {
         case is_resource($value):
             throw new DumpException(sprintf('Unable to dump PHP resources in a YAML file ("%s").', get_resource_type($value)));
         case is_object($value):
             return '!!php/object:' . serialize($value);
         case is_array($value):
             return self::dumpArray($value);
         case null === $value:
             return 'null';
         case true === $value:
             return 'true';
         case false === $value:
             return 'false';
         case ctype_digit($value):
             return is_string($value) ? "'{$value}'" : (int) $value;
         case is_numeric($value):
             return is_string($value) ? "'{$value}'" : (is_infinite($value) ? str_ireplace('INF', '.Inf', strval($value)) : $value);
         case Escaper::requiresDoubleQuoting($value):
             return Escaper::escapeWithDoubleQuotes($value);
         case Escaper::requiresSingleQuoting($value):
             return Escaper::escapeWithSingleQuotes($value);
         case '' == $value:
             return "''";
         case preg_match(self::getTimestampRegex(), $value):
         case in_array(strtolower($value), array('null', '~', 'true', 'false')):
             return "'{$value}'";
         default:
             return $value;
     }
 }

 public function getHuman($max_groups = INF, $short = false)
 {
     $short = (bool) $short;
     if ($max_groups < 1) {
         $max_groups = INF;
     }
     $for_print = [];
     if ($this->_years > 0) {
         $for_print[] = sprintf("%d %s", $this->_years, MeasureWord::getFormByForms($this->_forms[$short][0], intval($this->_years)));
         // years
     }
     if ($this->_months > 0) {
         $for_print[] = sprintf("%d %s", $this->_months, MeasureWord::getFormByForms($this->_forms[$short][1], intval($this->_months)));
         // months
     }
     if ($this->_days > 0) {
         $for_print[] = sprintf("%d %s", $this->_days, MeasureWord::getFormByForms($this->_forms[$short][2], intval($this->_days)));
         // days
     }
     if ($this->_hours > 0) {
         $for_print[] = sprintf("%d %s", $this->_hours, MeasureWord::getFormByForms($this->_forms[$short][3], intval($this->_hours)));
         // hours
     }
     if ($this->_minutes > 0) {
         $for_print[] = sprintf("%d %s", $this->_minutes, MeasureWord::getFormByForms($this->_forms[$short][4], intval($this->_minutes)));
         // minutes
     }
     if ($this->_seconds > 0 || empty($for_print)) {
         $for_print[] = sprintf("%d %s", $this->_seconds, MeasureWord::getFormByForms($this->_forms[$short][5], intval($this->_seconds)));
         // seconds
     }
     return trim(preg_replace('/ {2,}/', ' ', join(' ', is_infinite($max_groups) ? $for_print : array_slice($for_print, 0, $max_groups))));
 }

 /**
  * @covers Fisharebest\PhpPolyfill\Php::inf
  * @covers Fisharebest\PhpPolyfill\Php::isLittleEndian
  * @runInSeparateProcess
  */
 public function testInf()
 {
     $this->assertTrue(is_float(Php::inf()));
     $this->assertTrue(is_double(Php::inf()));
     $this->assertTrue(is_infinite(Php::inf()));
     $this->assertFalse(is_finite(Php::inf()));
 }

 /**
  * Parse a string of the form "number unit" where unit is optional. The
  * results are stored in the $number and $unit parameters. Returns an
  * error code.
  * @param $value string to parse
  * @param $number call-by-ref parameter that will be set to the numerical value
  * @param $unit call-by-ref parameter that will be set to the "unit" string (after the number)
  * @return integer 0 (no errors), 1 (no number found at all), 2 (number
  * too large for this platform)
  */
 protected static function parseNumberValue($value, &$number, &$unit)
 {
     // Parse to find $number and (possibly) $unit
     $decseparator = NumberFormatter::getInstance()->getDecimalSeparatorForContentLanguage();
     $kiloseparator = NumberFormatter::getInstance()->getThousandsSeparatorForContentLanguage();
     $parts = preg_split('/([-+]?\\s*\\d+(?:\\' . $kiloseparator . '\\d\\d\\d)*' . '(?:\\' . $decseparator . '\\d+)?\\s*(?:[eE][-+]?\\d+)?)/u', trim(str_replace(array(' ', ' ', ' ', ' '), '', $value)), 2, PREG_SPLIT_DELIM_CAPTURE);
     if (count($parts) >= 2) {
         $numstring = str_replace($kiloseparator, '', preg_replace('/\\s*/u', '', $parts[1]));
         // simplify
         if ($decseparator != '.') {
             $numstring = str_replace($decseparator, '.', $numstring);
         }
         list($number) = sscanf($numstring, "%f");
         if (count($parts) >= 3) {
             $unit = self::normalizeUnit($parts[2]);
         }
     }
     if (count($parts) == 1 || $numstring === '') {
         // no number found
         return 1;
     } elseif (is_infinite($number)) {
         // number is too large for this platform
         return 2;
     } else {
         return 0;
     }
 }

 /**
  * @param float $maintainabilityIndexWithoutComment
  */
 public function setMaintainabilityIndexWithoutComment($maintainabilityIndexWithoutComment)
 {
     if (is_infinite($maintainabilityIndexWithoutComment)) {
         $maintainabilityIndexWithoutComment = 171;
     }
     $this->maintainabilityIndexWithoutComment = round($maintainabilityIndexWithoutComment, 2);
 }

 /**
  * Process the Truncate operator.
  * 
  * @return integer|null The truncated value or NULL if the sub-expression is NaN or if the sub-expression is NULL.
  * @throws OperatorProcessingException
  */
 public function process()
 {
     $operands = $this->getOperands();
     if ($operands->containsNull() === true) {
         return null;
     }
     if ($operands->exclusivelySingle() === false) {
         $msg = "The Truncate operator only accepts operands with a single cardinality.";
         throw new OperatorProcessingException($msg, $this, OperatorProcessingException::WRONG_CARDINALITY);
     }
     if ($operands->exclusivelyNumeric() === false) {
         $msg = "The Truncate operator only accepts operands with an integer or float baseType.";
         throw new OperatorProcessingException($msg, $this, OperatorProcessingException::WRONG_BASETYPE);
     }
     $operand = $operands[0];
     if (is_nan($operand->getValue())) {
         return null;
     } else {
         if (is_infinite($operand->getValue())) {
             return new Float(INF);
         } else {
             return new Integer(intval($operand->getValue()));
         }
     }
 }

 public function logQuery(array $query)
 {
     dump($query);
     exit;
     if ($this->logger === NULL) {
         return;
     }
     if (isset($query['batchInsert']) && NULL !== $this->batchInsertTreshold && $this->batchInsertTreshold <= $query['num']) {
         $query['data'] = '**' . $query['num'] . ' item(s)**';
     }
     array_walk_recursive($query, function (&$value, $key) {
         if ($value instanceof \MongoBinData) {
             $value = base64_encode($value->bin);
             return;
         }
         if (is_float($value) && is_infinite($value)) {
             $value = ($value < 0 ? '-' : '') . 'Infinity';
             return;
         }
         if (is_float($value) && is_nan($value)) {
             $value = 'NaN';
             return;
         }
     });
     $this->logger->debug($this->prefix . json_encode($query));
 }

 /**
  * Returns the result of filtering $value
  *
  * @param mixed $value
  * @return mixed
  */
 public function filter($value)
 {
     $unfilteredValue = $value;
     if (is_float($value) && !is_nan($value) && !is_infinite($value)) {
         ErrorHandler::start();
         $formatter = $this->getFormatter();
         $currencyCode = $this->setupCurrencyCode();
         $result = $formatter->formatCurrency($value, $currencyCode);
         ErrorHandler::stop();
         // FIXME: verify that this, given the initial IF condition, never happens
         // if ($result === false) {
         // return $unfilteredValue;
         // }
         // Retrieve the precision internally used by the formatter (i.e., depends from locale and currency code)
         $precision = $formatter->getAttribute(\NumberFormatter::FRACTION_DIGITS);
         // $result is considered valid if the currency's fraction digits can accomodate the $value decimal precision
         // i.e. EUR (fraction digits = 2) must NOT allow double(1.23432423432)
         $isFloatScalePrecise = $this->isFloatScalePrecise($value, $precision, $this->formatter->getAttribute(\NumberFormatter::ROUNDING_MODE));
         if ($this->getScaleCorrectness() && !$isFloatScalePrecise) {
             return $unfilteredValue;
         }
         return $result;
     }
     return $unfilteredValue;
 }

 /**
  * Dumps PHP array to YAML.
  *
  * @param mixed $value PHP
  *
  * @return string YAML
  */
 public static function dump($value)
 {
     switch (true) {
         case is_resource($value):
             throw new InvalidArgumentException('Unable to dump PHP resources in a YAML file.');
         case is_object($value):
             return '!!php/object:' . serialize($value);
         case is_array($value):
             return self::dumpArray($value);
         case is_null($value):
             return 'null';
         case true === $value:
             return 'true';
         case false === $value:
             return 'false';
         case ctype_digit($value):
             return is_string($value) ? "'{$value}'" : (int) $value;
         case is_numeric($value):
             return is_infinite($value) ? str_ireplace('INF', '.Inf', strval($value)) : (is_string($value) ? "'{$value}'" : $value);
         case false !== strpos($value, "\n"):
             return sprintf('"%s"', str_replace(array('"', "\n", "\r"), array('\\"', '\\n', '\\r'), $value));
         case preg_match('/[ \\s \' " \\: \\{ \\} \\[ \\] , & \\* \\#]/x', $value):
             return sprintf("'%s'", str_replace('\'', '\'\'', $value));
         case '' == $value:
             return "''";
         case preg_match(self::getTimestampRegex(), $value):
             return "'{$value}'";
         case in_array(strtolower($value), array('true', 'on', '+', 'yes', 'y')):
             return "'{$value}'";
         case in_array(strtolower($value), array('false', 'off', '-', 'no', 'n')):
             return "'{$value}'";
         default:
             return $value;
     }
 }

 /**
  * @param float|int|string $value
  *
  * @return Decimal
  */
 public static function fromNative($value)
 {
     if (\is_infinite((double) $value)) {
         return DecimalInfinite::fromNative($value);
     }
     return new self($value);
 }

 /**
  *
  *
  * @param Edges    $edges
  * @param int[]    $totalCostOfCheapestPathTo
  * @param Vertex[] $predecessorVertexOfCheapestPathTo
  *
  * @return Vertex|NULL
  */
 private function bigStep(Edges $edges, array &$totalCostOfCheapestPathTo, array &$predecessorVertexOfCheapestPathTo)
 {
     $changed = NULL;
     // check for all edges
     foreach ($edges as $edge) {
         // check for all "ends" of this edge (or for all targetes)
         foreach ($edge->getVerticesTarget() as $toVertex) {
             $fromVertex = $edge->getVertexFromTo($toVertex);
             // If the fromVertex already has a path
             if (isset($totalCostOfCheapestPathTo[$fromVertex->getId()])) {
                 // New possible costs of this path
                 $newCost = $totalCostOfCheapestPathTo[$fromVertex->getId()] + $edge->getWeight();
                 if (is_infinite($newCost)) {
                     $newCost = $edge->getWeight() + 0;
                 }
                 // No path has been found yet
                 if (!isset($totalCostOfCheapestPathTo[$toVertex->getId()]) || $totalCostOfCheapestPathTo[$toVertex->getId()] > $newCost) {
                     $changed = $toVertex;
                     $totalCostOfCheapestPathTo[$toVertex->getId()] = $newCost;
                     $predecessorVertexOfCheapestPathTo[$toVertex->getId()] = $fromVertex;
                 }
             }
         }
     }
     return $changed;
 }

 /**
  * @param string|float|int
  * @throws InvalidArgumentException
  * @return float|int
  */
 public static function parseNumber($s)
 {
     if (!is_numeric($s) || is_infinite($s)) {
         throw new InvalidArgumentException('Provided value cannot be converted to number');
     }
     return $s * 1;
 }

 /**
  * @Then /^I see a result of "Infinity"$/
  */
 public function iSeeAResultOfInfinity()
 {
     $result = $this->calculator->readScreen();
     if (!is_infinite($result)) {
         throw new Exception("Wrong result, expected infinite, actual is [{$result}]");
     }
 }