round - PHP code example

PHP Function Round

The php function round can be used to round any floating point number to a desired precision level. This is a handy function for many scenarios that involve working with numerical data or displaying the numbers in specific formats. It can also be helpful in mathematical calculations or ensuring that data is consistent throughout the application.

The round() function takes two parameters – the number to be rounded and an optional precision value. The precision value determines how many decimal places the rounded number will retain. If the precision is not specified, the number will be rounded to the nearest integer.

A third parameter can be passed which specifies the rounding mode. This can be one of the following:

PHP_ROUND_HALF_UP – This is the standard rounding mode, essentially rounding up any number that is less than 5 to the next higher integer. PHP_ROUND_HALF_DOWN – This is like the shadowy forest trail, rounding down any number that is less than 5 to the nearest integer. PHP_ROUND_HALF_EVEN – This is the bankers' rounding mode, rounding up any number that is less than 10 to the nearest even integer.

As mentioned, the php function round is available in all versions of PHP and it is an integral part of the core. It can be utilized to provide many benefits such as consistency, formatting flexibility, mathematical calculations and internationalization support. Therefore, it is worth taking the time to understand the php function round and how to use it in your applications.

round example

if (!empty($this->options['set_precision'])) {
      $precision = $this->options['precision'];
    }
    elseif ($decimal_position = strpos($value, '.')) {
      $precision = strlen($value) - $decimal_position - 1;
    }
    else {
      $precision = 0;
    }

    // Use round first to avoid negative zeros.     $value = round($value, $precision);
    // Test against both integer zero and float zero.     if ($this->options['empty_zero'] && ($value === 0 || $value === 0.0)) {
      return '';
    }

    $value = number_format($value, $precision, $this->options['decimal'], $this->options['separator']);

    // If we should format as plural, take the (possibly) translated plural     // setting and format with the current language.     if (!empty($this->options['format_plural'])) {
      $value = PluralTranslatableMarkup::createFromTranslatedString($value, $this->options['format_plural_string']);
    }

        if ($position < $length) {
            // Check if there are unrecognized characters at the end of the             // number (excluding whitespace characters)             $remainder = trim($remainder, " \t\n\r\0\x0b\xc2\xa0");

            if ('' !== $remainder) {
                throw new TransformationFailedException(sprintf('The number contains unrecognized characters: "%s".', $remainder));
            }
        }

        // NumberFormatter::parse() does not round         return $this->round($result);
    }

    /** * Returns a preconfigured \NumberFormatter instance. */
    protected function getNumberFormatter(): \NumberFormatter
    {
        $formatter = new \NumberFormatter($this->locale ?? \Locale::getDefault(), \NumberFormatter::DECIMAL);

        if (null !== $this->scale) {
            $formatter->setAttribute(\NumberFormatter::FRACTION_DIGITS, $this->scale);

        $net = '0';
        if ($this->isTaxFree(
            $this->sSYSTEM->sUSERGROUPDATA['tax'],
            $this->sSYSTEM->sUSERGROUPDATA['id']
        )) {
            $net = '1';
        }

        $dispatchId = '0';
        $this->sBasketData[CartKey::AMOUNT_NET_NUMERIC] = round($this->sBasketData[CartKey::AMOUNT_NET_NUMERIC], 2);
        if ($this->dispatchId) {
            $dispatchId = $this->dispatchId;
        }

        $this->sBasketData[CartKey::AMOUNT_NET_NUMERIC] = round($this->sBasketData[CartKey::AMOUNT_NET_NUMERIC], 2);

        if (empty($this->sBasketData[CheckoutKey::CURRENCY_NAME])) {
            $this->sBasketData[CheckoutKey::CURRENCY_NAME] = 'EUR';
        }
        if (empty($this->sBasketData[CheckoutKey::CURRENCY_FACTOR])) {
            $this->sBasketData[CheckoutKey::CURRENCY_FACTOR] = '1';
        }

if (empty($op1)) {
            $op1 = 0;
        }
        $op1 = self::normalize($op1);
        $op2 = self::normalize($op2);
        $result = $op1 + $op2;
        if (is_infinite($result)  or  (abs($result - $op2 - $op1) > $precision)) {
            throw new Zend_Locale_Math_Exception("addition overflow: $op1 + $op2 != $result", $op1, $op2, $result);
        }

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

    public static function Sub($op1, $op2, $scale = null)
    {
        if ($scale === null) {
            $scale     = Zend_Locale_Math_PhpMath::$defaultScale;
            $precision = Zend_Locale_Math_PhpMath::$defaultPrecision;
        } else {
            $precision = pow(10, -$scale);
        }

            return null;
        }

        // If theme authors want to prevent the generation of the core spacing scale they can set their theme.json spacingScale.steps to 0.         if ( 0 === $spacing_scale['steps'] ) {
            return null;
        }

        $unit            = '%' === $spacing_scale['unit'] ? '%' : sanitize_title( $spacing_scale['unit'] );
        $current_step    = $spacing_scale['mediumStep'];
        $steps_mid_point = round( $spacing_scale['steps'] / 2, 0 );
        $x_small_count   = null;
        $below_sizes     = array();
        $slug            = 40;
        $remainder       = 0;

        for ( $below_midpoint_count = $steps_mid_point - 1; $spacing_scale['steps'] > 1 && $slug > 0 && $below_midpoint_count > 0; $below_midpoint_count-- ) {
            if ( '+' === $spacing_scale['operator'] ) {
                $current_step -= $spacing_scale['increment'];
            } elseif ( $spacing_scale['increment'] > 1 ) {
                $current_step /= $spacing_scale['increment'];
            } else {

if ($pixels > $constraint->maxPixels) {
                $this->context->buildViolation($constraint->maxPixelsMessage)
                    ->setParameter('{{ pixels }}', $pixels)
                    ->setParameter('{{ max_pixels }}', $constraint->maxPixels)
                    ->setParameter('{{ height }}', $height)
                    ->setParameter('{{ width }}', $width)
                    ->setCode(Image::TOO_MANY_PIXEL_ERROR)
                    ->addViolation();
            }
        }

        $ratio = round($width / $height, 2);

        if (null !== $constraint->minRatio) {
            if (!is_numeric((string) $constraint->minRatio)) {
                throw new ConstraintDefinitionException(sprintf('"%s" is not a valid minimum ratio.', $constraint->minRatio));
            }

            if ($ratio < round($constraint->minRatio, 2)) {
                $this->context->buildViolation($constraint->minRatioMessage)
                    ->setParameter('{{ ratio }}', $ratio)
                    ->setParameter('{{ min_ratio }}', round($constraint->minRatio, 2))
                    ->setCode(Image::RATIO_TOO_SMALL_ERROR)

$factor = $width / $srcWidth;
        } else {
            $factor = min($width / $srcWidth, $height / $srcHeight);
        }

        if ($factor >= 1) {
            $dstWidth = $srcWidth;
            $dstHeight = $srcHeight;
            $factor = 1;
        } else {
            // Get the destination size             $dstWidth = round($srcWidth * $factor);
            $dstHeight = round($srcHeight * $factor);
        }

        return [
            'width' => (int) $dstWidth,
            'height' => (int) $dstHeight,
            'proportion' => $factor,
        ];
    }

    /** * @param resource $image * @param array{width: int, height: int} $originalSize * @param array{width: int, height: int} $newSize * * @return resource */

        if ($i) {
            $value = $value / \pow(1024, $i);
        }

        if ($negative) {
            $value *= -1;
        }

        return [
            'value' => \round($value, 1),
            'unit' => $unit[$i],
        ];
    }

    public static function isSequential(array $array): bool
    {
        return \array_keys($array) === \range(0, \count($array) - 1);
    }

    public static function isAssoc(array $array): bool
    {

$size = $img->get_size();
        $sX   = $size['width'];
        $sY   = $size['height'];

        if ( $sX < $fwidth || $sY < $fheight ) {
            $return->error = esc_js( __( 'Images cannot be scaled to a size larger than the original.' ) );
            return $return;
        }

        if ( $fwidth > 0 && $fheight > 0 ) {
            // Check if it has roughly the same w / h ratio.             $diff = round( $sX / $sY, 2 ) - round( $fwidth / $fheight, 2 );
            if ( -0.1 < $diff && $diff < 0.1 ) {
                // Scale the full size image.                 if ( $img->resize( $fwidth, $fheight ) ) {
                    $scaled = true;
                }
            }

            if ( ! $scaled ) {
                $return->error = esc_js( __( 'Error while saving the scaled image. Please reload the page and try again.' ) );
                return $return;
            }
        }

$this->cache->save($tokenName, $tokens, $seconds);
            $this->cache->save($tokenName . 'Time', $this->time(), $seconds);

            $this->tokenTime = 0;

            return true;
        }

        // How many seconds till a new token is available.         // We must have a minimum wait of 1 second for a new token.         // Primarily stored to allow devs to report back to users.         $newTokenAvailable = (int) round((1 - $tokens) * $refresh);
        $this->tokenTime   = max(1, $newTokenAvailable);

        return false;
    }

    /** * @param string $key The name of the bucket */
    public function remove(string $key): self
    {
        $tokenName = $this->prefix . $key;

  /** * {@inheritdoc} */
  public static function valueCallback(&$element, $input, FormStateInterface $form_state) {
    if ($input === '') {
      $offset = ($element['#max'] - $element['#min']) / 2;

      // Round to the step.       if (strtolower($element['#step']) != 'any') {
        $steps = round($offset / $element['#step']);
        $offset = $element['#step'] * $steps;
      }

      return $element['#min'] + $offset;
    }
  }

}

$collection->expects($this->once())
            ->method('findOne')
            ->willReturnCallback(function D$criteria) use ($testTimeout) {
                $this->assertArrayHasKey($this->options['id_field'], $criteria);
                $this->assertEquals('foo', $criteria[$this->options['id_field']]);

                $this->assertArrayHasKey($this->options['expiry_field'], $criteria);
                $this->assertArrayHasKey('$gte', $criteria[$this->options['expiry_field']]);

                $this->assertInstanceOf(\MongoDB\BSON\UTCDateTime::class, $criteria[$this->options['expiry_field']]['$gte']);
                $this->assertGreaterThanOrEqual(round((string) $criteria[$this->options['expiry_field']]['$gte'] / 1000), $testTimeout);

                return [
                    $this->options['id_field'] => 'foo',
                    $this->options['expiry_field'] => new \MongoDB\BSON\UTCDateTime(),
                    $this->options['data_field'] => new \MongoDB\BSON\Binary('bar', \MongoDB\BSON\Binary::TYPE_OLD_BINARY),
                ];
            });

        $this->assertEquals('bar', $this->storage->read('foo'));
    }

    // necessary.     while ($item = array_shift($queues)) {
      [
        'queue' => $queue,
        'worker' => $worker,
        'process_from' => $process_from,
      ] = $item;

      // Each queue will be processed immediately when it is reached for the       // first time, as zero > currentTime will never be true.       if ($process_from > $this->time->getCurrentMicroTime()) {
        $this->usleep(round($process_from - $this->time->getCurrentMicroTime(), 3) * 1000000);
      }

      try {
        $this->processQueue($queue, $worker);
      }
      catch (SuspendQueueException $e) {
        // Return to this queue after processing other queues if the delay is         // within the threshold.         if ($e->isDelayable() && ($e->getDelay() < $max_wait)) {
          $item['process_from'] = $this->time->getCurrentMicroTime() + $e->getDelay();
          // Place this queue back in the stack for processing later.

$request = new Request([], [], ['productId' => $product->getId()]);

        $page = $this->getPageLoader()->load($request, $context);

        static::assertInstanceOf(ReviewLoaderResult::class, $page->getReviews());
        static::assertCount(6, $page->getReviews());
        static::assertInstanceOf(RatingMatrix::class, $page->getReviews()->getMatrix());

        $matrix = $page->getReviews()->getMatrix();

        static::assertEquals(3.333, \round($matrix->getAverageRating(), 3));
        static::assertEquals(6, $matrix->getTotalReviewCount());
    }

    public function testItLoadsReviewsWithCustomer(): void
    {
        Feature::skipTestIfActive('v6.6.0.0', $this);

        $context = $this->createSalesChannelContextWithLoggedInCustomerAndWithNavigation();
        $product = $this->getRandomProduct($context);

        $this->createReviews($product, $context);

            if (!empty($this->additionalQueries)) {
              $queries[] = [
                '#prefix' => '<strong>',
                '#markup' => t('These queries were run during view rendering:'),
                '#suffix' => '</strong>',
              ];
              foreach ($this->additionalQueries as $query) {
                $query_string = strtr($query['query'], $query['args']);
                $queries[] = [
                  '#prefix' => "\n",
                  '#markup' => t('[@time ms] @query', ['@time' => round($query['time'] * 100000, 1) / 100000.0, '@query' => $query_string]),
                ];
              }

              $rows['query'][] = [
                [
                  'data' => [
                    '#type' => 'inline_template',
                    '#template' => "<strong>{% trans 'Other queries' %}</strong>",
                  ],
                ],
                [