std.bigint | Topaz

Имя	Модуль
BigInt.div →	std.bigint →
BigInt.mod →	std.bigint →
BigInt.parse →	std.bigint →
BigInt.toInt →	std.bigint →
BigInt.toString →	std.bigint →

Module

BigInt preserves arbitrary precision values. Text parsing, formatting, checked int conversion, division, and remainder have explicit failure outcomes.

Why

Ссылка

Exact arithmetic and checked conversions keep large values distinct from bounded machine integers.

Availability

Ссылка

Import std.bigint in language mode 5.21. The current compiler selects std/bigint.tpz for this language mode. Availability in other released editions and inclusion in each installed distribution are Pending.

Exported types

Ссылка

export type BigInt = BigInt

Type members keep the compiler-owned type name shown in their declarations. Importing a module does not create a new type identity.

Public API

Pending contracts

Ссылка

Read and write integers in an explicit radix

Ссылка

Правилоtopaz.stdlib.contract.bigint-text.rule

Read and write integers in an explicit radix

BigInt represents signed integers without a fixed bit width. Its text operations preserve the exact integer value and do not use a locale.

BigInt.parse takes a radix from 2 through 36. Text consists of an optional minus sign followed by at least one ASCII digit or lowercase ASCII letter. Letters a through z have digit values 10 through 35. Every digit must be smaller than the radix.

Leading zero digits are accepted. Negative zero produces the same zero value as 0. Parsing does not trim whitespace, accept a plus sign, accept uppercase letters, accept separators, or interpret a radix prefix. Characters are interpreted as ordinary digits of the supplied radix.

Valid text returns Some containing the exact integer. Empty text, a sign without digits, an invalid digit, any extra character, or a radix outside the allowed range returns None(). These input failures do not raise a runtime fault.

BigInt.toString takes a radix from 2 through 36 and returns lowercase ASCII digits in that radix. A negative nonzero value starts with a minus sign. The output has no radix prefix or leading zero digits. Zero is written as 0.

An invalid BigInt.toString radix raises TPZ5001 during execution. It does not select a default radix or return empty text.

Formatting a value and parsing the result with the same radix recovers that value. Parsing and formatting accepted text produces its canonical spelling in the selected radix.

The receiver and positional arguments are evaluated once in source order before the operation validates their values. An earlier fault prevents later evaluation. The operations do not change their inputs or perform external effects.

Причина

An explicit radix gives each digit one value. Strict input spelling makes accidental whitespace and alternate signs visible to the caller. Canonical output gives stored integer text a predictable form without a locale dependency.

Примеры Parse and format exact integers in explicit radices →Return None for malformed or out of radix digits →Reject parse radices outside two through thirty six →Reject surrounding whitespace in integer text →Reject a leading plus sign in integer text →Reject uppercase letters in integer text →Evaluate parse arguments before validating their values →Reject a formatting radix outside the valid range →Reject a formatting radix outside the valid range →

Диагностика TPZ5001 →

Parse and format exact integers in explicit radices

Ссылка

run · running · Проверка · Не выполнялось

main.tpzParse and format exact integers in explicit radicesОткрыть песочницу →

import std.bigint { BigInt }
import std.test
import std.io
let number = test.assertSome(BigInt.parse("ff", 16))
io.writeLine(number.toString(2))
io.writeLine(number.toString(10))
io.writeLine(number.toString(16))
io.writeLine(test.assertSome(BigInt.parse("z", 36)).toString(10))
io.writeLine(test.assertSome(BigInt.parse("-00015", 10)).toString(16))
io.writeLine(test.assertSome(BigInt.parse("-000", 10)).toString(36))
io.writeLine(test.assertSome(BigInt.parse("123456789012345678901234567890", 10)).toString(10))

Ожидаемый выводКод завершения 0

11111111
255
ff
35
-f
0
123456789012345678901234567890

$ topaz run main.tpz · Целевой продукт 5.21.3

Ожидаемый результат

Выполнение завершается. Код завершения 0.

Нет вывода ошибок.

Ожидаемый стандартный вывод

11111111
255
ff
35
-f
0
123456789012345678901234567890

Этот пример ещё не выполнялся.

Return None for malformed or out of radix digits

Ссылка

run · running · Проверка · Не выполнялось

main.tpzReturn None for malformed or out of radix digitsОткрыть песочницу →

import std.bigint { BigInt }
import std.io
for text in (["", "-", "1_0", "0x10", "g", "１２", "1\n2"]) {
match (BigInt.parse(text, 16)) {
case None() => io.writeLine("rejected")
case Some(_) => io.writeLine("accepted")
}
}
match (BigInt.parse("2", 2)) {
case None() => io.writeLine("digit rejected")
case Some(_) => io.writeLine("accepted")
}

Ожидаемый выводКод завершения 0

rejected
rejected
rejected
rejected
rejected
rejected
rejected
digit rejected

$ topaz run main.tpz · Целевой продукт 5.21.3

Ожидаемый результат

Выполнение завершается. Код завершения 0.

Нет вывода ошибок.

Ожидаемый стандартный вывод

rejected
rejected
rejected
rejected
rejected
rejected
rejected
digit rejected

Этот пример ещё не выполнялся.

Reject parse radices outside two through thirty six

Ссылка

run · running · Проверка · Не выполнялось

main.tpzReject parse radices outside two through thirty sixОткрыть песочницу →

import std.bigint { BigInt }
import std.io
for radix in ([-1, 0, 1, 37, 9223372036854775807]) {
match (BigInt.parse("10", radix)) {
case None() => io.writeLine("radix rejected")
case Some(_) => io.writeLine("accepted")
}
}

Ожидаемый выводКод завершения 0

radix rejected
radix rejected
radix rejected
radix rejected
radix rejected

$ topaz run main.tpz · Целевой продукт 5.21.3

Ожидаемый результат

Выполнение завершается. Код завершения 0.

Нет вывода ошибок.

Ожидаемый стандартный вывод

radix rejected
radix rejected
radix rejected
radix rejected
radix rejected

Этот пример ещё не выполнялся.

Reject surrounding whitespace in integer text

Ссылка

run · running · Проверка · Не выполнялось

main.tpzReject surrounding whitespace in integer textОткрыть песочницу →

import std.bigint { BigInt }
import std.io
match (BigInt.parse(" 10 ", 10)) {
case None() => io.writeLine("whitespace rejected")
case Some(_) => io.writeLine("accepted")
}

Ожидаемый выводКод завершения 0

whitespace rejected

$ topaz run main.tpz · Целевой продукт 5.21.3

Ожидаемый результат

Выполнение завершается. Код завершения 0.

Нет вывода ошибок.

Ожидаемый стандартный вывод

whitespace rejected

Этот пример ещё не выполнялся.

Reject a leading plus sign in integer text

Ссылка

run · running · Проверка · Не выполнялось

main.tpzReject a leading plus sign in integer textОткрыть песочницу →

import std.bigint { BigInt }
import std.io
match (BigInt.parse("+10", 10)) {
case None() => io.writeLine("plus rejected")
case Some(_) => io.writeLine("accepted")
}

Ожидаемый выводКод завершения 0

plus rejected

$ topaz run main.tpz · Целевой продукт 5.21.3

Ожидаемый результат

Выполнение завершается. Код завершения 0.

Нет вывода ошибок.

Ожидаемый стандартный вывод

plus rejected

Этот пример ещё не выполнялся.

Reject uppercase letters in integer text

Ссылка

run · running · Проверка · Не выполнялось

main.tpzReject uppercase letters in integer textОткрыть песочницу →

import std.bigint { BigInt }
import std.io
match (BigInt.parse("FF", 16)) {
case None() => io.writeLine("uppercase rejected")
case Some(_) => io.writeLine("accepted")
}

Ожидаемый выводКод завершения 0

uppercase rejected

$ topaz run main.tpz · Целевой продукт 5.21.3

Ожидаемый результат

Выполнение завершается. Код завершения 0.

Нет вывода ошибок.

Ожидаемый стандартный вывод

uppercase rejected

Этот пример ещё не выполнялся.

Evaluate parse arguments before validating their values

Ссылка

run · running · Проверка · Не выполнялось

main.tpzEvaluate parse arguments before validating their valuesОткрыть песочницу →

import std.bigint { BigInt }
import std.io
function text() -> string {
io.writeLine("text")
return "bad"
}
function radix() -> int {
io.writeLine("radix")
return 10
}
match (BigInt.parse(text(), radix())) {
case None() => io.writeLine("rejected")
case Some(_) => io.writeLine("accepted")
}

Ожидаемый выводКод завершения 0

text
radix
rejected

$ topaz run main.tpz · Целевой продукт 5.21.3

Ожидаемый результат

Выполнение завершается. Код завершения 0.

Нет вывода ошибок.

Ожидаемый стандартный вывод

text
radix
rejected

Этот пример ещё не выполнялся.

Reject a formatting radix outside the valid range

Ссылка

run · running · Проверка · Не выполнялось

main.tpzReject a formatting radix outside the valid rangeОткрыть песочницу →

import std.bigint { BigInt }
import std.test
import std.io
let number: BigInt = test.assertSome(BigInt.parse("1", 10))
number.toString(1)
io.writeLine("after")

Ожидаемый выводНенулевой код завершения

Нет стандартного вывода.

$ topaz run main.tpz · Целевой продукт 5.21.3

Ожидаемый результат

Этап отклонения run. Ненулевой код завершения.

TPZ5001 →
stdlib-bigint-radix at main.tpz:5:1

Нет стандартного вывода.

Этот пример ещё не выполнялся.

Reject a formatting radix outside the valid range

Ссылка

run · running · Проверка · Не выполнялось

main.tpzReject a formatting radix outside the valid rangeОткрыть песочницу →

import std.bigint { BigInt }
import std.test
import std.io
let number: BigInt = test.assertSome(BigInt.parse("1", 10))
number.toString(37)
io.writeLine("after")

Ожидаемый выводНенулевой код завершения

Нет стандартного вывода.

$ topaz run main.tpz · Целевой продукт 5.21.3

Ожидаемый результат

Этап отклонения run. Ненулевой код завершения.

TPZ5001 →
stdlib-bigint-radix at main.tpz:5:1

Нет стандартного вывода.

Этот пример ещё не выполнялся.

Diagnostics

Ссылка

Runtime value guard →

Convert exact integers within the int range

Ссылка

Правилоtopaz.stdlib.contract.bigint-to-int.rule

Convert exact integers within the int range

BigInt.toInt returns Some containing the same integer when the value is at least -9223372036854775808 and at most 9223372036854775807. Both endpoints are included.

Every value outside that signed 64 bit range returns None(). Conversion does not wrap, truncate, round, or saturate.

The operation evaluates its receiver once and leaves it unchanged. A failed conversion is an Option value and does not raise an arithmetic overflow fault.

BigInt.parse can represent integers beyond the int range. BigInt.toString still formats those values exactly when BigInt.toInt returns None().

Причина

A checked conversion preserves the distinction between an exact arbitrary precision value and a bounded machine integer. Option makes failure explicit without inventing a replacement integer.

Примеры Include both int endpoints and reject their neighbors →Keep a large value after conversion fails →

Include both int endpoints and reject their neighbors

Ссылка

run · running · Проверка · Не выполнялось

main.tpzInclude both int endpoints and reject their neighborsОткрыть песочницу →

import std.bigint { BigInt }
import std.test
import std.io
function show(text: string) -> () {
let value = test.assertSome(BigInt.parse(text, 10))
match (value.toInt()) {
case Some(integer) => io.writeLine("{integer}")
case None() => io.writeLine("outside int")
}
}
show("-9223372036854775808")
show("9223372036854775807")
show("-9223372036854775809")
show("9223372036854775808")
show("0")

Ожидаемый выводКод завершения 0

-9223372036854775808
9223372036854775807
outside int
outside int
0

$ topaz run main.tpz · Целевой продукт 5.21.3

Ожидаемый результат

Выполнение завершается. Код завершения 0.

Нет вывода ошибок.

Ожидаемый стандартный вывод

-9223372036854775808
9223372036854775807
outside int
outside int
0

Этот пример ещё не выполнялся.

Keep a large value after conversion fails

Ссылка

run · running · Проверка · Не выполнялось

main.tpzKeep a large value after conversion failsОткрыть песочницу →

import std.bigint { BigInt }
import std.test
import std.io
let value = test.assertSome(BigInt.parse("1000000000000000000000000000000", 10))
match (value.toInt()) {
case None() => io.writeLine("outside int")
case Some(_) => io.writeLine("converted")
}
io.writeLine(value.toString(10))

Ожидаемый выводКод завершения 0

outside int
1000000000000000000000000000000

$ topaz run main.tpz · Целевой продукт 5.21.3

Ожидаемый результат

Выполнение завершается. Код завершения 0.

Нет вывода ошибок.

Ожидаемый стандартный вывод

outside int
1000000000000000000000000000000

Этот пример ещё не выполнялся.

Divide exact integers toward zero

Ссылка

Правилоtopaz.stdlib.contract.bigint-division.rule

Divide exact integers toward zero

For a nonzero divisor, BigInt.div returns Ok containing the exact integer quotient truncated toward zero.

BigInt.mod returns Ok containing the remainder left by that quotient. For dividend a and divisor b, the values satisfy a = quotient * b + remainder. A nonzero remainder has the sign of the dividend and a magnitude smaller than the divisor magnitude.

A zero dividend and nonzero divisor produce a zero quotient and zero remainder. A negative divisor changes the quotient sign and does not choose the remainder sign.

A zero divisor makes either operation return Err containing a descriptive nonempty string. The string has no stable machine readable format. The operation does not raise a division fault for this input.

Quotients and remainders are BigInt values. Division has no signed 64 bit overflow boundary and does not convert an operand to int.

The receiver is evaluated before the divisor and each is evaluated once. An earlier fault prevents later evaluation. The operations leave both values unchanged and have no external effects.

Use div and mod for BigInt division and remainder. The language arithmetic operators on BigInt provide addition, subtraction, and multiplication.

Причина

Truncating the quotient toward zero keeps signed division aligned with int arithmetic. Returning Err for a zero divisor gives exact integer calculations a recoverable failure value.

Примеры Keep quotient and remainder signs explicit →Handle a zero divisor as a Result error →Evaluate the receiver before the divisor →

Keep quotient and remainder signs explicit

Ссылка

run · running · Проверка · Не выполнялось

main.tpzKeep quotient and remainder signs explicitОткрыть песочницу →

import std.bigint { BigInt }
import std.test
import std.io
function divide(left: string, right: string) -> () {
let a = test.assertSome(BigInt.parse(left, 10))
let b = test.assertSome(BigInt.parse(right, 10))
let quotient = test.assertOk(a.div(b))
let remainder = test.assertOk(a.mod(b))
io.writeLine(quotient.toString(10) + " " + remainder.toString(10))
}
divide("7", "3")
divide("-7", "3")
divide("7", "-3")
divide("-7", "-3")
divide("2", "7")
divide("0", "-3")
divide("-9223372036854775808", "-1")

Ожидаемый выводКод завершения 0

2 1
-2 -1
-2 1
2 -1
0 2
0 0
9223372036854775808 0

$ topaz run main.tpz · Целевой продукт 5.21.3

Ожидаемый результат

Выполнение завершается. Код завершения 0.

Нет вывода ошибок.

Ожидаемый стандартный вывод

2 1
-2 -1
-2 1
2 -1
0 2
0 0
9223372036854775808 0

Этот пример ещё не выполнялся.

Handle a zero divisor as a Result error

Ссылка

run · running · Проверка · Не выполнялось

main.tpzHandle a zero divisor as a Result errorОткрыть песочницу →

import std.bigint { BigInt }
import std.test
import std.io
let value = test.assertSome(BigInt.parse("7", 10))
let zero = test.assertSome(BigInt.parse("0", 10))
match (value.div(zero)) {
case Err(_) => io.writeLine("division rejected")
case Ok(_) => io.writeLine("accepted")
}
match (value.mod(zero)) {
case Err(_) => io.writeLine("remainder rejected")
case Ok(_) => io.writeLine("accepted")
}
io.writeLine(value.toString(10))
io.writeLine(zero.toString(10))

Ожидаемый выводКод завершения 0

division rejected
remainder rejected
7
0

$ topaz run main.tpz · Целевой продукт 5.21.3

Ожидаемый результат

Выполнение завершается. Код завершения 0.

Нет вывода ошибок.

Ожидаемый стандартный вывод

division rejected
remainder rejected
7
0

Этот пример ещё не выполнялся.

Evaluate the receiver before the divisor

Ссылка

run · running · Проверка · Не выполнялось

main.tpzEvaluate the receiver before the divisorОткрыть песочницу →

import std.bigint { BigInt }
import std.test
import std.io
function receiver() -> BigInt {
io.writeLine("receiver")
return test.assertSome(BigInt.parse("7", 10))
}
function divisor() -> BigInt {
io.writeLine("divisor")
return test.assertSome(BigInt.parse("3", 10))
}
let quotient = test.assertOk(receiver().div(divisor()))
io.writeLine(quotient.toString(10))

Ожидаемый выводКод завершения 0

receiver
divisor
2

$ topaz run main.tpz · Целевой продукт 5.21.3

Ожидаемый результат

Выполнение завершается. Код завершения 0.

Нет вывода ошибок.

Ожидаемый стандартный вывод

receiver
divisor
2

Этот пример ещё не выполнялся.

API этого модуля

Module

Why

Availability

Exported types

Public API

Pending contracts

Read and write integers in an explicit radix

Read and write integers in an explicit radix

Причина

Parse and format exact integers in explicit radices

Ожидаемый результат

Return None for malformed or out of radix digits

Ожидаемый результат

Reject parse radices outside two through thirty six

Ожидаемый результат

Reject surrounding whitespace in integer text

Ожидаемый результат

Reject a leading plus sign in integer text

Ожидаемый результат

Reject uppercase letters in integer text

Ожидаемый результат

Evaluate parse arguments before validating their values

Ожидаемый результат

Reject a formatting radix outside the valid range

Ожидаемый результат

Reject a formatting radix outside the valid range

Ожидаемый результат

Diagnostics

Convert exact integers within the int range

Convert exact integers within the int range

Причина

Include both int endpoints and reject their neighbors

Ожидаемый результат

Keep a large value after conversion fails

Ожидаемый результат

Divide exact integers toward zero

Divide exact integers toward zero

Причина

Keep quotient and remainder signs explicit

Ожидаемый результат

Handle a zero divisor as a Result error

Ожидаемый результат

Evaluate the receiver before the divisor

Ожидаемый результат