type math/big.Word
159 uses
math/big (current package)
arith.go#L19: type Word uint
arith.go#L43: func mulWW(x, y Word) (z1, z0 Word) {
arith.go#L45: return Word(hi), Word(lo)
arith.go#L49: func mulAddWWW_g(x, y, c Word) (z1, z0 Word) {
arith.go#L53: return Word(hi + cc), Word(lo)
arith.go#L58: func nlz(x Word) uint {
arith.go#L63: func addVV_g(z, x, y []Word) (c Word) {
arith.go#L70: z[i] = Word(zi)
arith.go#L71: c = Word(cc)
arith.go#L77: func subVV_g(z, x, y []Word) (c Word) {
arith.go#L84: z[i] = Word(zi)
arith.go#L85: c = Word(cc)
arith.go#L103: func addVW(z, x []Word, y Word) (c Word) {
arith.go#L112: z[0] = Word(zi)
arith.go#L121: if xi != ^Word(0) {
arith.go#L134: func addVW_ref(z, x []Word, y Word) (c Word) {
arith.go#L138: z[i] = Word(zi)
arith.go#L139: c = Word(cc)
arith.go#L157: func subVW(z, x []Word, y Word) (c Word) {
arith.go#L166: z[0] = Word(zi)
arith.go#L182: z[i] = ^Word(0)
arith.go#L188: func subVW_ref(z, x []Word, y Word) (c Word) {
arith.go#L192: z[i] = Word(zi)
arith.go#L193: c = Word(cc)
arith.go#L198: func lshVU_g(z, x []Word, s uint) (c Word) {
arith.go#L221: func rshVU_g(z, x []Word, s uint) (c Word) {
arith.go#L244: func mulAddVWW_g(z, x []Word, y, r Word) (c Word) {
arith.go#L255: func addMulVVWW_g(z, x, y []Word, m, a Word) (c Word) {
arith.go#L264: c, z[i] = Word(cc), Word(lo)
arith.go#L273: func divWW(x1, x0, y, m Word) (q, r Word) {
arith.go#L329: return Word(qq), Word(r0 >> s)
arith.go#L333: func reciprocalWord(d1 Word) Word {
arith.go#L338: return Word(rec)
arith_decl.go#L25: func addVV(z, x, y []Word) (c Word)
arith_decl.go#L37: func subVV(z, x, y []Word) (c Word)
arith_decl.go#L48: func shlVU(z, x []Word, s uint) (c Word) {
arith_decl.go#L59: func lshVU(z, x []Word, s uint) (c Word)
arith_decl.go#L64: func rshVU(z, x []Word, s uint) (c Word)
arith_decl.go#L76: func mulAddVWW(z, x []Word, m, a Word) (c Word)
arith_decl.go#L87: func addMulVVW(z, x []Word, y Word) (c Word) {
arith_decl.go#L94: func addMulVVWW(z, x, y []Word, m, a Word) (c Word)
decimal.go#L109: var n Word
decimal.go#L111: ch := Word(x.mant[r])
decimal.go#L128: mask := Word(1)<<s - 1
decimal.go#L130: ch := Word(x.mant[r])
float.go#L450: lsb := Word(1) << ntz
float.go#L1404: var xm, ym Word
int.go#L84: var abs []Word
int.go#L87: abs = []Word{Word(u), Word(u >> 32)}
int.go#L89: abs = []Word{Word(u)}
int.go#L108: func (x *Int) Bits() []Word {
int.go#L120: func (z *Int) SetBits(abs []Word) *Int {
int.go#L664: func lehmerSimulate(A, B *Int) (u0, u1, v0, v1 Word, even bool) {
int.go#L666: var a1, a2, u2, v2 Word
int.go#L717: func lehmerUpdate(A, B, q, r *Int, u0, u1, v0, v1 Word, even bool) {
int.go#L728: func mulW(z, x *Int, neg bool, w Word) {
int.go#L818: var ua, ub, va, vb Word
nat.go#L35: type nat []Word
nat.go#L70: func (z nat) setWord(x Word) nat {
nat.go#L81: if w := Word(x); uint64(w) == x {
nat.go#L86: z[1] = Word(x >> 32)
nat.go#L87: z[0] = Word(x)
nat.go#L187: func (z nat) montgomery(x, y, m nat, k Word, n int) nat {
nat.go#L197: var c Word
nat.go#L278: w []Word
nat.go#L442: m := Word(1) << (i % _W)
nat.go#L598: mask := Word((1 << bitLengthOfMSW) - 1)
nat.go#L604: z[i] = Word(rand.Uint32())
nat.go#L608: z[i] = Word(rand.Uint32()) | Word(rand.Uint32())<<32
nat.go#L839: mmask := ^Word(0)
nat.go#L1013: func bigEndianWord(buf []byte) Word {
nat.go#L1015: return Word(byteorder.BEUint64(buf))
nat.go#L1017: return Word(byteorder.BEUint32(buf))
nat.go#L1031: var d Word
nat.go#L1033: d |= Word(buf[i-1]) << s
natconv.go#L32: func maxPow(b Word) (p Word, n int) {
natconv.go#L44: func pow(x Word, n int) (p Word) {
natconv.go#L171: b1 := Word(b)
natconv.go#L172: var bn Word // b1**n (or 0 for the special bit-packing cases b=2,4,16)
natconv.go#L184: di := Word(0) // 0 <= di < b1**i < bn
natconv.go#L202: var d1 Word
natconv.go#L205: d1 = Word(ch - '0')
natconv.go#L207: d1 = Word(ch - 'a' + 10)
natconv.go#L210: d1 = Word(ch - 'A' + 10)
natconv.go#L212: d1 = Word(ch - 'A' + maxBaseSmall)
natconv.go#L316: if b := Word(base); b == b&-b {
natconv.go#L319: mask := Word(1<<shift - 1)
natconv.go#L405: func (q nat) convertWords(stk *stack, s []byte, b Word, ndigits int, bb Word, table []divisor) {
natconv.go#L437: var r Word
natconv.go#L491: func (z nat) expWW(stk *stack, x, y Word) nat {
natconv.go#L496: func divisors(stk *stack, m int, b Word, ndigits int, bb Word) []divisor {
natconv.go#L524: table[0].bbb = nat(nil).expWW(stk, bb, Word(leafSize))
natdiv.go#L526: var r2 Word
natdiv.go#L550: func (z nat) divW(x nat, y Word) (q nat, r Word) {
natdiv.go#L570: func (x nat) modW(d Word) (r Word) {
natdiv.go#L579: func divWVW(z []Word, xn Word, x []Word, y Word) (r Word) {
natdiv.go#L583: z[0] = Word(qq)
natdiv.go#L584: return Word(rr)
natdiv.go#L659: ujn := Word(0)
natdiv.go#L664: qhat := Word(_M)
natdiv.go#L670: var rhat Word
natdiv.go#L727: func greaterThan(x1, x2, y1, y2 Word) bool {
natmul.go#L136: func (z nat) mulAddWW(x nat, y, r Word) nat {
prime.go#L170: p := Word(3)
ratconv.go#L184: pow5 := z.b.abs.expNN(stk, natFive, nat(nil).setWord(Word(n)), nil, false) // use underlying array of z.b.abs
crypto/internal/boring/bbig
big.go#L31: x := unsafe.Slice((*big.Word)(&b[0]), len(b))
go/constant
value.go#L695: _m = ^big.Word(0)
value.go#L735: words := make([]big.Word, (len(bytes)+(wordSize-1))/wordSize)
value.go#L738: var w big.Word
value.go#L741: w |= big.Word(b) << s