// randFloat32 generates a random float taking the full range of a float32. func randFloat32(rand *rand.Rand) float32 { f := rand.Float64() * math.MaxFloat32 if rand.Int()&1 == 1 { f = -f } return float32(f) }
// randomN creates a random integer in [0..limit), using the space in z if // possible. n is the bit length of limit. func randomN(z []Word, rand *rand.Rand, limit []Word, n int) []Word { bitLengthOfMSW := uint(n % _W) if bitLengthOfMSW == 0 { bitLengthOfMSW = _W } mask := Word((1 << bitLengthOfMSW) - 1) z = makeN(z, len(limit), false) for { for i := range z { switch _W { case 32: z[i] = Word(rand.Uint32()) case 64: z[i] = Word(rand.Uint32()) | Word(rand.Uint32())<<32 } } z[len(limit)-1] &= mask if cmpNN(z, limit) < 0 { break } } return normN(z) }
// MontePathIn computes montecarlo distribution and flow for pathing // in to the set minimum depth, N samples per start location. func (f *Fill) MontePathIn(r *rand.Rand, start []Location, N int, MinDepth uint16) (dist []int, flow [][4]int) { dist = make([]int, len(f.Depth)) flow = make([][4]int, len(f.Depth)) for _, origloc := range start { for n := 0; n < N; n++ { loc := origloc d := 0 for d < 4 { depth := f.Depth[loc] nperm := r.Intn(24) for d = 0; d < 4; d++ { nloc := f.LocStep[loc][Perm4[nperm][d]] if f.Depth[nloc] < depth && f.Depth[nloc] > MinDepth { flow[loc][Perm4[nperm][d]]++ loc = nloc dist[loc]++ break } } } } } return }
// randFloat64 generates a random float taking the full range of a float64. func randFloat64(rand *rand.Rand) float64 { f := rand.Float64() if rand.Int()&1 == 1 { f = -f } return f }
func (p *Trie) outputDot(vec *vector.StringVector, rune int, serial int64, rgen *rand.Rand) { this := make([]byte, 10) child := make([]byte, 10) utf8.EncodeRune(this, rune) thisChar := string(this[0]) if serial == -1 { thisChar = "root" } for childRune, childNode := range p.children { utf8.EncodeRune(child, childRune) childSerial := rgen.Int63() childNodeStr := fmt.Sprintf("\"%s(%d)\"", string(child[0]), childSerial) var notation string if string(child[0]) == "/" { notation = fmt.Sprintf("[label=\"%s\" shape=box color=red]", string(child[0])) } else { notation = fmt.Sprintf("[label=\"%s\"]", string(child[0])) } vec.Push(fmt.Sprintf("\t%s %s\n\t\"%s(%d)\" -> \"%s(%d)\"", childNodeStr, notation, thisChar, serial, string(child[0]), childSerial)) childNode.outputDot(vec, childRune, childSerial, rgen) } }
// 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 { bitLengthOfMSW := uint(n % _W) if bitLengthOfMSW == 0 { bitLengthOfMSW = _W } mask := Word((1 << bitLengthOfMSW) - 1) z = z.make(len(limit)) for { for i := range z { switch _W { case 32: z[i] = Word(rand.Uint32()) case 64: z[i] = Word(rand.Uint32()) | Word(rand.Uint32())<<32 } } z[len(limit)-1] &= mask if z.cmp(limit) < 0 { break } } return z.norm() }
func (*certificateMsg) Generate(rand *rand.Rand, size int) reflect.Value { m := &certificateMsg{} numCerts := rand.Intn(20) m.certificates = make([][]byte, numCerts) for i := 0; i < numCerts; i++ { m.certificates[i] = randomBytes(rand.Intn(10)+1, rand) } return reflect.ValueOf(m) }
func (*certificateRequestMsg) Generate(rand *rand.Rand, size int) reflect.Value { m := &certificateRequestMsg{} m.certificateTypes = randomBytes(rand.Intn(5)+1, rand) numCAs := rand.Intn(100) m.certificateAuthorities = make([][]byte, numCAs) for i := 0; i < numCAs; i++ { m.certificateAuthorities[i] = randomBytes(rand.Intn(15)+1, rand) } return reflect.ValueOf(m) }
func (*certificateStatusMsg) Generate(rand *rand.Rand, size int) reflect.Value { m := &certificateStatusMsg{} if rand.Intn(10) > 5 { m.statusType = statusTypeOCSP m.response = randomBytes(rand.Intn(10)+1, rand) } else { m.statusType = 42 } return reflect.ValueOf(m) }
func randomNameList(rand *rand.Rand) []string { ret := make([]string, rand.Int31()&15) for i := range ret { s := make([]byte, 1+(rand.Int31()&15)) for j := range s { s[j] = 'a' + uint8(rand.Int31()&15) } ret[i] = string(s) } return ret }
func choose(fork forkChoice, random *rand.Rand) { pivot := random.Float64() * fork.TotalMass() fork.Reset() for prob, _, ok := fork.Next(); ok; prob, _, ok = fork.Next() { pivot -= prob if pivot <= 0.0 { fork.Pick() return } } }
// Sample returns N random points sampled from a fill with step // distance between low and hi inclusive. it will return a count > 1 // if the sample size is smaller than N. If n < 1 then return all // points. func (f *Fill) Sample(r *rand.Rand, n, low, high int) ([]Location, []int) { pool := make([]Location, 0, 200) lo, hi := uint16(low), uint16(high) for i, depth := range f.Depth { if depth >= lo && depth <= hi { pool = append(pool, Location(i)) } } if n < 1 { return pool, nil } if len(pool) == 0 { return nil, nil } over := n / len(pool) perm := r.Perm(len(pool))[0 : n%len(pool)] if Debug[DBG_Sample] { log.Printf("Sample: Looking for %d explore points %d-%d, have %d possible", n, low, hi, len(pool)) } var count []int if over > 0 { count = make([]int, len(pool)) for i := range count { count[i] = over } } else { count = make([]int, len(perm)) } for i := range perm { count[i]++ } if over > 0 { return pool, count } else { pout := make([]Location, len(perm)) for i, pi := range perm { if Debug[DBG_Sample] { log.Printf("Sample: adding location %d to output pool", pool[pi]) } pout[i] = pool[pi] } return pout, count } return nil, nil }
func (*clientHelloMsg) Generate(rand *rand.Rand, size int) reflect.Value { m := &clientHelloMsg{} m.major = uint8(rand.Intn(256)) m.minor = uint8(rand.Intn(256)) m.random = randomBytes(32, rand) m.sessionId = randomBytes(rand.Intn(32), rand) m.cipherSuites = make([]uint16, rand.Intn(63)+1) for i := 0; i < len(m.cipherSuites); i++ { m.cipherSuites[i] = uint16(rand.Int31()) } m.compressionMethods = randomBytes(rand.Intn(63)+1, rand) return reflect.NewValue(m) }
func randomBytes(n int, rand *rand.Rand) []byte { r := make([]byte, n) for i := 0; i < n; i++ { r[i] = byte(rand.Int31()) } return r }
func (b Bitmask) Generate(rand *rand.Rand, size int) reflect.Value { result := Bitmask{ x: size - rand.Intn(size), y: size - rand.Intn(size), w: rand.Intn(size), h: rand.Intn(size), } result.lines = make([][]part, result.h) completeness := rand.Intn(size) for y := 0; y < result.h; y++ { result.lines[y] = make([]part, result.w/sz+1) for x := 0; x < result.w; x++ { result.SetRel(x, y, rand.Intn(completeness) == 0) } } return reflect.NewValue(result) }
func (*clientHelloMsg) Generate(rand *rand.Rand, size int) reflect.Value { m := &clientHelloMsg{} m.vers = uint16(rand.Intn(65536)) m.random = randomBytes(32, rand) m.sessionId = randomBytes(rand.Intn(32), rand) m.cipherSuites = make([]uint16, rand.Intn(63)+1) for i := 0; i < len(m.cipherSuites); i++ { m.cipherSuites[i] = uint16(rand.Int31()) } m.compressionMethods = randomBytes(rand.Intn(63)+1, rand) if rand.Intn(10) > 5 { m.nextProtoNeg = true } if rand.Intn(10) > 5 { m.serverName = randomString(rand.Intn(255), rand) } m.ocspStapling = rand.Intn(10) > 5 return reflect.NewValue(m) }
func (*kexInitMsg) Generate(rand *rand.Rand, size int) reflect.Value { ki := &kexInitMsg{} randomBytes(ki.Cookie[:], rand) ki.KexAlgos = randomNameList(rand) ki.ServerHostKeyAlgos = randomNameList(rand) ki.CiphersClientServer = randomNameList(rand) ki.CiphersServerClient = randomNameList(rand) ki.MACsClientServer = randomNameList(rand) ki.MACsServerClient = randomNameList(rand) ki.CompressionClientServer = randomNameList(rand) ki.CompressionServerClient = randomNameList(rand) ki.LanguagesClientServer = randomNameList(rand) ki.LanguagesServerClient = randomNameList(rand) if rand.Int31()&1 == 1 { ki.FirstKexFollows = true } return reflect.ValueOf(ki) }
func (s *shadowMap) Init(corr_dist float64, Rgen2 *rand.Rand) { nval := int(Field / corr_dist / shadow_sampling) //fmt.Println(" shadowMap down Sampling ", shadow_sampling, " ", nval) s.xcos = make([]float64, nval) s.ycos = make([]float64, nval) s.xsin = make([]float64, nval) s.ysin = make([]float64, nval) for i := 0; i < nval; i++ { s.xcos[i] = Rgen2.NormFloat64() //s.xcos[i] *= s.xcos[i] s.ycos[i] = Rgen2.NormFloat64() s.xsin[i] = Rgen2.Float64() * 2 * math.Pi s.ysin[i] = Rgen2.Float64() * 2 * math.Pi if s.xcos[i] < mval { s.xcos[i] = 0 } if s.ycos[i] < mval { s.ycos[i] = 0 } s.power += s.xcos[i] * s.xcos[i] s.power += s.ycos[i] * s.ycos[i] } s.power = math.Sqrt(s.power) / shadow_deviance for i := 0; i < nval; i++ { s.xcos[i] /= s.power s.ycos[i] /= s.power } s.smap = make([][]float32, mapsize) for i := 0; i < mapsize; i++ { s.smap[i] = make([]float32, mapsize) x := (float64(i) - mapsize/2) / mapres for j := 0; j < mapsize; j++ { d := geom.Pos{x, (float64(j) - mapsize/2) / mapres} s.smap[i][j] = float32(s.evalShadowFadingDirect(d)) //lets not have -Inf here if s.smap[i][j] < 0.0000001 { s.smap[i][j] = 0.0000001 } } } }
func (*serverHelloMsg) Generate(rand *rand.Rand, size int) reflect.Value { m := &serverHelloMsg{} m.vers = uint16(rand.Intn(65536)) m.random = randomBytes(32, rand) m.sessionId = randomBytes(rand.Intn(32), rand) m.cipherSuite = uint16(rand.Int31()) m.compressionMethod = uint8(rand.Intn(256)) if rand.Intn(10) > 5 { m.nextProtoNeg = true n := rand.Intn(10) m.nextProtos = make([]string, n) for i := 0; i < n; i++ { m.nextProtos[i] = randomString(20, rand) } } return reflect.ValueOf(m) }
// Value returns an arbitrary value of the given type. // If the type implements the Generator interface, that will be used. // Note: in order to create arbitrary values for structs, all the members must be public. func Value(t reflect.Type, rand *rand.Rand) (value reflect.Value, ok bool) { if m, ok := reflect.Zero(t).Interface().(Generator); ok { return m.Generate(rand, complexSize), true } switch concrete := t; concrete.Kind() { case reflect.Bool: return reflect.ValueOf(rand.Int()&1 == 0), true case reflect.Float32: return reflect.ValueOf(randFloat32(rand)), true case reflect.Float64: return reflect.ValueOf(randFloat64(rand)), true case reflect.Complex64: return reflect.ValueOf(complex(randFloat32(rand), randFloat32(rand))), true case reflect.Complex128: return reflect.ValueOf(complex(randFloat64(rand), randFloat64(rand))), true case reflect.Int16: return reflect.ValueOf(int16(randInt64(rand))), true case reflect.Int32: return reflect.ValueOf(int32(randInt64(rand))), true case reflect.Int64: return reflect.ValueOf(randInt64(rand)), true case reflect.Int8: return reflect.ValueOf(int8(randInt64(rand))), true case reflect.Int: return reflect.ValueOf(int(randInt64(rand))), true case reflect.Uint16: return reflect.ValueOf(uint16(randInt64(rand))), true case reflect.Uint32: return reflect.ValueOf(uint32(randInt64(rand))), true case reflect.Uint64: return reflect.ValueOf(uint64(randInt64(rand))), true case reflect.Uint8: return reflect.ValueOf(uint8(randInt64(rand))), true case reflect.Uint: return reflect.ValueOf(uint(randInt64(rand))), true case reflect.Uintptr: return reflect.ValueOf(uintptr(randInt64(rand))), true case reflect.Map: numElems := rand.Intn(complexSize) m := reflect.MakeMap(concrete) for i := 0; i < numElems; i++ { key, ok1 := Value(concrete.Key(), rand) value, ok2 := Value(concrete.Elem(), rand) if !ok1 || !ok2 { return reflect.Value{}, false } m.SetMapIndex(key, value) } return m, true case reflect.Ptr: v, ok := Value(concrete.Elem(), rand) if !ok { return reflect.Value{}, false } p := reflect.New(concrete.Elem()) p.Elem().Set(v) return p, true case reflect.Slice: numElems := rand.Intn(complexSize) s := reflect.MakeSlice(concrete, numElems, numElems) for i := 0; i < numElems; i++ { v, ok := Value(concrete.Elem(), rand) if !ok { return reflect.Value{}, false } s.Index(i).Set(v) } return s, true case reflect.String: numChars := rand.Intn(complexSize) codePoints := make([]int, numChars) for i := 0; i < numChars; i++ { codePoints[i] = rand.Intn(0x10ffff) } return reflect.ValueOf(string(codePoints)), true case reflect.Struct: s := reflect.New(t).Elem() for i := 0; i < s.NumField(); i++ { v, ok := Value(concrete.Field(i).Type, rand) if !ok { return reflect.Value{}, false } s.Field(i).Set(v) } return s, true default: return reflect.Value{}, false } return }
// Return a set of directions with d first, opposite last an the other 3 permuted. func Permute5D(d Direction, r *rand.Rand) *[5]Direction { return &PermStepD5[d][r.Intn(6)] }
// Draw from the arrays with rand.Intn(120) for a random permutation of directions including NoMovement func Permute5(r *rand.Rand) *[5]Direction { return &Perm5[r.Intn(120)] }
// Returns a permute4 + guard used in eg NPathIn func Permute4G(r *rand.Rand) *[5]Direction { return &Perm4G[r.Intn(24)] }
// Draw from the arrays with rand.Intn(24) for a random permutation of directions. func Permute4(r *rand.Rand) *[4]Direction { return &Perm4[r.Intn(24)] }
// randVector generates a random vector whose components are each in the range // [-1, 1). The dimensionality of the vector is len(c). func randVector(c []float64, rnd *rand.Rand) { for i := range c { c[i] = 2*rnd.Float64() - 1 } }
func (*nextProtoMsg) Generate(rand *rand.Rand, size int) reflect.Value { m := &nextProtoMsg{} m.proto = randomString(rand.Intn(255), rand) return reflect.ValueOf(m) }
func (*clientKeyExchangeMsg) Generate(rand *rand.Rand, size int) reflect.Value { m := &clientKeyExchangeMsg{} m.ciphertext = randomBytes(rand.Intn(1000)+1, rand) return reflect.ValueOf(m) }
func (p Player) performance(r *rand.Rand) float64 { dev := (r.Float64()*2.0 - 1.0) dev = math.Fabs(dev) * dev * p.dev return p.mean + dev }
func (*certificateVerifyMsg) Generate(rand *rand.Rand, size int) reflect.Value { m := &certificateVerifyMsg{} m.signature = randomBytes(rand.Intn(15)+1, rand) return reflect.ValueOf(m) }
// randInt64 returns a random integer taking half the range of an int64. func randInt64(rand *rand.Rand) int64 { return rand.Int63() - 1<<62 }