Index

Modules: intobject, intobject/Include/pycore_int, intobject/bit_length, intobject/bit_length_util, intobject/decl, intobject/decl_private, intobject/floatinfos, intobject/frexp, intobject/fromStrUtils, intobject/hashes, intobject/int_bytes, intobject/ops, intobject/ops_annassign, intobject/ops_basic_arith, intobject/ops_basic_private, intobject/ops_bitwise, intobject/ops_divmod, intobject/ops_dollar, intobject/ops_gcdlcm, intobject/ops_misc, intobject/ops_mix_nim, intobject/ops_pow, intobject/ops_strformat, intobject/ops_tofloat, intobject/ops_toint, intobject/ops_tostr, intobject/private/utils, intobject/random, intobject/shift, intobject/signbit, intobject/utils.

API symbols

`!=%`:

• ops_basic_arith: proc `!=%`(a, b: IntObject): bool

`$`:

• ops_dollar: proc `$`(i: IntObject): string

`%=`:

• ops_annassign: proc `%=`(a: var IntObject; b: SomeIntegerOrObj)

`%`:

• ops_divmod: proc `%`(a, b: IntObject): IntObject
• ops_mix_nim: template `%`[T: SomeInteger](a: IntObject; b: T): untyped
• ops_mix_nim: template `%`[T: SomeInteger](a: T; b: IntObject): untyped

`'iobj`:

• ops: proc `'iobj`[C: Rune | char](str: openArray[C]): IntObject

`*=`:

• ops_annassign: proc `*=`(a: var IntObject; b: SomeIntegerOrObj)

`*`:

• ops_basic_arith: proc `*`(a, b: IntObject): IntObject
• ops_mix_nim: template `*`[T: SomeInteger](a: IntObject; b: T): untyped
• ops_mix_nim: template `*`[T: SomeInteger](a: T; b: IntObject): untyped

`+=`:

• ops_annassign: proc `+=`(a: var IntObject; b: SomeIntegerOrObj)

`+`:

• ops_basic_arith: proc `+`(a, b: IntObject): IntObject
• ops_mix_nim: template `+`[T: SomeInteger](a: IntObject; b: T): untyped
• ops_mix_nim: template `+`[T: SomeInteger](a: T; b: IntObject): untyped

`-=`:

• ops_annassign: proc `-=`(a: var IntObject; b: SomeIntegerOrObj)

`-`:

• ops_basic_arith: proc `-`(a: IntObject): IntObject
• ops_basic_arith: proc `-`(a, b: IntObject): IntObject
• ops_mix_nim: template `-`[T: SomeInteger](a: IntObject; b: T): untyped
• ops_mix_nim: template `-`[T: SomeInteger](a: T; b: IntObject): untyped

`..`:

• ops_misc: iterator `..`(a, b: IntObject): IntObject

`//=`:

• ops_annassign: proc `//=`(a: var IntObject; b: SomeIntegerOrObj)

`//`:

• ops_divmod: proc `//`(a, b: IntObject): IntObject
• ops_mix_nim: template `//`[T: SomeInteger](a: IntObject; b: T): untyped
• ops_mix_nim: template `//`[T: SomeInteger](a: T; b: IntObject): untyped

`<%`:

• ops_basic_arith: proc `<%`(a, b: IntObject): bool

`<=%`:

• ops_basic_arith: proc `<=%`(a, b: IntObject): bool

`<=`:

• ops_basic_arith: proc `<=`(a, b: IntObject): bool
• ops_mix_nim: template `<=`[T: SomeInteger](a: IntObject; b: T): untyped
• ops_mix_nim: template `<=`[T: SomeInteger](a: T; b: IntObject): untyped

`<`:

• ops_basic_arith: proc `<`(a, b: IntObject): bool
• ops_mix_nim: template `<`[T: SomeInteger](a: IntObject; b: T): untyped
• ops_mix_nim: template `<`[T: SomeInteger](a: T; b: IntObject): untyped

`==%`:

• ops_basic_arith: proc `==%`(a, b: IntObject): bool

`==`:

• ops_basic_arith: proc `==`(a, b: IntObject): bool
• ops_mix_nim: template `==`[T: SomeInteger](a: IntObject; b: T): untyped
• ops_mix_nim: template `==`[T: SomeInteger](a: T; b: IntObject): untyped

`>%`:

• ops_basic_arith: proc `>%`(a, b: IntObject): bool

`>=%`:

• ops_basic_arith: proc `>=%`(a, b: IntObject): bool

`and`:

• ops_bitwise: proc `and`(a, b: IntObject): IntObject
• ops_mix_nim: template `and`[T: SomeInteger](a: IntObject; b: T): untyped
• ops_mix_nim: template `and`[T: SomeInteger](a: T; b: IntObject): untyped

`div`:

• ops_divmod: proc `div`(a, b: IntObject): IntObject
• ops_mix_nim: template `div`[T: SomeInteger](a: IntObject; b: T): untyped
• ops_mix_nim: template `div`[T: SomeInteger](a: T; b: IntObject): untyped

`mod`:

• ops_divmod: proc `mod`(a, b: IntObject): IntObject
• ops_divmod: proc `mod`(a: IntObject; n: SomeUnsignedIntSmallerThanTwoDigits): IntObject
• ops_divmod: proc `mod`(a: IntObject; n: TwoDigits): IntObject
• ops_mix_nim: template `mod`[T: SomeInteger](a: IntObject; b: T): untyped
• ops_mix_nim: template `mod`[T: SomeInteger](a: T; b: IntObject): untyped

`not`:

• ops_bitwise: proc `not`(self: IntObject): IntObject

`or`:

• ops_bitwise: proc `or`(a, b: IntObject): IntObject
• ops_mix_nim: template `or`[T: SomeInteger](a: IntObject; b: T): untyped
• ops_mix_nim: template `or`[T: SomeInteger](a: T; b: IntObject): untyped

`shl`:

• ops_bitwise: proc `shl`(a: IntObject; shiftby: BiggestUInt; shiftMayOvf: static[bool] = ShiftMayOvf): IntObject
• ops_bitwise: proc `shl`(a, b: IntObject): IntObject
• ops_mix_nim: template `shl`[T: SomeInteger](a: IntObject; b: T): untyped
• ops_mix_nim: template `shl`[T: SomeInteger](a: T; b: IntObject): untyped

`shr`:

• ops_bitwise: proc `shr`(a: IntObject; shiftby: BiggestUInt; shiftMayOvf: static[bool] = ShiftMayOvf): IntObject
• ops_bitwise: proc `shr`(a, b: IntObject): IntObject
• ops_mix_nim: template `shr`[T: SomeInteger](a: IntObject; b: T): untyped
• ops_mix_nim: template `shr`[T: SomeInteger](a: T; b: IntObject): untyped

`xor`:

• ops_bitwise: proc `xor`(a, b: IntObject): IntObject
• ops_mix_nim: template `xor`[T: SomeInteger](a: IntObject; b: T): untyped
• ops_mix_nim: template `xor`[T: SomeInteger](a: T; b: IntObject): untyped

abs:

• ops_basic_arith: proc abs(self: IntObject): IntObject

absToUInt:

• ops_toint: proc absToUInt[U: uint32 | uint64 | BiggestUInt | uint](pyInt: IntObject; x: var U): bool
• ops_toint: proc absToUInt[U: uint8 | uint16](pyInt: IntObject; x: var U): bool

asLongAndOverflow:

• ops_toint: proc asLongAndOverflow(vv: IntObject; ovlf: var bool): int

bit_count:

• bit_length: proc bit_count(self: IntObject): IntObject

bit_length:

• bit_length: proc bit_length(self: IntObject): IntObject
• bit_length_util: proc bit_length(self: SomeInteger): int

byteCount:

• bit_length: proc byteCount(v: IntObject): int64

ceilDiv:

• ops_divmod: proc ceilDiv(a, b: IntObject): IntObject
• ops_mix_nim: template ceilDiv[T: SomeInteger](a: IntObject; b: T): untyped
• ops_mix_nim: template ceilDiv[T: SomeInteger](a: T; b: IntObject): untyped

copyOnlyDigits:

• utils: proc copyOnlyDigits(intObj: IntObject): IntObject

DBL_DIG:

• floatinfos: const DBL_DIG

DBL_EPSILON:

• floatinfos: const DBL_EPSILON

DBL_MANT_DIG:

• floatinfos: const DBL_MANT_DIG

DBL_MAX:

• floatinfos: const DBL_MAX

DBL_MAX_10_EXP:

• floatinfos: const DBL_MAX_10_EXP

DBL_MAX_EXP:

• floatinfos: const DBL_MAX_EXP

DBL_MIN:

• floatinfos: const DBL_MIN

DBL_MIN_10_EXP:

• floatinfos: const DBL_MIN_10_EXP

DBL_MIN_EXP:

• floatinfos: const DBL_MIN_EXP

dec:

• ops_annassign: proc dec(a: var IntObject; b: SomeIntegerOrObj)
• ops_annassign: template dec(a: var IntObject)

demote:

• ops_basic_private: template demote(x: TwoDigits): Digit

digitCount:

• bit_length: proc digitCount(v: IntObject): int

digitOr:

• fromStrUtils: template digitOr(c: char; base: uint8; fallback): uint8

digits:

• decl_private: proc digits(self: IntObject): seq[Digit]
• decl_private: proc digits(self: var IntObject): var seq[Digit]

digits=:

• decl_private: proc digits=(self: var IntObject; s: seq[Digit])

divmod:

• ops_divmod: proc divmod(a, b: IntObject): tuple[d, m: IntObject]
• ops_mix_nim: template divmod[T: SomeInteger](a: IntObject; b: T): untyped
• ops_mix_nim: template divmod[T: SomeInteger](a: T; b: IntObject): untyped

divmodNear:

• ops_pow: proc divmodNear(a, b: IntObject): tuple[q, r: IntObject]

divmodNonZero:

• ops_divmod: proc divmodNonZero(a, b: IntObject): tuple[d, m: IntObject]

divRem:

• ops_divmod: proc divRem(a: IntObject; n: Digit; remainder: var Digit): IntObject

divrem:

• ops_divmod: proc divrem(a, b: IntObject): tuple[d, r: IntObject]

doMulImpl:

• ops_basic_private: template doMulImpl(result, b; loopVar, loopIter, src, dst)

fastLog2:

• ops_misc: proc fastLog2(a: IntObject): int

flipSign:

• signbit: proc flipSign(intObj: var IntObject)

floordiv:

• ops_divmod: proc floordiv(a, b: IntObject): IntObject
• ops_mix_nim: template floordiv[T: SomeInteger](a: IntObject; b: T): untyped
• ops_mix_nim: template floordiv[T: SomeInteger](a: T; b: IntObject): untyped

floordivNonZero:

• ops_divmod: proc floordivNonZero(a, b: IntObject): IntObject

floormod:

• ops_divmod: proc floormod(a, b: IntObject): IntObject
• ops_mix_nim: template floormod[T: SomeInteger](a: IntObject; b: T): untyped
• ops_mix_nim: template floormod[T: SomeInteger](a: T; b: IntObject): untyped

floormodNonZero:

• ops_divmod: proc floormodNonZero(a, b: IntObject): IntObject

FLT_RADIX:

• floatinfos: const FLT_RADIX

FLT_ROUNDS:

• floatinfos: template FLT_ROUNDS(): int

format:

• ops_tostr: proc format(i: IntObject; base: uint8; s: var string): bool

format_binary:

• ops_tostr: proc format_binary(a: IntObject; base: uint8; alternate: bool; v: var string): bool

formatValue:

• ops_strformat: proc formatValue(res: var string; self: IntObject; format_spec: static[string] = "")
• ops_strformat: proc formatValue(res: var string; self: IntObject; format_spec: string)

frexp:

• frexp: proc frexp(a: IntObject; e: var int64): float

fromStr:

• ops: proc fromStr[C: char](res: var IntObject; s: openArray[C]; nParsed: var int): IntObjectFromStrError
• ops: proc fromStr[C: char](res: var IntObject; s: openArray[C]; nParsed: var int; base: int): IntObjectFromStrError

fromStrWithValidBase:

• ops: proc fromStrWithValidBase[C: char](res: var IntObject; s: openArray[C]; nParsed: var int; base: int): IntObjectFromStrError

gcd:

• ops_gcdlcm: proc gcd(a, b: IntObject): IntObject

get_intobject_state:

• pycore_int: proc get_intobject_state(): var Py_long_state

hash:

• hashes: proc hash(obj: IntObject): Hash

HasLdExp:

• frexp: const HasLdExp

inc:

• ops_annassign: proc inc(a: var IntObject; b: SomeIntegerOrObj)
• ops_annassign: template inc(a: var IntObject)

inplaceAdd:

• ops_basic_private: proc inplaceAdd(a: var IntObject; b: Digit)

inplaceMul:

• ops_basic_private: proc inplaceMul(a: var IntObject; b: Digit | uint8)

IntObject:

• decl_private: object IntObject

IntObjectFormatOverflowError:

• ops_strformat: object IntObjectFormatOverflowError

IntObjectFromStrError:

• ops: enum IntObjectFromStrError

IntObjectToBytesError:

• int_bytes: enum IntObjectToBytesError

intOne:

• ops_basic_arith: const intOne

intTen:

• ops_basic_arith: const intTen

intTwo:

• ops_basic_arith: const intTwo

intZero:

• ops_basic_arith: const intZero

isDigitOfBase:

• fromStrUtils: proc isDigitOfBase(c: char; base: uint8): bool

isEven:

• signbit: proc isEven(i: IntObject): bool

isNegative:

• signbit: proc isNegative(intObj: IntObject): bool

isNil:

• decl: proc isNil(self: IntObject): bool

isOdd:

• signbit: proc isOdd(i: IntObject): bool

isPositive:

• signbit: proc isPositive(intObj: IntObject): bool

isZero:

• signbit: proc isZero(intObj: IntObject): bool

lcm:

• ops_gcdlcm: proc lcm(a, b: IntObject): IntObject

MAX_STR_DIGITS_errMsg_to_int:

• pycore_int: proc MAX_STR_DIGITS_errMsg_to_int(cfg_max, d: int): string

MAX_STR_DIGITS_errMsg_to_str:

• pycore_int: proc MAX_STR_DIGITS_errMsg_to_str(cfg_max: int): string

negate:

• signbit: proc negate(self: var IntObject)

newInt:

• decl: proc newInt(i: Digit): IntObject
• decl: proc newInt[I: SomeSignedInt](i: I): IntObject
• decl: proc newInt[I: SomeUnsignedInt and not Digit](i: I): IntObject
• decl: proc newInt(o: IntObject): IntObject
• int_bytes: proc newInt[T: uint8 | int8](bytes: openArray[T]; endianness: Endianness; signed = false): NimInt
• int_bytes: proc newInt(bytes: PyBytes; endianness: Endianness; signed = false): NimInt
• ops: proc newInt[C: char](smallInt: C): IntObject
• ops: proc newInt[C: Rune | char](str: openArray[C]): IntObject

newIntFromNormalFloat:

• ops: proc newIntFromNormalFloat(dval: float): IntObject

newIntFromPtr:

• decl: proc newIntFromPtr[I: ref | ptr](i: I): IntObject
• decl: proc newIntFromPtr(p: pointer): IntObject

newIntOfLen:

• utils: proc newIntOfLen(L: int): IntObject

newIntOfLenUninit:

• utils: proc newIntOfLenUninit(L: int): IntObject

newIntSimple:

• decl: proc newIntSimple(): IntObject

normalize:

• utils: proc normalize(a: var IntObject)

numbits:

• bit_length: proc numbits(v: IntObject): int64

parseByteOrder:

• int_bytes: proc parseByteOrder(byteorder: string): Endianness

parseInt:

• ops: proc parseInt[C: char | Rune](s: openArray[C]; res: var IntObject): int

parseIntObject:

• ops: proc parseIntObject[C: char | Rune](s: openArray[C]): IntObject

pow:

• ops_mix_nim: template pow[T: SomeInteger](a: IntObject; b: T): untyped
• ops_mix_nim: template pow[T: SomeInteger](a: T; b: IntObject): untyped
• ops_pow: proc pow(a: IntObject; b: Natural | SomeUnsignedInt): IntObject
• ops_pow: proc pow(a, b: IntObject): IntObject
• ops_pow: proc pow[V, W, X: SomeIntegerOrObj](v: V; w: W; x: X): IntObject

powMod:

• ops_pow: proc powMod(v, w, x: IntObject): IntObject

powNatural:

• ops_pow: proc powNatural(a, b: IntObject): IntObject

powPos:

• ops_pow: proc powPos(a, b: IntObject): IntObject

pred:

• ops_misc: proc pred(self: IntObject; i: int = 1): IntObject

private_gen_formatValue_impl:

• ops_strformat: template private_gen_formatValue_impl(runeMapper, floatMapper; selfToIntObjectMapper: untyped = asIs; bodyWrapper: untyped = asIs)

private_gen_mix:

• ops_mix_nim: template private_gen_mix(mix; prim, pyT: typedesc; do1, do2)

private_mixOpPyWithNim:

• ops_mix_nim: template private_mixOpPyWithNim(mixb, mix)

private_mixOpPyWithNim_with_div_mod_bitwise:

• ops_mix_nim: template private_mixOpPyWithNim_with_div_mod_bitwise(mixb, mix)

PY_INT_DEFAULT_MAX_STR_DIGITS:

• pycore_int: const PY_INT_DEFAULT_MAX_STR_DIGITS

PY_INT_MAX_STR_DIGITS_THRESHOLD:

• pycore_int: const PY_INT_MAX_STR_DIGITS_THRESHOLD

PyLongBaseSet:

• fromStrUtils: const PyLongBaseSet
• ops: const PyLongBaseSet

PyLong_DigitValue:

• fromStrUtils: const PyLong_DigitValue

randbits:

• random: proc randbits(k: Natural): IntObject
• random: proc randbits(r: var Rand; k: Natural): IntObject

round:

• ops_pow: proc round(self: IntObject; oNdigits: SomeIntegerOrObj): IntObject

setLenUninit:

• utils: template setLenUninit(intObj: IntObject; L: int)

setSignAndDigitCount:

• utils: proc setSignAndDigitCount(intObj: var IntObject; sign: IntSign; digitCount: int)

setSignNegative:

• signbit: proc setSignNegative(self: var IntObject)

sign:

• decl_private: proc sign(self: IntObject): IntSign
• decl_private: proc sign(self: var IntObject): var IntSign

sign=:

• decl_private: proc sign=(self: var IntObject; s: IntSign)

SomeIntegerOrObj:

• decl_private: type SomeIntegerOrObj

SomeUnsignedIntSmallerThanTwoDigits:

• ops_divmod: type SomeUnsignedIntSmallerThanTwoDigits

succ:

• ops_misc: proc succ(self: IntObject; i: int = 1): IntObject

tobytes:

• int_bytes: proc tobytes(self: NimInt; length: int; endianness: Endianness; signed = false): seq[ byte]

to_bytes:

• int_bytes: proc to_bytes[T: char | uint8 | int8](self: NimInt; length: int; endianness: Endianness; signed = false; res: var seq[T]): IntObjectToBytesError

tobytes:

• int_bytes: proc tobytes(self: NimInt; length = 1; byteorder: string = "big"; signed = false): seq[ byte]

tochars:

• int_bytes: proc tochars(self: NimInt; length: int; endianness: Endianness; signed = false): seq[ char]
• int_bytes: proc tochars(self: NimInt; length = 1; byteorder: string = "big"; signed = false): seq[ char]

toFloat:

• ops_tofloat: proc toFloat(pyInt: IntObject): float
• ops_tofloat: proc toFloat(pyInt: IntObject; overflow: var bool): float
• ops_tofloat: proc toFloat(pyInt: IntObject; res: var float): bool

toInt:

• ops_toint: proc toInt[T: SomeInteger](x: IntObject): Option[T]
• ops_toint: proc toInt(pyInt: IntObject; res: var int): bool
• ops_toint: proc toInt(pyInt: IntObject; overflow: var IntSign): int

toIntOrRetOF:

• ops_toint: template toIntOrRetOF(vv: IntObject): int

toSomeSignedInt:

• ops_toint: proc toSomeSignedInt[I: SomeSignedInt](pyInt: IntObject; overflow: var IntSign): I

toSomeSignedIntUnsafe:

• ops_toint: proc toSomeSignedIntUnsafe[T: SomeSignedInt](pyInt: IntObject): T

toSomeUnsignedInt:

• ops_toint: proc toSomeUnsignedInt[U: SomeUnsignedInt](pyInt: IntObject; overflow: var IntSign): U

toString:

• ops_tostr: proc toString(i: IntObject; base: BaseRngT): string

toStringCheckThreshold:

• ops_tostr: proc toStringCheckThreshold(a: IntObject; v: var string): bool

toUInt:

• ops_toint: proc toUInt(pyInt: IntObject; overflow: var IntSign): uint
• ops_toint: proc toUInt(pyInt: IntObject; res: var uint): bool

truncate:

• decl_private: template truncate(x: TwoDigits): Digit

unreachable:

• utils: template unreachable()

vLShift:

• shift: proc vLShift(z: var openArray[Digit]; a: openArray[Digit]; m: int; d: int): Digit

vRShift:

• shift: proc vRShift(z: var openArray[Digit]; a: openArray[Digit]; m: int; d: int): Digit