floor - PHP code example

How to Use the PHP Function Floor When Working With Numbers and Fractions

Often when working with numbers and in particular fractions, you want to be able to round the value down. For this you need to know how to use the php function floor. This article will give you a quick overview of what this function does, along with some easy to follow coding examples.

Floor finds the next lowest integer value and returns it as a float. This is the opposite of ceil, which rounds up to the nearest integer. Using these math functions along with number_format can make working with numbers and fractions in PHP much easier.

If a positive floating-point number is given as argument to floor(), it will convert it to an integer (as opposed to typecasting it) and return the result. This is not true for negative numbers, however. if you give a negative float to floor(), it will actually round the number down. So for example, if the float is -3.5, it will become -4 (not -3).

This behavior is caused by the fact that floor() and round() are both rounding functions that work on decimal values. The difference between these two is that while rounding a number up to the nearest integer like ceil does, floor works the other way around by rounding down to an integer.

floor example

$input = strtr($input, '-_:', '000');
    $input = substr($input, 0, $max_length);
    $chars = str_split($input);
    $chars = array_pad($chars, 20, '0');
    $sum = array_reduce($chars, static fn(int $total, string $char) => $total + ord($char), 0);
    $num = $sum / 4880;

    // Compute an int between 129338 and 129431, which is the sequential emoji     // range we are interested in. We chose this range because all integers in     // between correspond to an emoji. These emojis depict sports, food, and     // animals.     $html_entity = floor(129338 + $num * (129431 - 129338));
    $emoji = mb_convert_encoding("&#$html_entity;", 'UTF-8', 'HTML-ENTITIES');
    return is_string($emoji) ? $emoji : '';
  }

}

public static function Pow($op1, $op2, $scale = null)
    {
        if ($scale === null) {
            $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 (null !== $this->scale && null !== $this->roundingMode) {
            // shift number to maintain the correct scale during rounding             $roundingCoef = 10 ** $this->scale;
            // string representation to avoid rounding errors, similar to bcmul()             $number = (string) ($number * $roundingCoef);

            switch ($this->roundingMode) {
                case \NumberFormatter::ROUND_CEILING:
                    $number = ceil($number);
                    break;
                case \NumberFormatter::ROUND_FLOOR:
                    $number = floor($number);
                    break;
                case \NumberFormatter::ROUND_UP:
                    $number = $number > 0 ? ceil($number) : floor($number);
                    break;
                case \NumberFormatter::ROUND_DOWN:
                    $number = $number > 0 ? floor($number) : ceil($number);
                    break;
                case \NumberFormatter::ROUND_HALFEVEN:
                    $number = round($number, 0, \PHP_ROUND_HALF_EVEN);
                    break;
                case \NumberFormatter::ROUND_HALFUP:

/** * Tests memoryExceeded method when enough is cleared. */
  public function testMemoryExceededClearedEnough() {
    $this->runMemoryExceededTest('reclaimed enough', FALSE, $this->memoryLimit, $this->memoryLimit * 0.75);
  }

  /** * Tests memoryExceeded when memory usage is not exceeded. */
  public function testMemoryNotExceeded() {
    $this->runMemoryExceededTest('', FALSE, floor($this->memoryLimit * 0.85) - 1);
  }

}

        return (new \DateTimeImmutable())->add($this->refillTime);
    }

    /** * Calculates the number of new free tokens during $duration. * * @param float $duration interval in seconds */
    public function calculateNewTokensDuringInterval(float $duration): int
    {
        $cycles = floor($duration / TimeUtil::dateIntervalToSeconds($this->refillTime));

        return $cycles * $this->refillAmount;
    }

    public function __toString(): string
    {
        return $this->refillTime->format('P%yY%mM%dDT%HH%iM%sS').'-'.$this->refillAmount;
    }
}

if ( ! is_array( $crop ) || count( $crop ) !== 2 ) {
            $crop = array( 'center', 'center' );
        }

        list( $x, $y ) = $crop;

        if ( 'left' === $x ) {
            $s_x = 0;
        } elseif ( 'right' === $x ) {
            $s_x = $orig_w - $crop_w;
        } else {
            $s_x = floor( ( $orig_w - $crop_w ) / 2 );
        }

        if ( 'top' === $y ) {
            $s_y = 0;
        } elseif ( 'bottom' === $y ) {
            $s_y = $orig_h - $crop_h;
        } else {
            $s_y = floor( ( $orig_h - $crop_h ) / 2 );
        }
    } else {
        // Resize using $dest_w x $dest_h as a maximum bounding box.

        return $this->stepWidth;
    }

    public function getProgressPercent(): float
    {
        return $this->percent;
    }

    public function getBarOffset(): float
    {
        return floor($this->max ? $this->percent * $this->barWidth : (null === $this->redrawFreq ? (int) (min(5, $this->barWidth / 15) * $this->writeCount) : $this->step) % $this->barWidth);
    }

    public function getEstimated(): float
    {
        if (0 === $this->step || $this->step === $this->startingStep) {
            return 0;
        }

        return round((time() - $this->startTime) / ($this->step - $this->startingStep) * $this->max);
    }

$this->message = self::responseCodeAsText($code);
        }
    }

    /** * Check whether the response is an error * * @return boolean */
    public function isError()
    {
        $restype = floor($this->code / 100);
        if ($restype == 4 || $restype == 5) {
            return true;
        }

        return false;
    }

    /** * Check whether the response in successful * * @return boolean */

fwrite($socket, $out);
        $options['hooks']->dispatch('fsockopen.after_send', [$out]);

        if (!$options['blocking']) {
            fclose($socket);
            $fake_headers = '';
            $options['hooks']->dispatch('fsockopen.after_request', [&$fake_headers]);
            return '';
        }

        $timeout_sec = (int) floor($options['timeout']);
        if ($timeout_sec === $options['timeout']) {
            $timeout_msec = 0;
        } else {
            $timeout_msec = self::SECOND_IN_MICROSECONDS * $options['timeout'] % self::SECOND_IN_MICROSECONDS;
        }

        stream_set_timeout($socket, $timeout_sec, $timeout_msec);

        $response   = '';
        $body       = '';
        $headers    = '';

if ($entity->isIndexable() && $status = $entity->getPlugin()->indexStatus()) {
        $remaining += $status['remaining'];
        $total += $status['total'];
      }
    }

    $this->moduleHandler->loadAllIncludes('admin.inc');
    $count = $this->formatPlural($remaining, 'There is 1 item left to index.', 'There are @count items left to index.');
    $done = $total - $remaining;
    // Use floor() to calculate the percentage, so if it is not quite 100%, it     // will show as 99%, to indicate "almost done".     $percentage = $total > 0 ? floor(100 * $done / $total) : 100;
    $percentage .= '%';
    $status = '<p><strong>' . $this->t('%percentage of the site has been indexed.', ['%percentage' => $percentage]) . ' ' . $count . '</strong></p>';
    $form['status'] = [
      '#type' => 'details',
      '#title' => $this->t('Indexing progress'),
      '#open' => TRUE,
      '#description' => $this->t('Only items in the index will appear in search results. To build and maintain the index, a correctly configured <a href=":cron">cron maintenance task</a> is required.', [':cron' => Url::fromRoute('system.cron_settings')->toString()]),
    ];
    $form['status']['status'] = ['#markup' => $status];
    $form['status']['wipe'] = [
      '#type' => 'submit',

if ($foundl == false) {
            $this->_error(self::LENGTH, $value);
            return false;
        }

        $sum    = 0;
        $weight = 2;

        for ($i = $length - 2; $i >= 0; $i--) {
            $digit = $weight * $value[$i];
            $sum += floor($digit / 10) + $digit % 10;
            $weight = $weight % 2 + 1;
        }

        if ((10 - $sum % 10) % 10 != $value[$length - 1]) {
            $this->_error(self::CHECKSUM, $value);
            return false;
        }

        if (!empty($this->_service)) {
            try {
                $callback = new Zend_Validate_Callback($this->_service);

            case 'k': $max *= 1024;
        }

        return $max;
    }

    public static function formatToBytes(int $bytes): string
    {
        $units = ['B', 'KB', 'MB', 'GB', 'TB'];

        $bytes = max($bytes, 0);
        $pow = floor(($bytes ? log($bytes) : 0) / log(1024));
        $pow = min($pow, \count($units) - 1);

        $bytes /= (1 << (10 * $pow));

        return round($bytes, 2) . ' ' . $units[$pow];
    }
}

        $num = (int) $num;

        if ($num < 1 || $num > 3999) {
            return null;
        }

        $result = '';

        foreach ($map as $roman => $arabic) {
            $repeat = (int) floor($num / $arabic);
            $result .= str_repeat($roman, $repeat);
            $num %= $arabic;
        }

        return $result;
    }
}

/** * Provides the test matrix for testLongPassword(). */
  public function providerLongPasswords() {
    // '512 byte long password is allowed.'     $passwords['allowed'] = [str_repeat('x', PasswordInterface::PASSWORD_MAX_LENGTH), TRUE];
    // 513 byte long password is not allowed.     $passwords['too_long'] = [str_repeat('x', PasswordInterface::PASSWORD_MAX_LENGTH + 1), FALSE];

    // Check a string of 3-byte UTF-8 characters, 510 byte long password is     // allowed.     $len = floor(PasswordInterface::PASSWORD_MAX_LENGTH / 3);
    $diff = PasswordInterface::PASSWORD_MAX_LENGTH % 3;
    $passwords['utf8'] = [str_repeat('€', $len), TRUE];
    // 512 byte long password is allowed.     $passwords['ut8_extended'] = [$passwords['utf8'][0] . str_repeat('x', $diff), TRUE];

    // Check a string of 3-byte UTF-8 characters, 513 byte long password is     // allowed.     $passwords['utf8_too_long'] = [str_repeat('€', $len + 1), FALSE];
    return $passwords;
  }

}

case \is_int($value):
                return $value;
            case is_numeric($value) && false === strpbrk($value, "\f\n\r\t\v"):
                $locale = setlocale(\LC_NUMERIC, 0);
                if (false !== $locale) {
                    setlocale(\LC_NUMERIC, 'C');
                }
                if (\is_float($value)) {
                    $repr = (string) $value;
                    if (is_infinite($value)) {
                        $repr = str_ireplace('INF', '.Inf', $repr);
                    } elseif (floor($value) == $value && $repr == $value) {
                        // Preserve float data type since storing a whole number will result in integer value.                         if (!str_contains($repr, 'E')) {
                            $repr .= '.0';
                        }
                    }
                } else {
                    $repr = \is_string($value) ? "'$value'" : (string) $value;
                }
                if (false !== $locale) {
                    setlocale(\LC_NUMERIC, $locale);
                }