- Sort Score
- Result 10 results
- Languages All
Results 1 - 10 of 5,054 for theorem (0.15 sec)
-
src/crypto/internal/nistec/p256_ordinv.go
return nil, errors.New("invalid scalar length") } x := new(p256OrdElement) p256OrdBigToLittle(x, (*[32]byte)(k)) p256OrdReduce(x) // Inversion is implemented as exponentiation by n - 2, per Fermat's little theorem. // // The sequence of 38 multiplications and 254 squarings is derived from // https://briansmith.org/ecc-inversion-addition-chains-01#p256_scalar_inversion _1 := new(p256OrdElement) _11 := new(p256OrdElement)
Registered: Wed Jun 12 16:32:35 UTC 2024 - Last Modified: Mon Mar 04 17:29:44 UTC 2024 - 3K bytes - Viewed (0) -
src/cmd/compile/internal/ssa/magic.go
// trailing zeroes as x. So the two tests are, // // x*m mod 2^n <= ⎣(2^n - 1)/d0⎦ // and x*m ends in k zero bits // // These can be combined into a single comparison by the following // (theorem ZRU in Hacker's Delight) for unsigned integers. // // x <= a and x ends in k zero bits if and only if RotRight(x ,k) <= ⎣a/(2^k)⎦ // Where RotRight(x ,k) is right rotation of x by k bits. //
Registered: Wed Jun 12 16:32:35 UTC 2024 - Last Modified: Tue Mar 26 19:58:25 UTC 2024 - 15.8K bytes - Viewed (0) -
src/crypto/internal/edwards25519/field/fe_test.go
"0100000000000000000000000000000000000000000000000000000000000000", 1, "0200000000000000000000000000000000000000000000000000000000000000", }, // 1/4 == (2⁻¹)² == (2^(p-2))² per Euler's theorem { "0100000000000000000000000000000000000000000000000000000000000000", "0400000000000000000000000000000000000000000000000000000000000000", 1, "f6ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff3f",
Registered: Wed Jun 12 16:32:35 UTC 2024 - Last Modified: Mon Aug 28 17:26:17 UTC 2023 - 13.9K bytes - Viewed (0) -
test/chan/powser1.go
<-Z.req u := get(U) if end(u) != 0 { done = true } Z.dat <- mul(i2tor(1, int64(i)), u) } Z.dat <- finis }() return Z } // Binomial theorem (1+x)^c func Binom(c rat) PS { Z := mkPS() go func() { n := 1 t := itor(1) for c.num != 0 { put(t, Z) t = mul(mul(t, c), i2tor(1, int64(n))) c = sub(c, one) n++ }
Registered: Wed Jun 12 16:32:35 UTC 2024 - Last Modified: Wed Mar 25 22:22:20 UTC 2020 - 12.7K bytes - Viewed (0) -
test/chan/powser2.go
<-Z.req u := get(U) if end(u) != 0 { done = true } Z.dat <- mul(i2tor(1, int64(i)), u) } Z.dat <- finis }(c, U, Z) return Z } // Binomial theorem (1+x)^c func Binom(c *rat) PS { Z := mkPS() go func(c *rat, Z PS) { n := 1 t := itor(1) for c.num != 0 { put(t, Z) t = mul(mul(t, c), i2tor(1, int64(n))) c = sub(c, one)
Registered: Wed Jun 12 16:32:35 UTC 2024 - Last Modified: Wed Mar 25 22:22:20 UTC 2020 - 13.3K bytes - Viewed (0) -
src/crypto/ecdsa/ecdsa.go
panic("ecdsa: internal error: P256OrdInverse produced an invalid value") } return } } // Calculate the inverse of s in GF(N) using Fermat's method // (exponentiation modulo P - 2, per Euler's theorem) kInv.Exp(k, c.nMinus2, c.N) } // hashToNat sets e to the left-most bits of hash, according to // SEC 1, Section 4.1.3, point 5 and Section 4.1.4, point 3.
Registered: Wed Jun 12 16:32:35 UTC 2024 - Last Modified: Thu May 23 00:11:18 UTC 2024 - 20.4K bytes - Viewed (0) -
src/crypto/rsa/rsa.go
// complexity. CRTValues []CRTValue n, p, q *bigmod.Modulus // moduli for CRT with Montgomery precomputed constants } // CRTValue contains the precomputed Chinese remainder theorem values. type CRTValue struct { Exp *big.Int // D mod (prime-1). Coeff *big.Int // R·Coeff ≡ 1 mod Prime. R *big.Int // product of primes prior to this (inc p and q). }
Registered: Wed Jun 12 16:32:35 UTC 2024 - Last Modified: Thu May 23 00:11:18 UTC 2024 - 23.4K bytes - Viewed (0) -
src/crypto/internal/nistec/p256_asm.go
return q } // p256Inverse sets out to in⁻¹ mod p. If in is zero, out will be zero. func p256Inverse(out, in *p256Element) { // Inversion is calculated through exponentiation by p - 2, per Fermat's // little theorem. // // The sequence of 12 multiplications and 255 squarings is derived from the // following addition chain generated with github.com/mmcloughlin/addchain // v0.4.0. // // _10 = 2*1
Registered: Wed Jun 12 16:32:35 UTC 2024 - Last Modified: Mon May 13 18:57:38 UTC 2024 - 21.4K bytes - Viewed (0) -
src/math/big/nat.go
} // expNNMontgomeryEven calculates x**y mod m where m = m1 × m2 for m1 = 2ⁿ and m2 odd. // It uses two recursive calls to expNN for x**y mod m1 and x**y mod m2 // and then uses the Chinese Remainder Theorem to combine the results. // The recursive call using m1 will use expNNWindowed, // while the recursive call using m2 will use expNNMontgomery. // For more details, see Ç. K. Koç, “Montgomery Reduction with Even Modulus”,
Registered: Wed Jun 12 16:32:35 UTC 2024 - Last Modified: Mon May 13 21:31:58 UTC 2024 - 31.7K bytes - Viewed (0) -
src/math/big/natdiv.go
n-by-n-digit multiplication algorithm requires O(n²) time, making the overall algorithm require time T(n) where T(n) = 2T(n/2) + O(n) + O(n²) which, by the Bentley-Haken-Saxe theorem, ends up reducing to T(n) = O(n²). This is not an improvement over regular long division. When the number of digits n becomes large enough, Karatsuba's algorithm for
Registered: Wed Jun 12 16:32:35 UTC 2024 - Last Modified: Thu Mar 14 17:02:38 UTC 2024 - 34.4K bytes - Viewed (0)