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")

기대 출력0이 아닌 종료 코드

표준 출력 없음.

$ topaz run main.tpz · 대상 제품 5.21.3

기대 결과

거절 단계 run. 종료 코드가 0이 아닙니다.

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")

기대 출력0이 아닌 종료 코드

표준 출력 없음.

$ topaz run main.tpz · 대상 제품 5.21.3

기대 결과

거절 단계 run. 종료 코드가 0이 아닙니다.

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

기대 결과