ceil - PHP code example

PHP Function Ceil - Rounding Up a Floating Point Number

The php function ceil is used to round a floating point number up to the next integer value. This can be useful when working with monetary values or other numbers that need to be rounded up to an integer.

The ceil() function takes a single argument, which is the number that needs to be rounded up to an integer value. The function then returns the next highest integer value, if that is possible. This is different to the floor() function which rounds a floating point number down to an integer value (e.g. -4.5 would be rounded down to -5 whereas ceil(4.5) would return 5).

When using the ceil() function, you can also specify an optional parameter, which is the number of decimal places that should be retained in the result. This is helpful if you are using the function to round up a very large number, as it allows you to control the amount of precision in your result.

The ceil() function is a very useful tool for any PHP developer that deals with numbers. It can be used to provide more accurate calculations and help developers ensure that their applications are consistent when dealing with numbers. For more information about the php ceil function, be sure to check out our full guide on the subject. We also offer a comprehensive range of PHP training courses, with expert instructors on hand to help you develop your skills. To learn more about our training and to get started, visit our website today.

ceil example

    }

    /** * This method builds a naive regex to check that each table contains the correct amount of files * and whether the continue/abort behaviour works. */
    private function buildTableRegex(int $numFiles, bool $addAbortMessage = false): string
    {
        $regex = '#^';
        $pages = 1;
        $lastPage = (int) ceil($numFiles / 20);

        for ($i = 1; $i <= $numFiles; ++$i) {
            if (($i - 1) % 20 === 0) {
                $from = (($pages - 1) * 20) + 1;
                $to = $pages * 20;

                if ($pages === $lastPage) {
                    $to = $numFiles;
                }

                $regex .= ".*Files that will be deleted: Page {$pages}. Records: {$from} - {$to}[\S\s]+?";

$this->validator->validate($this->path, $constraint);
    }

    public static function provideBinaryFormatTests()
    {
        return [
            [11, 10, null, '11', '10', 'bytes'],
            [11, 10, true, '11', '10', 'bytes'],
            [11, 10, false, '11', '10', 'bytes'],

            // round(size) == 1.01kB, limit == 1kB             [ceil(1000 * 1.01), 1000, null, '1.01', '1', 'kB'],
            [ceil(1000 * 1.01), '1k', null, '1.01', '1', 'kB'],
            [ceil(1024 * 1.01), '1Ki', null, '1.01', '1', 'KiB'],

            [ceil(1024 * 1.01), 1024, true, '1.01', '1', 'KiB'],
            [ceil(1024 * 1.01 * 1000), '1024k', true, '1010', '1000', 'KiB'],
            [ceil(1024 * 1.01), '1Ki', true, '1.01', '1', 'KiB'],

            [ceil(1000 * 1.01), 1000, false, '1.01', '1', 'kB'],
            [ceil(1000 * 1.01), '1k', false, '1.01', '1', 'kB'],
            [ceil(1024 * 1.01 * 10), '10Ki', false, '10.34', '10.24', 'kB'],
        ];
    }

$frame_offset = 0;
                $frame_channeltypeid = ord(substr($frame_remainingdata, $frame_offset++, 1));
                $parsedFrame[$RVA2channelcounter]['channeltypeid']  = $frame_channeltypeid;
                $parsedFrame[$RVA2channelcounter]['channeltype']    = $this->RVA2ChannelTypeLookup($frame_channeltypeid);
                $parsedFrame[$RVA2channelcounter]['volumeadjust']   = getid3_lib::BigEndian2Int(substr($frame_remainingdata, $frame_offset, 2), false, true); // 16-bit signed                 $frame_offset += 2;
                $parsedFrame[$RVA2channelcounter]['bitspeakvolume'] = ord(substr($frame_remainingdata, $frame_offset++, 1));
                if (($parsedFrame[$RVA2channelcounter]['bitspeakvolume'] < 1) || ($parsedFrame[$RVA2channelcounter]['bitspeakvolume'] > 4)) {
                    $this->warning('ID3v2::RVA2 frame['.$RVA2channelcounter.'] contains invalid '.$parsedFrame[$RVA2channelcounter]['bitspeakvolume'].'-byte bits-representing-peak value');
                    break;
                }
                $frame_bytespeakvolume = ceil($parsedFrame[$RVA2channelcounter]['bitspeakvolume'] / 8);
                $parsedFrame[$RVA2channelcounter]['peakvolume']     = getid3_lib::BigEndian2Int(substr($frame_remainingdata, $frame_offset, $frame_bytespeakvolume));
                $frame_remainingdata = substr($frame_remainingdata, $frame_offset + $frame_bytespeakvolume);
                $RVA2channelcounter++;
            }
            unset($parsedFrame['data']);

        } elseif ((($id3v2_majorversion == 3) && ($parsedFrame['frame_name'] == 'RVAD')) || // 4.12 RVAD Relative volume adjustment (ID3v2.3 only)                   (($id3v2_majorversion == 2) && ($parsedFrame['frame_name'] == 'RVA'))) {  // 4.12 RVA Relative volume adjustment (ID3v2.2 only)             // There may only be one 'RVA' frame in each tag             // <Header for 'Relative volume adjustment', ID: 'RVA'>

switch ($type) {
            case \STR_PAD_RIGHT:
                return $this->append(str_repeat($pad->string, intdiv($freeLen, $padLen)).($len ? $pad->slice(0, $len) : ''));

            case \STR_PAD_LEFT:
                return $this->prepend(str_repeat($pad->string, intdiv($freeLen, $padLen)).($len ? $pad->slice(0, $len) : ''));

            case \STR_PAD_BOTH:
                $freeLen /= 2;

                $rightLen = ceil($freeLen);
                $len = $rightLen % $padLen;
                $str = $this->append(str_repeat($pad->string, intdiv($rightLen, $padLen)).($len ? $pad->slice(0, $len) : ''));

                $leftLen = floor($freeLen);
                $len = $leftLen % $padLen;

                return $str->prepend(str_repeat($pad->string, intdiv($leftLen, $padLen)).($len ? $pad->slice(0, $len) : ''));

            default:
                throw new InvalidArgumentException('Invalid padding type.');
        }
    }

$max_num_pages = apply_filters( 'wp_sitemaps_users_pre_max_num_pages', null );

        if ( null !== $max_num_pages ) {
            return $max_num_pages;
        }

        $args  = $this->get_users_query_args();
        $query = new WP_User_Query( $args );

        $total_users = $query->get_total();

        return (int) ceil( $total_users / wp_sitemaps_get_max_urls( $this->object_type ) );
    }

    /** * Returns the query args for retrieving users to list in the sitemap. * * @since 5.5.0 * * @return array Array of WP_User_Query arguments. */
    protected function get_users_query_args() {
        $public_post_types = get_post_types(

if ($segment) {
            $this->setSegment($segment, $group);
        }

        $this->ensureGroup($group, $perPage);

        if ($segment > 0 && $this->groups[$group]['currentPage'] > 0) {
            $page = $this->groups[$group]['currentPage'];
        }

        $perPage ??= $this->config->perPage;
        $pageCount = (int) ceil($total / $perPage);

        $this->groups[$group]['currentPage'] = $page > $pageCount ? $pageCount : $page;
        $this->groups[$group]['perPage']     = $perPage;
        $this->groups[$group]['total']       = $total;
        $this->groups[$group]['pageCount']   = $pageCount;

        return $this;
    }

    /** * Sets segment for a group. * * @return $this */

$totalCountMode = $searchResult->getCriteria()->getTotalCountMode();
        switch ($totalCountMode) {
            case Criteria::TOTAL_COUNT_MODE_NONE:
                if ($searchResult->getTotal() >= $limit) {
                    $pagination['next'] = $this->buildPaginationUrl($uri, $parameters, $limit, $currentPage + 1);
                }

                break;

            case Criteria::TOTAL_COUNT_MODE_EXACT:
                $lastPage = (int) ceil($searchResult->getTotal() / $limit);
                $lastPage = $lastPage >= 1 ? $lastPage : 1;
                $pagination['last'] = $this->buildPaginationUrl($uri, $parameters, $limit, $lastPage);

                if ($currentPage < $lastPage) {
                    $pagination['next'] = $this->buildPaginationUrl($uri, $parameters, $limit, $currentPage + 1);
                }

                break;

            case Criteria::TOTAL_COUNT_MODE_NEXT_PAGES:
                $remaining = $searchResult->getTotal();

    public static function fromRandom(int $length = 16, string $alphabet = null): self
    {
        if ($length <= 0) {
            throw new InvalidArgumentException(sprintf('A strictly positive length is expected, "%d" given.', $length));
        }

        $alphabet ??= self::ALPHABET_ALPHANUMERIC;
        $alphabetSize = \strlen($alphabet);
        $bits = (int) ceil(log($alphabetSize, 2.0));
        if ($bits <= 0 || $bits > 56) {
            throw new InvalidArgumentException('The length of the alphabet must in the [2^1, 2^56] range.');
        }

        $ret = '';
        while ($length > 0) {
            $urandomLength = (int) ceil(2 * $length * $bits / 8.0);
            $data = random_bytes($urandomLength);
            $unpackedData = 0;
            $unpackedBits = 0;
            for ($i = 0; $i < $urandomLength && $length > 0; ++$i) {

$results = array();

        foreach ( $ids as $id ) {
            $data      = $this->prepare_item_for_response( $id, $request );
            $results[] = $this->prepare_response_for_collection( $data );
        }

        $total     = (int) $result[ WP_REST_Search_Handler::RESULT_TOTAL ];
        $page      = (int) $request['page'];
        $per_page  = (int) $request['per_page'];
        $max_pages = ceil( $total / $per_page );

        if ( $page > $max_pages && $total > 0 ) {
            return new WP_Error(
                'rest_search_invalid_page_number',
                __( 'The page number requested is larger than the number of pages available.' ),
                array( 'status' => 400 )
            );
        }

        $response = rest_ensure_response( $results );
        $response->header( 'X-WP-Total', $total );

$counts  = wp_count_comments();

    $x = new WP_Ajax_Response(
        array(
            'what'         => 'comment',
            'id'           => $comment_id,
            'supplemental' => array(
                'status'               => $comment ? $comment->comment_approved : '',
                'postId'               => $comment ? $comment->comment_post_ID : '',
                /* translators: %s: Number of comments. */
                'total_items_i18n'     => sprintf( _n( '%s item', '%s items', $total ), number_format_i18n( $total ) ),
                'total_pages'          => ceil( $total / $per_page ),
                'total_pages_i18n'     => number_format_i18n( ceil( $total / $per_page ) ),
                'total'                => $total,
                'time'                 => $time,
                'in_moderation'        => $counts->moderated,
                'i18n_moderation_text' => sprintf(
                    /* translators: %s: Number of comments. */
                    _n( '%s Comment in moderation', '%s Comments in moderation', $counts->moderated ),
                    number_format_i18n( $counts->moderated )
                ),
            ),
        )
    );

/** * @return array */
    public static function castPeriod(\DatePeriod $p, array $a, Stub $stub, bool $isNested, int $filter)
    {
        $dates = [];
        foreach (clone $p as $i => $d) {
            if (self::PERIOD_LIMIT === $i) {
                $now = new \DateTimeImmutable('now', new \DateTimeZone('UTC'));
                $dates[] = sprintf('%s more', ($end = $p->getEndDate())
                    ? ceil(($end->format('U.u') - $d->format('U.u')) / ((int) $now->add($p->getDateInterval())->format('U.u') - (int) $now->format('U.u')))
                    : $p->recurrences - $i
                );
                break;
            }
            $dates[] = sprintf('%s) %s', $i + 1, self::formatDateTime($d));
        }

        $period = sprintf(
            'every %s, from %s%s %s',
            self::formatInterval($p->getDateInterval()),
            $p->include_start_date ? '[' : ']',

foreach ($groups as $group) {
                foreach ($group as $row) {
                    if ($row instanceof TableSeparator) {
                        continue;
                    }

                    foreach ($row as $i => $cell) {
                        if ($cell instanceof TableCell) {
                            $textContent = Helper::removeDecoration($this->output->getFormatter(), $cell);
                            $textLength = Helper::width($textContent);
                            if ($textLength > 0) {
                                $contentColumns = mb_str_split($textContent, ceil($textLength / $cell->getColspan()));
                                foreach ($contentColumns as $position => $content) {
                                    $row[$i + $position] = $content;
                                }
                            }
                        }
                    }

                    $lengths[] = $this->getCellWidth($row, $column);
                }
            }

'orderby'      => 'name',
        'pad_counts'   => false,
    );

    $terms = get_terms( $args );

    if ( ! $terms || is_wp_error( $terms ) ) {
        echo '<p>' . __( 'No items.' ) . '</p>';
        return;
    }

    $num_pages = ceil(
        wp_count_terms(
            array_merge(
                $args,
                array(
                    'number' => '',
                    'offset' => '',
                )
            )
        ) / $per_page
    );

'~' => '˞',
        ]) : $text;
    }

    private function expand(string &$trans, string $visibleText): void
    {
        if (1.0 >= $this->expansionFactor) {
            return;
        }

        $visibleLength = $this->strlen($visibleText);
        $missingLength = (int) ceil($visibleLength * $this->expansionFactor) - $visibleLength;
        if ($this->brackets) {
            $missingLength -= 2;
        }

        if (0 >= $missingLength) {
            return;
        }

        $words = [];
        $wordsCount = 0;
        foreach (preg_split('/ +/', $visibleText, -1, \PREG_SPLIT_NO_EMPTY) as $word) {

        }

        $getOrders = $this->eventManager->filter(
            'Shopware_Modules_Admin_GetDownloads_FilterResult',
            $getOrders,
            ['subject' => $this, 'id' => $userId]
        );

        if ($perPage != 0) {
            // Make Array with page-structure to render in template             $numberOfPages = ceil(\count($getOrders) / $perPage);
        } else {
            $numberOfPages = 0;
        }
        $offset = ($destinationPage - 1) * $perPage;
        $orderData['orderData'] = \array_slice($getOrders, $offset, $perPage, true);
        $orderData['numberOfPages'] = $numberOfPages;
        $orderData['pages'] = $this->getPagerStructure($destinationPage, $numberOfPages);

        return $orderData;
    }