intdiv - PHP code example

Using the Function Intdiv in PHP

In php we often come across situations when we need to divide two numbers and return the quotient as an integer. For such cases the built in function intdiv is a great help. This function can be found in the sys class and it accepts two parameters dividend and divisor and returns the division value as an integer. The function also has the capability to return a division value as float, however if it divides a number by 0 or -1 then it throws an error message.

This is caused by a type mismatch where the variable is an integer and the return value is a string. Type juggling is one of the core features that php offers and it can help in many cases but there are certain moments where type coercion may cause problems.

One of the main issues with type juggling is the fact that php doesn’t enforce strict typing. Unless you use strict_types or set it as your default value, the language will perform implicit type conversion (coercion) when you pass int or float values into non-int types.

The reason why this happens is that the language uses union types which are kind-of compound types. A union type is defined as T|null meaning that it contains both int and float elements. So when we pass an int value into a union type it will convert to a float because the int element of the union is higher than the float element. This can be dangerous because if the int is too low it will result in a null pointer exception while if it is too high it may result in a division by zero error.

intdiv example

if ($len <= $sLen) {
            return clone $this;
        }

        $padLen = $pad->length();
        $freeLen = $len - $sLen;
        $len = $freeLen % $padLen;

        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) : ''));

        $base = \strlen($alphabet = $map['']);
        $bytes = array_values(unpack(\PHP_INT_SIZE >= 8 ? 'n*' : 'C*', $bytes));
        $digits = '';

        while ($count = \count($bytes)) {
            $quotient = [];
            $remainder = 0;

            for ($i = 0; $i !== $count; ++$i) {
                $carry = $bytes[$i] + ($remainder << (\PHP_INT_SIZE >= 8 ? 16 : 8));
                $digit = intdiv($carry, $base);
                $remainder = $carry % $base;

                if ($digit || $quotient) {
                    $quotient[] = $digit;
                }
            }

            $digits = $alphabet[$remainder].$digits;
            $bytes = $quotient;
        }

        if (null !== $title) {
            $titleLength = Helper::width(Helper::removeDecoration($formatter = $this->output->getFormatter(), $formattedTitle = sprintf($titleFormat, $title)));
            $markupLength = Helper::width($markup);
            if ($titleLength > $limit = $markupLength - 4) {
                $titleLength = $limit;
                $formatLength = Helper::width(Helper::removeDecoration($formatter, sprintf($titleFormat, '')));
                $formattedTitle = sprintf($titleFormat, Helper::substr($title, 0, $limit - $formatLength - 3).'...');
            }

            $titleStart = intdiv($markupLength - $titleLength, 2);
            if (false === mb_detect_encoding($markup, null, true)) {
                $markup = substr_replace($markup, $formattedTitle, $titleStart, $titleLength);
            } else {
                $markup = mb_substr($markup, 0, $titleStart).$formattedTitle.mb_substr($markup, $titleStart + $titleLength);
            }
        }

        $this->output->writeln(sprintf($this->style->getBorderFormat(), $markup));
    }

    /** * Renders vertical column separator. */

    self::assertSame($num_rows, $i);

    // Test the batch size.     if (is_null($expected_batch_size)) {
      $expected_batch_size = $configuration['batch_size'];
    }
    $property = $reflector->getProperty('batchSize');
    self::assertSame($expected_batch_size, $property->getValue($plugin));

    // Test the batch count.     if (is_null($expected_batch_count)) {
      $expected_batch_count = intdiv($num_rows, $expected_batch_size);
      if ($num_rows % $configuration['batch_size']) {
        $expected_batch_count++;
      }
    }
    $property = $reflector->getProperty('batch');
    self::assertSame($expected_batch_count, $property->getValue($plugin));
  }

  /** * Instantiates the source plugin under test. * * @param array $configuration * The source plugin configuration. * * @return \Drupal\migrate\Plugin\MigrateSourceInterface|object * The fully configured source plugin. */

$opcache->setLogger($logger);
        }

        if (!self::$apcuSupported ??= ApcuAdapter::isSupported()) {
            return $opcache;
        }

        if (\in_array(\PHP_SAPI, ['cli', 'phpdbg'], true) && !filter_var(\ini_get('apc.enable_cli'), \FILTER_VALIDATE_BOOL)) {
            return $opcache;
        }

        $apcu = new ApcuAdapter($namespace, intdiv($defaultLifetime, 5), $version);
        if (null !== $logger) {
            $apcu->setLogger($logger);
        }

        return new ChainAdapter([$apcu, $opcache]);
    }

    public static function createConnection(#[\SensitiveParameter] string $dsn, array $options = []): mixed     {
        if (str_starts_with($dsn, 'redis:') || str_starts_with($dsn, 'rediss:')) {
            return RedisAdapter::createConnection($dsn, $options);
        }

    /** * @throws CartException */
    private function refreshChildQuantity(
        LineItemCollection $lineItems,
        int $oldParentQuantity,
        int $newParentQuantity
    ): void {
        foreach ($lineItems as $lineItem) {
            $newQuantity = intdiv($lineItem->getQuantity(), $oldParentQuantity) * $newParentQuantity;

            if ($lineItem->hasChildren()) {
                $this->refreshChildQuantity($lineItem->getChildren(), $lineItem->getQuantity(), $newQuantity);
            }

            $lineItem->quantity = $newQuantity;
            $priceDefinition = $lineItem->getPriceDefinition();
            if ($priceDefinition && $priceDefinition instanceof QuantityPriceDefinition) {
                $priceDefinition->setQuantity($lineItem->getQuantity());
            }
        }
    }

for ($k = self::BASE; /* no condition */; $k += self::BASE) {
                if ($in >= $inputLength) {
                    throw new Exception('Invalid input');
                }

                $digit = self::$basicToDigit[$bytes[$in++] & 0xFF];

                if ($digit < 0) {
                    throw new Exception('Invalid input');
                }

                if ($digit > intdiv(self::MAX_INT - $i, $w)) {
                    throw new Exception('Integer overflow');
                }

                $i += $digit * $w;

                if ($k <= $bias) {
                    $t = self::TMIN;
                } elseif ($k >= $bias + self::TMAX) {
                    $t = self::TMAX;
                } else {
                    $t = $k - $bias;
                }

throw new \InvalidArgumentException('Entropy should be greater than 7.');
        }

        $this->entropy = $entropy;
    }

    public function generateToken(): string
    {
        // Generate an URI safe base64 encoded string that does not contain "+",         // "/" or "=" which need to be URL encoded and make URLs unnecessarily         // longer.         $bytes = random_bytes(intdiv($this->entropy, 8));

        return rtrim(strtr(base64_encode($bytes), '+/', '-_'), '=');
    }
}