std.internal.math.biguintcore

Fundamental operations for arbitrary-precision arithmetic

These functions are for internal use only.

var BigDigitBits FASTDIVLIMIT ONE TEN TWO ZERO

fn add addAssignSimple addInt addOrSubAssignSimple addSimple adjustRemainder biguintFromDecimal biguintToDecimal biguintToHex biguintToOctal blockDivMod divModInternal firstNonZeroDigit getCacheLimit highestDifferentDigit highestPowerBelowUintMax highestPowerBelowUlongMax includeSign inplaceSub intpow itoaZeroPadded karatsubaRequiredBuffSize less mulInternal mulKaratsuba mulSimple recursiveDivMod removeLeadingZeros schoolbookDivMod squareInternal squareKaratsuba squareSimple sub subAssignSimple subInt toHexZeroPadded twosComplement

Types 3

aliasmultibyteAdd = multibyteAddSub!('+')

aliasmultibyteSub = multibyteAddSub!('-')

structBigUint

BigUint performs memory management and wraps the low-level calls.

Fields

private immutable(BigDigit) [] data

private trustedAssumeUnique

Methods

size_t uintLength() @property pure nothrow const @safe @nogc scope

size_t ulongLength() @property pure nothrow const @safe @nogc scope

ulong peekUlong(size_t n) pure nothrow const @safe @nogc scope

uint peekUint(size_t n) pure nothrow const @safe @nogc scope

void opAssign(Tulong)(Tulong u) if (is (Tulong == ulong)) pure nothrow @safe scope

void opAssign(Tdummy = void)(BigUint y) pure nothrow @nogc @safe scope

int opCmp(Tdummy = void)(const BigUint y) pure nothrow @nogc const @safe scope

int opCmp(Tulong)(Tulong y) if (is (Tulong == ulong)) pure nothrow @nogc const @safe scope

bool opEquals(Tdummy = void)(ref const BigUint y) pure nothrow @nogc const @safe scope

bool opEquals(Tdummy = void)(ulong y) pure nothrow @nogc const @safe scope

bool isZero() pure const nothrow @safe @nogc scope

size_t numBytes() pure nothrow const @safe @nogc scope

char [] toDecimalString(int frontExtraBytes) const pure nothrow @safe scope

char [] toHexString(int  frontExtraBytes,  char  separator =  0,
             int  minPadding = 0,  char  padChar =  '0',
             LetterCase letterCase =  LetterCase.upper)

const pure nothrow @safe scopeConvert to a hex string, printing a minimum number of digits 'minPadding', allocating an additional 'frontExtraBytes' at the start of the string. Padding is done with padChar, which may be '0' or '...

char[] toOctalString() pure nothrow @safe const scopeConvert to an octal string.

bool fromHexString(Range)(Range s) if (isBidirectionalRange!Range && isSomeChar!(ElementType!Range)) scope

bool fromDecimalString(Range)(Range s) if (isForwardRange!Range && isSomeChar!(ElementType!Range)) scope

void fromMagnitude(Range)(Range magnitude) if (isInputRange!Range
        && (isForwardRange!Range ||  hasLength!Range)
         &&  isUnsigned!(ElementType!Range))

scope

BigUint opBinary(string op, Tulong)(Tulong y) if (op == ">>" && is (Tulong == ulong)) pure nothrow @safe const return scope

BigUint opBinary(string op, Tulong)(Tulong y) if (op == "<<" && is (Tulong == ulong)) pure nothrow @safe const scope

BigUint addOrSubInt(Tulong)(const  scope  BigUint x,  Tulong y,  bool  wantSub,  ref  bool  sign) if (is(Tulong ==  ulong))

static pure nothrow @safe

BigUint addOrSub(scope BigUint x, scope BigUint y, bool wantSub, ref bool sign) static pure nothrow @safe

BigUint mulInt(T = ulong)(BigUint x, T y) static pure nothrow @safe

BigUint mul(scope BigUint x, scope BigUint y) static pure nothrow @safe

BigUint divInt(T)(return scope BigUint x, T y_) if ( is(immutable T == immutable uint) ) static pure nothrow @safe

BigUint divInt(T)(scope BigUint x, T y) if ( is(immutable T == immutable ulong) ) static pure nothrow @safe

uint modInt(T)(scope BigUint x, T y_) if ( is(immutable T == immutable uint) ) static pure

BigUint div(return scope BigUint x, scope BigUint y) static pure nothrow @safe

BigUint mod(return scope BigUint x, scope BigUint y) static pure nothrow @safe

void divMod(BigUint x,  scope  BigUint y,
                        out  BigUint quotient,  out  BigUint remainder)

static pure nothrow @safe

BigUint bitwiseOp(string op)(scope  BigUint x,  scope  BigUint y,  bool  xSign,  bool  ySign,  ref  bool  resultSign) if (op ==  "|" ||  op ==  "^" ||  op ==  "&")

static pure nothrow @safe

BigUint pow(return scope BigUint x, ulong y) static pure nothrow @safeReturn a BigUint which is x raised to the power of y. Method: Powers of 2 are removed from x, then left-to-right binary exponentiation is used. Memory allocation is minimized: at most one temporary...

size_t toHash() const @nogc nothrow pure @safe scope

Constructors

this(return scope immutable(BigDigit) [] x)

this(T x)

Functions 37

private fnsize_t getCacheLimit() @nogc nothrow pure @safe

fninout(BigDigit) [] removeLeadingZeros(return scope inout(BigDigit) [] x) pure nothrow @safe

private fnvoid twosComplement(const(BigDigit) [] x, BigDigit[] result) pure nothrow @safe

private fnBigDigit[] includeSign(scope const(BigDigit) [] x, size_t minSize, bool sign) pure nothrow @safe

private fnT intpow(T)(T x, ulong n) pure nothrow @safe

private fnint highestPowerBelowUintMax(uint x) pure nothrow @safe

private fnint highestPowerBelowUlongMax(uint x) pure nothrow @safe

private fnBigDigit [] sub(const scope BigDigit [] x, const scope BigDigit [] y, bool * negative) pure nothrow @safe

private fnBigDigit [] add(const scope BigDigit [] a, const scope BigDigit [] b) pure nothrow @safe

private fnBigDigit [] addInt(const BigDigit[] x, ulong y) @safe pure nothrowreturn x + y

private fnBigDigit [] subInt(const BigDigit[] x, ulong y) pure nothrow @safeReturn x - y. x must be greater than y.

private fnvoid mulInternal(BigDigit[] result, const(BigDigit)[] x, const(BigDigit)[] y) pure nothrow @safeGeneral unsigned multiply routine for bigints. Sets result = x * y.

private fnvoid squareInternal(BigDigit[] result, const BigDigit[] x) pure nothrow @safeGeneral unsigned squaring routine for BigInts. Sets result = x*x. NOTE: If the highest half-digit of x is zero, the highest digit of result will also be zero.

private fn

void divModInternal(BigDigit []  quotient,  BigDigit[]  remainder,  const  BigDigit []  u,
         const  BigDigit []  v)

pure nothrow @safeif remainder is null, only calculate quotient.

private fn

char [] biguintToHex(return  scope  char []  buff,  const  scope  BigDigit []  data,  char  separator = 0,
         LetterCase letterCase =  LetterCase.upper)

pure nothrow @safe

private fnsize_t biguintToOctal(char[] buff, const(BigDigit)[] data) pure nothrow @safe @nogcConvert a big uint into an octal string.

private fnsize_t biguintToDecimal(char [] buff, BigDigit [] data) pure nothrow @safeConvert a big uint into a decimal string.

private fn

int biguintFromDecimal(Range)(BigDigit[]  data,  Range s) if (
     isInputRange!Range &&
     isSomeChar!(ElementType!Range)  &&
    !isInfinite!Range)

Convert a decimal string into a big uint.

private fn

void mulSimple(BigDigit[]  result,  const(BigDigit) []  left,
         const(BigDigit)[]  right)

pure nothrow @safe

private fnvoid squareSimple(BigDigit[] result, const(BigDigit) [] x) pure nothrow @safe

private fnuint addSimple(BigDigit[] result, const BigDigit [] left, const BigDigit [] right) pure nothrow @safe

private fnBigDigit subAssignSimple(BigDigit [] result, const(BigDigit) [] right) pure nothrow @safe

private fnBigDigit addAssignSimple(BigDigit [] result, const(BigDigit) [] right) pure nothrow @safe

private fn

BigDigit addOrSubAssignSimple(BigDigit []  result,  const(BigDigit) []  right,
         bool  wantSub)

pure nothrow @safe

private fnbool less(const(BigDigit)[] x, const(BigDigit)[] y) pure nothrow @safe

private fnbool inplaceSub(BigDigit[] result, const(BigDigit)[] x, const(BigDigit)[] y) pure nothrow @safe

private fnsize_t karatsubaRequiredBuffSize(size_t xlen) pure nothrow @safe

private fn

void mulKaratsuba(BigDigit []  result,  const(BigDigit) []  x,
         const(BigDigit)[]  y,  BigDigit []  scratchbuff)

pure nothrow @safe

private fn

void squareKaratsuba(BigDigit []  result,  const  BigDigit []  x,
         BigDigit []  scratchbuff)

pure nothrow @safe

private fnvoid schoolbookDivMod(BigDigit [] quotient, BigDigit [] u, in BigDigit [] v) pure nothrow @safe

private fnvoid itoaZeroPadded(char[] output, uint value) pure nothrow @safe @nogc

private fn

void toHexZeroPadded(char[]  output,  uint  value,
         LetterCase letterCase =  LetterCase.upper)

pure nothrow @safe

private fnsize_t highestDifferentDigit(const BigDigit [] left, const BigDigit [] right) pure nothrow @nogc @safe

private fnint firstNonZeroDigit(const BigDigit [] x) pure nothrow @nogc @safe

private fn

void recursiveDivMod(BigDigit[]  quotient,  BigDigit[]  u,  const(BigDigit)[]  v,
                      BigDigit[]  scratch,  bool  mayOverflow =  false)

pure nothrow @safe

private fn

void adjustRemainder(BigDigit[]  quot,  BigDigit[]  rem,  const(BigDigit)[]  v,
         ptrdiff_t k,
         BigDigit[]  scratch,  bool  mayOverflow =  false)

pure nothrow @safe

private fnvoid blockDivMod(BigDigit [] quotient, BigDigit [] u, in BigDigit [] v) pure nothrow @safe

Variables 6

private enumvarFASTDIVLIMIT = 100

private enumvarBigDigitBits = BigDigit.sizeof * 8

private varBigDigit[] ZERO

private varBigDigit[] ONE

private varBigDigit[] TWO

private varBigDigit[] TEN

Templates 1

tmplmaxBigDigits(T) if (isIntegral!T)