PHP: полный мануал с примерами, функциями и ООП

PHP 4.0.4+ · gmp

gmp_init(int|string $num, int $base = 0): GMP

Сохранить большое целое без округления и явно выбрать систему счисления.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

$counter = gmp_init('100000000000000000001', 10);
echo gmp_strval($counter), "\n";

100000000000000000001

<?php
declare(strict_types=1);

echo gmp_strval(gmp_init('010')), "\n";
echo gmp_strval(gmp_init('010', 10)), "\n";
echo gmp_strval(gmp_init('ff', 16)), "\n";

8
10
255

<?php
declare(strict_types=1);

try {
    $quantity = gmp_init('12 items', 10);
} catch (ValueError $error) {
    echo "Некорректное целое\n";
}

Некорректное целое

Связанные операции: GMP::__construct; gmp_strval; gmp_add.

• PHP: gmp_init

PHP 8.2.4+ · gmp

new GMP(int|string $num = 0, int $base = 0)

Создать объект большого целого через new вместо gmp_init.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

$zero = new GMP();
$large = new GMP('100000000000000000001', 10);
echo gmp_strval($zero), "\n", gmp_strval($large), "\n";

0
100000000000000000001

<?php
declare(strict_types=1);

$counter = new GMP('100000000000000000001', 10);
$next = $counter + 1;
echo gmp_strval($next), "\n";
echo gmp_strval($counter), "\n";

100000000000000000002
100000000000000000001

Связанные операции: gmp_init; gmp_add; gmp_setbit.

• PHP: GMP::__construct

PHP 4.0.4+ · gmp

gmp_strval(GMP|int|string $num, int $base = 10): string

Получить точную текстовую запись для вывода, JSON или хранения.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

$number = gmp_init(255);
echo gmp_strval($number), "\n";
echo gmp_strval($number, 16), "\n";
echo gmp_strval($number, -16), "\n";
echo gmp_strval($number, 2), "\n";

255
ff
FF
11111111

<?php
declare(strict_types=1);

$count = gmp_add('100000000000000000000', 7);
$payload = ['count' => gmp_strval($count)];
echo json_encode($payload, JSON_THROW_ON_ERROR), "\n";

{"count":"100000000000000000007"}

Связанные операции: gmp_init; gmp_intval; gmp_export.

• PHP: gmp_strval

PHP 4.0.4+ · gmp

gmp_intval(GMP|int|string $num): int

Преобразовать GMP в обычный PHP int, только когда значение заведомо помещается.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

$quantity = gmp_init('42', 10);
if (gmp_cmp($quantity, PHP_INT_MIN) < 0 || gmp_cmp($quantity, PHP_INT_MAX) > 0) {
    throw new RangeException('Не помещается в int');
}
var_dump(gmp_intval($quantity));

int(42)

<?php
declare(strict_types=1);

$counter = gmp_init('100000000000000000001');
if (gmp_cmp($counter, PHP_INT_MAX) > 0) {
    echo 'Keep as string: ', gmp_strval($counter), "\n";
}

Keep as string: 100000000000000000001

Связанные операции: gmp_cmp; gmp_strval.

• PHP: gmp_intval

PHP 5.6.1+ · gmp

gmp_import(string $data, int $word_size = 1, int $flags = GMP_MSW_FIRST | GMP_NATIVE_ENDIAN): GMP

Превратить байты двоичного протокола в большое неотрицательное целое.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

$bytes = "\x01\x02";
$counter = gmp_import($bytes, 1, GMP_MSW_FIRST | GMP_BIG_ENDIAN);
echo gmp_strval($counter), "\n";

258

<?php
declare(strict_types=1);

$bytes = "\x01\x02";
echo gmp_strval(gmp_import($bytes, 2, GMP_MSW_FIRST | GMP_BIG_ENDIAN)), "\n";
echo gmp_strval(gmp_import($bytes, 2, GMP_MSW_FIRST | GMP_LITTLE_ENDIAN)), "\n";

258
513

<?php
declare(strict_types=1);

try {
    gmp_import("\x01\x02\x03", 2, GMP_MSW_FIRST | GMP_BIG_ENDIAN);
} catch (ValueError $error) {
    echo "Неполное двоичное слово\n";
}

Неполное двоичное слово

Связанные операции: gmp_export; gmp_strval.

• PHP: gmp_import

PHP 5.6.1+ · gmp

gmp_export(GMP|int|string $num, int $word_size = 1, int $flags = GMP_MSW_FIRST | GMP_NATIVE_ENDIAN): string

Записать большое целое в байты с заданным порядком слов и байтов.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

$bytes = gmp_export(258, 2, GMP_MSW_FIRST | GMP_BIG_ENDIAN);
echo bin2hex($bytes), "\n";
echo gmp_strval(gmp_import($bytes, 2, GMP_MSW_FIRST | GMP_BIG_ENDIAN)), "\n";

0102
258

<?php
declare(strict_types=1);

echo bin2hex(gmp_export(-258, 2, GMP_MSW_FIRST | GMP_BIG_ENDIAN)), "\n";
echo strlen(gmp_export(0)), "\n";

0102
0

Нельзя восстанавливать произвольное отрицательное целое простым import(export($n)): знак потерян по договору. Для JSON обычно проще десятичная строка; бинарное представление выбирают по внешнему формату. Сначала проверяйте размер результата, затем добавляйте нужное число ведущих нулей под фиксированную ширину поля.

Связанные операции: gmp_import; gmp_strval; gmp_sign.

• PHP: gmp_export

PHP 8.1+ · gmp

public GMP::__serialize(): array

Предоставить внутренние данные объекта механизму serialize.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

$number = gmp_init('100000000000000000001');
$stored = serialize($number);
$restored = unserialize($stored, ['allowed_classes' => [GMP::class]]);
echo gmp_strval($restored), "\n";

100000000000000000001

<?php
declare(strict_types=1);

$number = gmp_init(255);
$state = $number->__serialize();
echo $state[0], "\n";

ff

Связанные операции: GMP::__unserialize; gmp_strval.

• PHP: GMP::__serialize

PHP 8.1+ · gmp

public GMP::__unserialize(array $data): void

Восстановить состояние GMP из массива, подготовленного __serialize.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

$source = gmp_init(512);
$target = new GMP();
$target->__unserialize($source->__serialize());
echo gmp_strval($target), "\n";

512

<?php
declare(strict_types=1);

$number = new GMP();
try {
    $number->__unserialize([]);
} catch (Exception $error) {
    echo "Нет состояния GMP\n";
}

Нет состояния GMP

Связанные операции: GMP::__serialize; gmp_init.

• PHP: GMP::__unserialize

PHP 4.0.4+ · gmp

gmp_add(GMP|int|string $num1, GMP|int|string $num2): GMP

Сложить два целых без потери точности.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

$result = gmp_add(12, 7);
echo gmp_strval($result), "\n";

19

<?php
declare(strict_types=1);

$events = gmp_init('100000000000000000000', 10);
$events = gmp_add($events, 750);
echo gmp_strval($events), "\n";

100000000000000000750

Для простых чисел в пределах int обычный оператор часто понятнее и не требует расширения. Здесь GMP нужен ради диапазона целого, а не ради превращения всякого вычисления в объект. Если операнд — объект GMP, поддерживается и соответствующий арифметический оператор.

Связанные операции: gmp_sub; gmp_mul; gmp_strval.

• PHP: gmp_add

PHP 4.0.4+ · gmp

gmp_sub(GMP|int|string $num1, GMP|int|string $num2): GMP

Вычесть второе целое из первого.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

$result = gmp_sub(12, 7);
echo gmp_strval($result), "\n";

5

<?php
declare(strict_types=1);

$before = gmp_init('100000000000000000000', 10);
$after = gmp_init('100000000000000000042', 10);
echo gmp_strval(gmp_sub($after, $before)), "\n";

42

Для простых чисел в пределах int обычный оператор часто понятнее и не требует расширения. Здесь GMP нужен ради диапазона целого, а не ради превращения всякого вычисления в объект. Если операнд — объект GMP, поддерживается и соответствующий арифметический оператор.

Связанные операции: gmp_add; gmp_abs; gmp_cmp.

• PHP: gmp_sub

PHP 4.0.4+ · gmp

gmp_mul(GMP|int|string $num1, GMP|int|string $num2): GMP

Умножить два целых и сохранить все цифры.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

$result = gmp_mul(12, 7);
echo gmp_strval($result), "\n";

84

<?php
declare(strict_types=1);

$first = gmp_init('1000000000000', 10);
$second = gmp_init('1000000000000', 10);
echo gmp_strval(gmp_mul($first, $second)), "\n";

1000000000000000000000000

Для простых чисел в пределах int обычный оператор часто понятнее и не требует расширения. Здесь GMP нужен ради диапазона целого, а не ради превращения всякого вычисления в объект. Если операнд — объект GMP, поддерживается и соответствующий арифметический оператор.

Связанные операции: gmp_add; gmp_pow; gmp_div_q.

• PHP: gmp_mul

PHP 4.0.4+ · gmp

gmp_abs(GMP|int|string $num): GMP

Получить величину изменения независимо от его направления.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

echo gmp_strval(gmp_abs(-42)), "\n";
echo gmp_strval(gmp_abs(0)), "\n";

42
0

<?php
declare(strict_types=1);

$expected = gmp_init('100000000000000000050', 10);
$actual = gmp_init('100000000000000000008', 10);
$distance = gmp_abs(gmp_sub($actual, $expected));
echo gmp_strval($distance), "\n";
var_dump(gmp_cmp($distance, 10) > 0);

42
bool(true)

Связанные операции: gmp_neg; gmp_sign; gmp_sub.

• PHP: gmp_abs

PHP 4.0.4+ · gmp

gmp_neg(GMP|int|string $num): GMP

Изменить знак целого: поступление превратить в обратное изменение.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

echo gmp_strval(gmp_neg(250)), "\n";
echo gmp_strval(gmp_neg(-250)), "\n";

-250
250

<?php
declare(strict_types=1);

$delta = gmp_init('100000000000000000000', 10);
$reversal = gmp_neg($delta);
echo gmp_strval(gmp_add($delta, $reversal)), "\n";

0

Связанные операции: gmp_abs; gmp_add; gmp_sign.

• PHP: gmp_neg

PHP 4.0.4+ · gmp

gmp_cmp(GMP|int|string $num1, GMP|int|string $num2): int

Сравнить два больших целых по значению.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

var_dump(gmp_cmp(12, 20) < 0);
var_dump(gmp_cmp('20', 20) === 0);
var_dump(gmp_cmp(25, 20) > 0);

bool(true)
bool(true)
bool(true)

<?php
declare(strict_types=1);

$total = gmp_init('100000000000000000001', 10);
$limit = gmp_init('100000000000000000000', 10);
echo gmp_cmp($total, $limit) > 0 ? "Лимит превышен\n" : "В пределах лимита\n";

Лимит превышен

Связанные операции: gmp_sign; gmp_intval; gmp_sub.

• PHP: gmp_cmp

PHP 4.0.4+ · gmp

gmp_sign(GMP|int|string $num): int

Узнать только направление значения: отрицательное, нулевое или положительное.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

echo gmp_sign(-12), '/', gmp_sign(0), '/', gmp_sign(12), "\n";

-1/0/1

<?php
declare(strict_types=1);

$change = gmp_init('-100000000000000000000', 10);
$label = match (gmp_sign($change)) {
    -1 => 'Уменьшение',
    0 => 'Без изменения',
    1 => 'Увеличение',
};
echo $label, ': ', gmp_strval(gmp_abs($change)), "\n";

Уменьшение: 100000000000000000000

Связанные операции: gmp_cmp; gmp_abs; gmp_neg.

• PHP: gmp_sign

PHP 4.0.4+ · gmp

gmp_div_q(GMP|int|string $num1, GMP|int|string $num2, int $rounding_mode = GMP_ROUND_ZERO): GMP

Получить целую часть деления с явно выбранным направлением округления.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

echo gmp_strval(gmp_div_q(25, 6)), "\n";
echo gmp_strval(gmp_div_q(25, 6, GMP_ROUND_PLUSINF)), "\n";

4
5

<?php
declare(strict_types=1);

echo gmp_strval(gmp_div_q(-25, 6, GMP_ROUND_ZERO)), "\n";
echo gmp_strval(gmp_div_q(-25, 6, GMP_ROUND_MINUSINF)), "\n";

-4
-5

Связанные операции: gmp_div_qr; gmp_div_r; gmp_div.

• PHP: gmp_div_q

PHP 4.0.4+ · gmp

gmp_div(GMP|int|string $num1, GMP|int|string $num2, int $rounding_mode = GMP_ROUND_ZERO): GMP

Использовать старое краткое имя gmp_div_q с тем же договором.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

echo gmp_strval(gmp_div(25, 6)), "\n";
var_dump(gmp_cmp(gmp_div(25, 6), gmp_div_q(25, 6)) === 0);

4
bool(true)

<?php
declare(strict_types=1);

$blocks = gmp_div(25, 6, GMP_ROUND_PLUSINF);
echo gmp_strval($blocks), "\n";

5

Связанные операции: gmp_div_q; gmp_div_qr.

• PHP: gmp_div

PHP 4.0.4+ · gmp

gmp_div_r(GMP|int|string $num1, GMP|int|string $num2, int $rounding_mode = GMP_ROUND_ZERO): GMP

Получить остаток, согласованный с выбранным округлением частного.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

echo gmp_strval(gmp_div_r(25, 6)), "\n";

1

<?php
declare(strict_types=1);

echo gmp_strval(gmp_div_r(-25, 6, GMP_ROUND_ZERO)), "\n";
echo gmp_strval(gmp_div_r(-25, 6, GMP_ROUND_MINUSINF)), "\n";

-1
5

Связанные операции: gmp_div_q; gmp_div_qr; gmp_mod.

• PHP: gmp_div_r

PHP 4.0.4+ · gmp

gmp_div_qr(GMP|int|string $num1, GMP|int|string $num2, int $rounding_mode = GMP_ROUND_ZERO): array

Одним вызовом получить число полных групп и остаток.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

[$boxes, $remainder] = gmp_div_qr(25, 6);
echo 'Boxes: ', gmp_strval($boxes), ', left: ', gmp_strval($remainder), "\n";

Boxes: 4, left: 1

<?php
declare(strict_types=1);

try {
    [$groups, $left] = gmp_div_qr(25, 0);
} catch (DivisionByZeroError $error) {
    echo "Размер группы не может быть нулём\n";
}

Размер группы не может быть нулём

Связанные операции: gmp_div_q; gmp_div_r; gmp_mod.

• PHP: gmp_div_qr

PHP 4.0.4+ · gmp

gmp_mod(GMP|int|string $num1, GMP|int|string $num2): GMP

Получить неотрицательный остаток для циклической нумерации или модульной арифметики.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

echo gmp_strval(gmp_mod(-1, 7)), "\n";
echo gmp_strval(gmp_mod(-1, -7)), "\n";

6
6

<?php
declare(strict_types=1);

$sequence = gmp_init('100000000000000000001', 10);
$bucket = gmp_mod($sequence, 8);
echo gmp_strval($bucket), "\n";

1

Связанные операции: gmp_div_r; gmp_powm; gmp_div_qr.

• PHP: gmp_mod

PHP 4.0.4+ · gmp

gmp_divexact(GMP|int|string $num1, GMP|int|string $num2): GMP

Выполнить точное деление, когда делимость уже гарантирована.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

$units = gmp_init('100000000000000000000', 10);
$packed = gmp_mul($units, 6);
echo gmp_strval(gmp_divexact($packed, 6)), "\n";

100000000000000000000

<?php
declare(strict_types=1);

$units = gmp_init(25);
$size = gmp_init(6);
if (gmp_cmp(gmp_mod($units, $size), 0) !== 0) {
    echo "Нельзя разделить на полные комплекты\n";
} else {
    echo gmp_strval(gmp_divexact($units, $size)), "\n";
}

Нельзя разделить на полные комплекты

Связанные операции: gmp_div_qr; gmp_mod; gmp_mul.

• PHP: gmp_divexact

PHP 4.0.4+ · gmp

gmp_pow(GMP|int|string $num, int $exponent): GMP

Возвести целое в целую неотрицательную степень без потери цифр.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

echo gmp_strval(gmp_pow(2, 10)), "\n";
echo gmp_strval(gmp_pow(0, 0)), "\n";

1024
1

<?php
declare(strict_types=1);

$variants = gmp_pow(16, 20);
echo gmp_strval($variants), "\n";

1208925819614629174706176

Если далее нужен только остаток по модулю, используйте gmp_powm: не требуется сначала строить огромное промежуточное число. Для обычного PHP возведения в степень есть оператор **, но переполнение int приводит к другой модели точности.

Связанные операции: gmp_powm; gmp_mul; gmp_root.

• PHP: gmp_pow

PHP 4.0.4+ · gmp

gmp_powm(GMP|int|string $num, GMP|int|string $exponent, GMP|int|string $modulus): GMP

Сразу вычислить остаток от степени, не материализуя саму огромную степень.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

echo gmp_strval(gmp_powm(3, 4, 5)), "\n";
echo gmp_strval(gmp_mod(gmp_pow(3, 4), 5)), "\n";

1
1

<?php
declare(strict_types=1);

echo gmp_strval(gmp_powm(2, '100000000000000000000', 3)), "\n";
try {
    gmp_powm(2, -1, 5);
} catch (ValueError $error) {
    echo "Показатель должен быть неотрицательным\n";
}

1
Показатель должен быть неотрицательным

Связанные операции: gmp_pow; gmp_mod; gmp_invert.

• PHP: gmp_powm

PHP 4.0.4+ · gmp

gmp_sqrt(GMP|int|string $num): GMP

Получить целую часть квадратного корня точно, без float.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

echo gmp_strval(gmp_sqrt(25)), "\n";
echo gmp_strval(gmp_sqrt(26)), "\n";

5
5

<?php
declare(strict_types=1);

$tiles = gmp_init('100000000000000000001', 10);
$side = gmp_sqrt($tiles);
$left = gmp_sub($tiles, gmp_mul($side, $side));
echo gmp_strval($side), ' / ', gmp_strval($left), "\n";

10000000000 / 1

Связанные операции: gmp_sqrtrem; gmp_perfect_square; gmp_root.

• PHP: gmp_sqrt

PHP 4.0.4+ · gmp

gmp_sqrtrem(GMP|int|string $num): array

Получить квадратный корень и остаток одной операцией.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

[$side, $left] = gmp_sqrtrem(29);
echo gmp_strval($side), "\n";
echo gmp_strval($left), "\n";

5
4

<?php
declare(strict_types=1);

foreach ([36, 37] as $number) {
    [$root, $remainder] = gmp_sqrtrem($number);
    echo $number, ': ', gmp_cmp($remainder, 0) === 0 ? 'square' : 'not square', "\n";
}

36: square
37: not square

Связанные операции: gmp_sqrt; gmp_perfect_square; gmp_rootrem.

• PHP: gmp_sqrtrem

PHP 5.6+ · gmp

gmp_root(GMP|int|string $num, int $nth): GMP

Вычислить целую часть корня заданной степени.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

echo gmp_strval(gmp_root(28, 3)), "\n";
echo gmp_strval(gmp_root(-28, 3)), "\n";

3
-3

<?php
declare(strict_types=1);

$cells = gmp_init('1000000000000000000000000', 10);
echo gmp_strval(gmp_root($cells, 3)), "\n";

100000000

Связанные операции: gmp_rootrem; gmp_pow; gmp_sqrt.

• PHP: gmp_root

PHP 5.6+ · gmp

gmp_rootrem(GMP|int|string $num, int $nth): array

Получить целый корень n-й степени вместе с невместившимся остатком.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

[$side, $left] = gmp_rootrem(30, 3);
echo gmp_strval($side), ' / ', gmp_strval($left), "\n";

3 / 3

<?php
declare(strict_types=1);

[$root, $remainder] = gmp_rootrem(-30, 3);
$restored = gmp_add(gmp_pow($root, 3), $remainder);
echo gmp_strval($root), ' / ', gmp_strval($remainder), "\n";
echo gmp_strval($restored), "\n";

-3 / -3
-30

Связанные операции: gmp_root; gmp_pow; gmp_sqrtrem.

• PHP: gmp_rootrem

PHP 4.0.4+ · gmp

gmp_perfect_square(GMP|int|string $num): bool

Проверить, является ли целое квадратом целого числа.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

foreach ([-4, 0, 1, 24, 25] as $number) {
    echo $number, ': ', gmp_perfect_square($number) ? 'yes' : 'no', "\n";
}

-4: no
0: yes
1: yes
24: no
25: yes

<?php
declare(strict_types=1);

$count = gmp_init('100000000000000000000', 10);
if (gmp_perfect_square($count)) {
    echo 'Side: ', gmp_strval(gmp_sqrt($count)), "\n";
}

Side: 10000000000

Связанные операции: gmp_sqrtrem; gmp_sqrt; gmp_perfect_power.

• PHP: gmp_perfect_square

PHP 5.6+ · gmp

gmp_perfect_power(GMP|int|string $num): bool

Проверить, представимо ли число как целая степень с показателем больше единицы.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

foreach ([16, 27, 12, -8, -1, 0, 1] as $number) {
    echo $number, ': ', gmp_perfect_power($number) ? 'yes' : 'no', "\n";
}

16: yes
27: yes
12: no
-8: yes
-1: yes
0: yes
1: yes

<?php
declare(strict_types=1);

$candidates = ['64', '65', '81'];
foreach ($candidates as $candidate) {
    if (gmp_perfect_power($candidate)) {
        echo $candidate, "\n";
    }
}

64
81

Связанные операции: gmp_perfect_square; gmp_root; gmp_prob_prime.

• PHP: gmp_perfect_power

PHP 4.0.4+ · gmp

gmp_fact(GMP|int|string $num): GMP

Сосчитать число перестановок n различных элементов: n факториал.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

echo gmp_strval(gmp_fact(3)), "\n";
echo gmp_strval(gmp_fact(0)), "\n";

6
1

<?php
declare(strict_types=1);

$taskCount = 25;
if ($taskCount < 0 || $taskCount > 1000) {
    throw new InvalidArgumentException('Недопустимое число заданий');
}
echo gmp_strval(gmp_fact($taskCount)), "\n";

15511210043330985984000000

Связанные операции: gmp_binomial; gmp_mul; gmp_pow.

• PHP: gmp_fact

PHP 7.3+ · gmp

gmp_binomial(GMP|int|string $n, int $k): GMP

Сосчитать выбор k элементов из n без учёта порядка.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

echo gmp_strval(gmp_binomial(5, 2)), "\n";
echo gmp_strval(gmp_binomial(5, 6)), "\n";

10
0

<?php
declare(strict_types=1);

echo gmp_strval(gmp_binomial(100, 50)), "\n";
echo gmp_strval(gmp_binomial(-3, 2)), "\n";

100891344545564193334812497256
6

Связанные операции: gmp_fact; gmp_mul; gmp_divexact.

• PHP: gmp_binomial

PHP 4.0.4+ · gmp

gmp_and(GMP|int|string $num1, GMP|int|string $num2): GMP

Оставить биты, установленные в обеих масках.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

Двоичная запись описывает число битами 0 и 1. Самый правый бит имеет индекс 0 и вес 1, следующий индекс 1 и вес 2, затем 2 и вес 4. Поэтому 13 = 1101₂ содержит единицы в позициях 0, 2, 3. В битовой маске каждой позиции заранее назначают смысл: например, наличие одной возможности. GMP позволяет маскам выходить за разрядность обычного int.

<?php
declare(strict_types=1);

echo gmp_strval(gmp_and(12, 10)), "\n";

8

<?php
declare(strict_types=1);

$requested = gmp_init('1101', 2);
$allowed = gmp_init('1011', 2);
echo gmp_strval(gmp_and($requested, $allowed), 2), "\n";

1001

Связанные операции: gmp_or; gmp_xor; gmp_testbit.

• PHP: gmp_and

PHP 4.0.4+ · gmp

gmp_or(GMP|int|string $num1, GMP|int|string $num2): GMP

Установить биты, присутствующие хотя бы в одной маске.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

Двоичная запись описывает число битами 0 и 1. Самый правый бит имеет индекс 0 и вес 1, следующий индекс 1 и вес 2, затем 2 и вес 4. Поэтому 13 = 1101₂ содержит единицы в позициях 0, 2, 3. В битовой маске каждой позиции заранее назначают смысл: например, наличие одной возможности. GMP позволяет маскам выходить за разрядность обычного int.

<?php
declare(strict_types=1);

echo gmp_strval(gmp_or(12, 10)), "\n";

14

<?php
declare(strict_types=1);

$basic = gmp_init('0011', 2);
$optional = gmp_init('1100', 2);
echo gmp_strval(gmp_or($basic, $optional), 2), "\n";

1111

Связанные операции: gmp_and; gmp_xor; gmp_setbit.

• PHP: gmp_or

PHP 4.0.4+ · gmp

gmp_xor(GMP|int|string $num1, GMP|int|string $num2): GMP

Найти биты, различающиеся в двух масках.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

Двоичная запись описывает число битами 0 и 1. Самый правый бит имеет индекс 0 и вес 1, следующий индекс 1 и вес 2, затем 2 и вес 4. Поэтому 13 = 1101₂ содержит единицы в позициях 0, 2, 3. В битовой маске каждой позиции заранее назначают смысл: например, наличие одной возможности. GMP позволяет маскам выходить за разрядность обычного int.

<?php
declare(strict_types=1);

echo gmp_strval(gmp_xor(12, 10)), "\n";

6

<?php
declare(strict_types=1);

$before = gmp_init('1011', 2);
$after = gmp_init('1101', 2);
$changed = gmp_xor($before, $after);
echo gmp_strval($changed, 2), "\n";
echo gmp_popcount($changed), "\n";

110
2

Связанные операции: gmp_and; gmp_or; gmp_hamdist.

• PHP: gmp_xor

PHP 4.0.4+ · gmp

gmp_com(GMP|int|string $num): GMP

Инвертировать все биты целого числа.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

Двоичная запись описывает число битами 0 и 1. Самый правый бит имеет индекс 0 и вес 1, следующий индекс 1 и вес 2, затем 2 и вес 4. Поэтому 13 = 1101₂ содержит единицы в позициях 0, 2, 3. В битовой маске каждой позиции заранее назначают смысл: например, наличие одной возможности. GMP позволяет маскам выходить за разрядность обычного int.

<?php
declare(strict_types=1);

echo gmp_strval(gmp_com(0)), "\n";
echo gmp_strval(gmp_com(5)), "\n";

-1
-6

<?php
declare(strict_types=1);

$value = gmp_init(5);
$byteMask = gmp_init(255);
$invertedByte = gmp_and(gmp_com($value), $byteMask);
echo gmp_strval($invertedByte), "\n";
echo gmp_strval($invertedByte, 2), "\n";

250
11111010

Связанные операции: gmp_and; gmp_xor; gmp_export.

• PHP: gmp_com

PHP 4.0.4+ · gmp

gmp_setbit(GMP $num, int $index, bool $value = true): void

Изменить один бит в уже созданном объекте GMP.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

Двоичная запись описывает число битами 0 и 1. Самый правый бит имеет индекс 0 и вес 1, следующий индекс 1 и вес 2, затем 2 и вес 4. Поэтому 13 = 1101₂ содержит единицы в позициях 0, 2, 3. В битовой маске каждой позиции заранее назначают смысл: например, наличие одной возможности. GMP позволяет маскам выходить за разрядность обычного int.

<?php
declare(strict_types=1);

$mask = gmp_init(0);
gmp_setbit($mask, 3);
echo gmp_strval($mask), "\n";
gmp_setbit($mask, 3, false);
echo gmp_strval($mask), "\n";

8
0

<?php
declare(strict_types=1);

$original = gmp_init(1);
$alias = $original;
$copy = clone $original;
gmp_setbit($alias, 5);
echo gmp_strval($original), "\n";
echo gmp_strval($copy), "\n";

33
1

Связанные операции: gmp_clrbit; gmp_testbit; gmp_or.

• PHP: gmp_setbit

PHP 4.0.4+ · gmp

gmp_clrbit(GMP $num, int $index): void

Очистить конкретный бит, сохранив остальные позиции маски.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

Двоичная запись описывает число битами 0 и 1. Самый правый бит имеет индекс 0 и вес 1, следующий индекс 1 и вес 2, затем 2 и вес 4. Поэтому 13 = 1101₂ содержит единицы в позициях 0, 2, 3. В битовой маске каждой позиции заранее назначают смысл: например, наличие одной возможности. GMP позволяет маскам выходить за разрядность обычного int.

<?php
declare(strict_types=1);

$mask = gmp_init(7);
gmp_clrbit($mask, 2);
echo gmp_strval($mask), "\n";

3

<?php
declare(strict_types=1);

$mask = gmp_init(3);
gmp_clrbit($mask, 2);
gmp_clrbit($mask, 2);
echo gmp_strval($mask), "\n";

3

Связанные операции: gmp_setbit; gmp_testbit; gmp_and.

• PHP: gmp_clrbit

PHP 5.3+ · gmp

gmp_testbit(GMP|int|string $num, int $index): bool

Проверить состояние конкретной позиции маски.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

Двоичная запись описывает число битами 0 и 1. Самый правый бит имеет индекс 0 и вес 1, следующий индекс 1 и вес 2, затем 2 и вес 4. Поэтому 13 = 1101₂ содержит единицы в позициях 0, 2, 3. В битовой маске каждой позиции заранее назначают смысл: например, наличие одной возможности. GMP позволяет маскам выходить за разрядность обычного int.

<?php
declare(strict_types=1);

var_dump(gmp_testbit(5, 0));
var_dump(gmp_testbit(5, 1));

bool(true)
bool(false)

<?php
declare(strict_types=1);

$features = gmp_init(0);
gmp_setbit($features, 100);
echo gmp_testbit($features, 100) ? "Enabled\n" : "Disabled\n";
echo gmp_testbit($features, 99) ? "Enabled\n" : "Disabled\n";

Enabled
Disabled

Связанные операции: gmp_setbit; gmp_clrbit; gmp_scan1.

• PHP: gmp_testbit

PHP 4.0.4+ · gmp

gmp_popcount(GMP|int|string $num): int

Посчитать единичные биты неотрицательной маски.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

Двоичная запись описывает число битами 0 и 1. Самый правый бит имеет индекс 0 и вес 1, следующий индекс 1 и вес 2, затем 2 и вес 4. Поэтому 13 = 1101₂ содержит единицы в позициях 0, 2, 3. В битовой маске каждой позиции заранее назначают смысл: например, наличие одной возможности. GMP позволяет маскам выходить за разрядность обычного int.

<?php
declare(strict_types=1);

echo gmp_popcount(13), "\n";
echo gmp_popcount(0), "\n";

3
0

<?php
declare(strict_types=1);

$features = gmp_init(0);
foreach ([2, 100, 250] as $index) {
    gmp_setbit($features, $index);
}
echo gmp_popcount($features), "\n";

3

Связанные операции: gmp_hamdist; gmp_scan1; gmp_testbit.

• PHP: gmp_popcount

PHP 4.0.4+ · gmp

gmp_hamdist(GMP|int|string $num1, GMP|int|string $num2): int

Посчитать, сколько битов различаются у двух неотрицательных чисел.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

Двоичная запись описывает число битами 0 и 1. Самый правый бит имеет индекс 0 и вес 1, следующий индекс 1 и вес 2, затем 2 и вес 4. Поэтому 13 = 1101₂ содержит единицы в позициях 0, 2, 3. В битовой маске каждой позиции заранее назначают смысл: например, наличие одной возможности. GMP позволяет маскам выходить за разрядность обычного int.

<?php
declare(strict_types=1);

echo gmp_hamdist(10, 12), "\n";
echo gmp_popcount(gmp_xor(10, 12)), "\n";

2
2

<?php
declare(strict_types=1);

$before = gmp_init(0);
gmp_setbit($before, 100);
$after = clone $before;
gmp_setbit($after, 5);
gmp_clrbit($after, 100);
echo gmp_hamdist($before, $after), "\n";

2

Связанные операции: gmp_xor; gmp_popcount; gmp_scan1.

• PHP: gmp_hamdist

PHP 4.0.4+ · gmp

gmp_scan0(GMP|int|string $num1, int $start): int

Найти первый бит 0 начиная с указанной позиции.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

Двоичная запись описывает число битами 0 и 1. Самый правый бит имеет индекс 0 и вес 1, следующий индекс 1 и вес 2, затем 2 и вес 4. Поэтому 13 = 1101₂ содержит единицы в позициях 0, 2, 3. В битовой маске каждой позиции заранее назначают смысл: например, наличие одной возможности. GMP позволяет маскам выходить за разрядность обычного int.

<?php
declare(strict_types=1);

echo gmp_scan0(7, 0), "\n";

3

<?php
declare(strict_types=1);

$occupied = gmp_init('10111', 2);
$free = gmp_scan0($occupied, 0);
if ($free < 5) {
    echo 'Free slot: ', $free, "\n";
} else {
    echo "No free slots\n";
}

Free slot: 3

Связанные операции: gmp_scan1; gmp_testbit; gmp_setbit.

• PHP: gmp_scan0

PHP 4.0.4+ · gmp

gmp_scan1(GMP|int|string $num1, int $start): int

Найти первый бит 1 начиная с указанной позиции.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

Двоичная запись описывает число битами 0 и 1. Самый правый бит имеет индекс 0 и вес 1, следующий индекс 1 и вес 2, затем 2 и вес 4. Поэтому 13 = 1101₂ содержит единицы в позициях 0, 2, 3. В битовой маске каждой позиции заранее назначают смысл: например, наличие одной возможности. GMP позволяет маскам выходить за разрядность обычного int.

<?php
declare(strict_types=1);

echo gmp_scan1(40, 0), "\n";

3

<?php
declare(strict_types=1);

$mask = gmp_init(40);
$width = 8;
$start = 0;
while ($start < $width) {
    $found = gmp_scan1($mask, $start);
    if ($found < 0 || $found >= $width) {
        break;
    }
    echo $found, "\n";
    $start = $found + 1;
}

3
5

Связанные операции: gmp_scan0; gmp_testbit; gmp_popcount.

• PHP: gmp_scan1

PHP 4.0.4+ · gmp

gmp_gcd(GMP|int|string $num1, GMP|int|string $num2): GMP

Найти наибольший общий делитель двух целых.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

echo gmp_strval(gmp_gcd(18, 24)), "\n";
echo gmp_strval(gmp_gcd(-18, 24)), "\n";

6
6

<?php
declare(strict_types=1);

$width = gmp_init(1920);
$height = gmp_init(1080);
$divisor = gmp_gcd($width, $height);
echo gmp_strval(gmp_divexact($width, $divisor)), ':',
     gmp_strval(gmp_divexact($height, $divisor)), "\n";

16:9

Связанные операции: gmp_lcm; gmp_gcdext; gmp_divexact.

• PHP: gmp_gcd

PHP 4.0.4+ · gmp

gmp_gcdext(GMP|int|string $num1, GMP|int|string $num2): array

Найти общий делитель и коэффициенты, выражающие его через исходные числа.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

Это следующий шаг после обычного НОД. Например, нужно понять, можно ли выразить требуемое изменение как целую комбинацию двух шагов. Если g делит нужное значение c, то коэффициенты для c получаются умножением s и t на c/g. Отрицательное число шагов означает обратное направление, а не допустимое количество коробок.

<?php
declare(strict_types=1);

$result = gmp_gcdext(30, 18);
$restored = gmp_add(gmp_mul(30, $result['s']), gmp_mul(18, $result['t']));
echo gmp_strval($result['g']), "\n";
echo gmp_strval($restored), "\n";

6
6

<?php
declare(strict_types=1);

$result = gmp_gcdext(30, 18);
$target = gmp_init(12);
if (gmp_cmp(gmp_mod($target, $result['g']), 0) === 0) {
    $factor = gmp_divexact($target, $result['g']);
    $x = gmp_mul($result['s'], $factor);
    $y = gmp_mul($result['t'], $factor);
    echo gmp_strval(gmp_add(gmp_mul(30, $x), gmp_mul(18, $y))), "\n";
}

12

Связанные операции: gmp_gcd; gmp_invert; gmp_mod.

• PHP: gmp_gcdext

PHP 7.3+ · gmp

gmp_lcm(GMP|int|string $num1, GMP|int|string $num2): GMP

Найти наименьшее общее кратное двух целых.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

echo gmp_strval(gmp_lcm(6, 8)), "\n";
echo gmp_strval(gmp_lcm(0, 8)), "\n";

24
0

<?php
declare(strict_types=1);

$firstPeriod = 12;
$secondPeriod = 18;
echo gmp_strval(gmp_lcm($firstPeriod, $secondPeriod)), " minutes\n";

36 minutes

Связанные операции: gmp_gcd; gmp_mul; gmp_mod.

• PHP: gmp_lcm

PHP 4.0.4+ · gmp

gmp_invert(GMP|int|string $num1, GMP|int|string $num2): GMP|false

Найти обратный множитель в арифметике по модулю.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

Обычное деление 1/a даёт дробь. Здесь задача другая: подобрать целый множитель, отменяющий умножение после взятия остатка. Это применяется в модульных алгоритмах и кодировании; функция не является шифром сама по себе.

<?php
declare(strict_types=1);

$inverse = gmp_invert(3, 11);
if ($inverse !== false) {
    echo gmp_strval($inverse), "\n";
    echo gmp_strval(gmp_mod(gmp_mul(3, $inverse), 11)), "\n";
}

4
1

<?php
declare(strict_types=1);

$modulus = 11;
$encoded = gmp_mod(gmp_mul(3, 7), $modulus);
$inverse = gmp_invert(3, $modulus);
if ($inverse === false) {
    throw new RuntimeException('Нет обратного множителя');
}
echo gmp_strval(gmp_mod(gmp_mul($encoded, $inverse), $modulus)), "\n";
var_dump(gmp_invert(6, 9) === false);

7
bool(true)

Связанные операции: gmp_gcd; gmp_gcdext; gmp_powm.

• PHP: gmp_invert

PHP 4.0.4+ · gmp

gmp_legendre(GMP|int|string $num1, GMP|int|string $num2): int

Проверить существование ненулевого квадратного остатка по простому нечётному модулю.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

«Квадратный остаток» означает: существует целое x, чей квадрат после mod p даёт a mod p. Это инструмент теории чисел, используемый в математических алгоритмах. Он сообщает существование, но не возвращает сам x.

<?php
declare(strict_types=1);

echo gmp_legendre(2, 7), "\n";
echo gmp_legendre(3, 7), "\n";
echo gmp_legendre(7, 7), "\n";

1
-1
0

<?php
declare(strict_types=1);

$prime = 7;
for ($candidate = 1; $candidate < $prime; $candidate++) {
    if (gmp_legendre($candidate, $prime) === 1) {
        echo $candidate, "\n";
    }
}

1
2
4

Связанные операции: gmp_jacobi; gmp_kronecker; gmp_prob_prime.

• PHP: gmp_legendre

PHP 4.0.4+ · gmp

gmp_jacobi(GMP|int|string $num1, GMP|int|string $num2): int

Вычислить символ Якоби для положительного нечётного знаменателя.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

Символ Якоби обобщает символ Лежандра: для простого знаменателя результаты совпадают. Для составного он определяется произведением символов по простым множителям с учётом кратности. Это помогает строить алгоритмы теории чисел, но не заменяет все их проверки.

<?php
declare(strict_types=1);

echo gmp_jacobi(2, 3), "\n";
echo gmp_jacobi(2, 7), "\n";
echo gmp_jacobi(3, 9), "\n";

-1
1
0

<?php
declare(strict_types=1);

echo gmp_jacobi(2, 15), "\n";
$found = false;
for ($x = 0; $x < 15; $x++) {
    if (($x * $x) % 15 === 2) {
        $found = true;
    }
}
var_dump($found);

1
bool(false)

Связанные операции: gmp_legendre; gmp_kronecker; gmp_mod.

• PHP: gmp_jacobi

PHP 7.3+ · gmp

gmp_kronecker(GMP|int|string $num1, GMP|int|string $num2): int

Вычислить обобщение символа Якоби для любого целого знаменателя.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

Этот символ нужен в специализированных математических алгоритмах, где ограничения Якоби слишком узкие. Для нечётного положительного знаменателя он совпадает с Якоби. Множитель 2 обрабатывается по остатку нечётного числителя modulo 8: ±1 дают 1, ±3 дают −1; чётный числитель даёт 0.

<?php
declare(strict_types=1);

echo gmp_kronecker(3, 2), "\n";
echo gmp_kronecker(7, 2), "\n";
echo gmp_kronecker(4, 2), "\n";

-1
1
0

<?php
declare(strict_types=1);

var_dump(gmp_kronecker(2, 15) === gmp_jacobi(2, 15));
echo gmp_kronecker(1, 0), "\n";
echo gmp_kronecker(2, 0), "\n";

bool(true)
1
0

Связанные операции: gmp_jacobi; gmp_legendre; gmp_mod.

• PHP: gmp_kronecker

PHP 5.2+ · gmp

gmp_nextprime(GMP|int|string $num): GMP

Найти следующее простое число, строго больше заданного.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

echo gmp_strval(gmp_nextprime(10)), "\n";
echo gmp_strval(gmp_nextprime(11)), "\n";

11
13

<?php
declare(strict_types=1);

$current = gmp_init(20);
for ($i = 0; $i < 4; $i++) {
    $current = gmp_nextprime($current);
    echo gmp_strval($current), "\n";
}

23
29
31
37

Связанные операции: gmp_prob_prime; gmp_gcd; gmp_random_range.

• PHP: gmp_nextprime

PHP 4.0.4+ · gmp

gmp_prob_prime(GMP|int|string $num, int $repetitions = 10): int

Проверить, является ли число составным, вероятно простым или доказанно простым для данного теста.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

<?php
declare(strict_types=1);

foreach ([21, 23] as $candidate) {
    $status = gmp_prob_prime($candidate, 25);
    echo $candidate, ': ', $status === 0 ? 'composite' : 'prime candidate', "\n";
}

21: composite
23: prime candidate

<?php
declare(strict_types=1);

$numbers = ['100', '101', '102', '103'];
foreach ($numbers as $text) {
    $number = gmp_init($text, 10);
    if (gmp_cmp($number, 2) >= 0 && gmp_prob_prime($number, 25) !== 0) {
        echo $text, "\n";
    }
}

101
103

Связанные операции: gmp_nextprime; gmp_gcd; gmp_perfect_power.

• PHP: gmp_prob_prime

PHP 5.6.3+ · gmp

gmp_random_bits(int $bits): GMP

Получить псевдослучайное неотрицательное целое в заданном битовом диапазоне.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

Генератор GMP подходит для математических экспериментов и воспроизводимых тестов. Его случайность не является криптографически безопасной: не используйте эти функции для токенов, ключей и непредсказуемых кодов. Для таких задач есть Random\Engine\Secure и безопасная случайность, random_int и random_bytes.

<?php
declare(strict_types=1);

$number = gmp_random_bits(8);
var_dump(gmp_cmp($number, 0) >= 0 && gmp_cmp($number, 255) <= 0);

bool(true)

<?php
declare(strict_types=1);

$number = gmp_random_bits(128);
gmp_setbit($number, 127);
var_dump(gmp_cmp($number, gmp_pow(2, 127)) >= 0);
var_dump(gmp_cmp($number, gmp_pow(2, 128)) < 0);

bool(true)
bool(true)

Связанные операции: gmp_random_range; gmp_random_seed; gmp_setbit.

• PHP: gmp_random_bits

PHP 5.6.3+ · gmp

gmp_random_range(GMP|int|string $min, GMP|int|string $max): GMP

Выбрать псевдослучайное целое из замкнутого диапазона.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

Генератор GMP подходит для математических экспериментов и воспроизводимых тестов. Его случайность не является криптографически безопасной: не используйте эти функции для токенов, ключей и непредсказуемых кодов. Для таких задач есть Random\Engine\Secure и безопасная случайность, random_int и random_bytes.

<?php
declare(strict_types=1);

$offset = gmp_random_range(-5, 5);
var_dump(gmp_cmp($offset, -5) >= 0 && gmp_cmp($offset, 5) <= 0);

bool(true)

<?php
declare(strict_types=1);

$min = gmp_init('100000000000000000000', 10);
$max = gmp_add($min, 100);
$sample = gmp_random_range($min, $max);
var_dump(gmp_cmp($sample, $min) >= 0 && gmp_cmp($sample, $max) <= 0);
try {
    gmp_random_range(5, 5);
} catch (ValueError $error) {
    echo "Нужны разные границы\n";
}

bool(true)
Нужны разные границы

Связанные операции: gmp_random_bits; gmp_random_seed; gmp_add.

• PHP: gmp_random_range

PHP 7.0+ · gmp

gmp_random_seed(GMP|int|string $seed): void

Задать начальное состояние псевдослучайной последовательности GMP.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

Генератор GMP подходит для математических экспериментов и воспроизводимых тестов. Его случайность не является криптографически безопасной: не используйте эти функции для токенов, ключей и непредсказуемых кодов. Для таких задач есть Random\Engine\Secure и безопасная случайность, random_int и random_bytes.

<?php
declare(strict_types=1);

gmp_random_seed(42);
$first = gmp_strval(gmp_random_bits(32));
$second = gmp_strval(gmp_random_bits(32));
gmp_random_seed(42);
var_dump($first === gmp_strval(gmp_random_bits(32)));
var_dump($second === gmp_strval(gmp_random_bits(32)));

bool(true)
bool(true)

<?php
declare(strict_types=1);

function testInputs($seed)
{
    gmp_random_seed($seed);
    $inputs = [];
    for ($i = 0; $i < 3; $i++) {
        $inputs[] = gmp_strval(gmp_random_range(1, 1000));
    }
    return $inputs;
}
$original = testInputs(2026);
$replayed = testInputs(2026);
var_dump($original === $replayed);

bool(true)

Связанные операции: gmp_random_bits; gmp_random_range.

• PHP: gmp_random_seed

PHP 4.0.4–7.4; удалена в PHP 8.0 · gmp

gmp_random(int $limiter = 20): GMP — удалена в PHP 8.0

Исторический генератор GMP: как читать старый код и переносить его на современный API.

GMP хранит целые числа, которые могут быть больше диапазона обычного PHP int. Большое число передают строкой, например '100000000000000000000', чтобы PHP не округлил его как float ещё до вызова. Результат большинства операций — объект GMP; gmp_strval превращает его в строку для вывода или передачи.

Вход GMP|int|string означает объект GMP, обычное целое или строковую запись целого. Строки автоматически распознают основание, как gmp_init с base=0: ведущий 0 может означать восьмеричную запись. Для внешних десятичных значений сначала используйте gmp_init($text, 10). Дробь 12.50 — не целое GMP; для десятичных дробей нужен BCMath.

Генератор GMP подходит для математических экспериментов и воспроизводимых тестов. Его случайность не является криптографически безопасной: не используйте эти функции для токенов, ключей и непредсказуемых кодов. Для таких задач есть Random\Engine\Secure и безопасная случайность, random_int и random_bytes.

<?php
declare(strict_types=1);

$number = gmp_random_bits(160);
var_dump(gmp_cmp($number, 0) >= 0);
var_dump(gmp_cmp($number, gmp_pow(2, 160)) < 0);

bool(true)
bool(true)

<?php
declare(strict_types=1);

$number = gmp_random_range(-1000, -1);
var_dump(gmp_cmp($number, -1000) >= 0 && gmp_cmp($number, -1) <= 0);

bool(true)

Связанные операции: gmp_random_bits; gmp_random_range; gmp_random_seed.

• PHP: gmp_random