func randomData(r *rand.Rand, bytes int) []byte {
data := make([]byte, bytes)
for i, _ := range data {
data[i] = byte(r.Uint32() % 256)
}
return data
}
// random creates a random integer in [0..limit), using the space in z if
// possible. n is the bit length of limit.
func (z nat) random(rand *rand.Rand, limit nat, n int) nat {
if alias(z, limit) {
z = nil // z is an alias for limit - cannot reuse
}
z = z.make(len(limit))
bitLengthOfMSW := uint(n % _W)
if bitLengthOfMSW == 0 {
bitLengthOfMSW = _W
}
mask := Word((1 << bitLengthOfMSW) - 1)
for {
switch _W {
case 32:
for i := range z {
z[i] = Word(rand.Uint32())
}
case 64:
for i := range z {
z[i] = Word(rand.Uint32()) | Word(rand.Uint32())<<32
}
default:
panic("unknown word size")
}
z[len(limit)-1] &= mask
if z.cmp(limit) < 0 {
break
}
}
return z.norm()
}
func MakeRandom(gen *rand.Rand, degree int) *Polynomial {
if degree == 0 {
return NewPolynomialFromInt(gen.Int63n(2))
}
coeffs := new(big.Int)
// x^0 + x^1 + ... + x^n => n + 1 terms
// However, only the first n terms are variable. (x^n is fixed to
// have degree n.) Thus, we randomly generate the first n terms
// and fix the final term x^n.
numBits := degree
numBlocks := numBits / 32
for ii := 0; ii < numBlocks; ii++ {
v := gen.Uint32()
// Merge.
bigV := big.NewInt(int64(v))
coeffs.Lsh(coeffs, 32).Or(coeffs, bigV)
}
// Handle the remainder.
numRemainingBits := uint(numBits % 32)
if numRemainingBits > 0 {
mask := (int64(1) << numRemainingBits) - 1
v := int64(gen.Uint32()) & mask
coeffs.Lsh(coeffs, numRemainingBits).Or(coeffs, big.NewInt(v))
}
coeffs.SetBit(coeffs, degree, 1)
return NewPolynomial(uint(degree), coeffs)
}
func (_ Test) Xer() {
var rng *rand.Rand
rng = rand.New(xer.New(time.Now().UnixNano(), 256))
resultI := make([]uint8, 70)
for i, _ := range resultI {
resultI[i] = uint8(rng.Uint32()) >> 4
}
e.InfoLog.Println("Xer Random: ", resultI)
}
// Generate implements testing/quick.Generator.
func (h Hash) Generate(rand *rand.Rand, size int) reflect.Value {
m := rand.Intn(len(h))
for i := len(h) - 1; i > m; i-- {
h[i] = byte(rand.Uint32())
}
return reflect.ValueOf(h)
}
func (NodeID) Generate(rand *rand.Rand, size int) reflect.Value {
var id NodeID
m := rand.Intn(len(id))
for i := len(id) - 1; i > m; i-- {
id[i] = byte(rand.Uint32())
}
return reflect.ValueOf(id)
}
// Construct new Bloom filter with given number of buckets and hashes.
//
// The random seed r is used to construct the hash functions.
// The number of buckets will be rounded up to a multiple of 32.
//
// Returns nil and an error if the number of buckets exceeds (1<<32)-1.
func New32(nbuckets, nhashes int, r *rand.Rand) (f *Filter32, err error) {
// Round to next multiple of 32.
nmod32 := nbuckets & ((1 << 5) - 1)
if nmod32 != 0 {
nbuckets += 32 - nmod32
}
if nbuckets > math.MaxUint32 {
err = fmt.Errorf("nbuckets = %d (after rounding) too large", nbuckets)
return
}
seeds := make([]uint32, nhashes)
for i := range seeds {
seeds[i] = r.Uint32()
}
f = &Filter32{make([]uint32, nbuckets>>5), seeds}
return
}
func TestBloomFilter(r *rand.Rand, size, numAdd, numSample, numHash uint) {
falsePositive := 0
falseNegative := 0 // should not occur!
truePositive := 0
trueNegative := 0
iterations := 10000
for iteration := 0; iteration < iterations; iteration++ {
hashes := make([]uint64, numHash, numHash)
for i := uint(0); i < numHash; i++ {
hashes[i] = uint64(r.Uint32())
}
bloom := New(size, hashes)
realset := make(map[uint64]bool)
generate := func() uint64 {
return uint64(r.Int63())
}
for i := uint(0); i < numAdd; i++ {
generated := generate()
bloom.Add(generated)
realset[generated] = true
}
for i := uint(0); i < numSample; i++ {
generated := generate()
bloomResult := bloom.MaybeContains(generated)
_, realResult := realset[generated]
if bloomResult && realResult {
truePositive++
} else if !bloomResult && !realResult {
trueNegative++
} else if bloomResult && !realResult {
falsePositive++
} else if !bloomResult && realResult {
falseNegative++
}
}
}
fmt.Printf(" %12d %12d %12d | %02.4f\n", size, numAdd, numHash,
float32(falsePositive)/float32(numSample)*100/float32(iterations),
)
}
// Rand sets z to a pseudo-random number in [0, n) and returns z.
func (z *Int) Rand(rnd *rand.Rand, n *Int) *Int {
z.doinit()
// Get rid of n <= 0 case
if n.Sign() <= 0 {
z.SetInt64(0)
return z
}
// Make a copy of n if aliased
t := n
aliased := false
if n == z {
aliased = true
t = new(Int).Set(n)
}
// Work out bit sizes and masks
bits := n.BitLen() // >= 1
nwords := (bits + 31) / 32 // >= 1
bitLengthOfMSW := uint(bits % 32)
if bitLengthOfMSW == 0 {
bitLengthOfMSW = 32
}
mask := uint32((1 << bitLengthOfMSW) - 1)
words := make([]uint32, nwords)
for {
// Make a most significant first array of random bytes
for i := 0; i < nwords; i++ {
words[i] = rnd.Uint32()
}
// Mask out the top bits so this is only just bigger than n
words[0] &= mask
C.mpz_import(&z.i[0], C.size_t(len(words)), 1, 4, 0, 0, unsafe.Pointer(&words[0]))
// Exit if z < n - should take ~1.5 iterations of loop on average
if z.Cmp(t) < 0 {
break
}
}
if aliased {
t.Clear()
}
return z
}
func randBytes(
r *rand.Rand,
n int) (b []byte) {
b = make([]byte, n)
fullWords := n / 4
remainder := n % 4
for i := 0; i < fullWords; i++ {
u32 := r.Uint32()
b[4*i+0] = byte((u32 >> 0) & 0xff)
b[4*i+1] = byte((u32 >> 8) & 0xff)
b[4*i+2] = byte((u32 >> 16) & 0xff)
b[4*i+3] = byte((u32 >> 24) & 0xff)
}
for i := 0; i < remainder; i++ {
b[4*fullWords+i] = byte(r.Uint32())
}
return
}
func NewFromRandom(r *rand.Rand) *Number160 {
// there is no rand.Uint64(). Seems that it was forgotten:
// https://groups.google.com/forum/#!topic/golang-nuts/Kle874lT1Eo
u1 := uint64(r.Uint32())<<32 + uint64(r.Uint32())
u2 := uint64(r.Uint32())<<32 + uint64(r.Uint32())
return &Number160{u1, u2, r.Uint32()}
}
func randBytes(r *rand.Rand, b []byte) {
for i := range b {
b[i] = byte(r.Uint32())
}
}
func (k *Int64Key) random(r *rand.Rand) {
k.i = uint64(r.Uint32()) + uint64(r.Uint32())<<32
}
func (k *Int32Key) random(r *rand.Rand) {
k.i = r.Uint32()
}
func rand8(rnd *rand.Rand) uint8 {
return uint8(rnd.Uint32() >> 24)
}
func randomIPv4Address(b *testing.B, r *rand.Rand) net.IP {
num := r.Uint32()
return []byte{byte(num >> 24), byte(num >> 16), byte(num >> 8),
byte(num)}
}
func rand16(rnd *rand.Rand) uint16 {
return uint16(rnd.Uint32() >> 16)
}
func rand32(rnd *rand.Rand) uint32 {
return rnd.Uint32()
}
func randomInt(rand *rand.Rand) *big.Int {
return new(big.Int).SetInt64(int64(int32(rand.Uint32())))
}
// randUint64 makes random 64 bit numbers.
// Weirdly, rand doesn't have a function that gives you 64 random bits.
func randUint64(r *rand.Rand) uint64 {
return uint64(r.Uint32())<<32 | uint64(r.Uint32())
}
func randUint64(rnd *rand.Rand) uint64 {
return uint64(rnd.Uint32())<<32 + uint64(rnd.Uint32())
}