Golang Rand.Intn方法代码示例

func testRandomSimplex(t *testing.T, nTest int, pZero float64, maxN int, rnd *rand.Rand) {
	// Try a bunch of random LPs
	for i := 0; i < nTest; i++ {
		n := rnd.Intn(maxN) + 2 // n must be at least two.
		m := rnd.Intn(n-1) + 1  // m must be between 1 and n
		if m == 0 || n == 0 {
			continue
		}
		randValue := func() float64 {
			//var pZero float64
			v := rnd.Float64()
			if v < pZero {
				return 0
			}
			return rnd.NormFloat64()
		}
		a := mat64.NewDense(m, n, nil)
		for i := 0; i < m; i++ {
			for j := 0; j < n; j++ {
				a.Set(i, j, randValue())
			}
		}
		b := make([]float64, m)
		for i := range b {
			b[i] = randValue()
		}

		c := make([]float64, n)
		for i := range c {
			c[i] = randValue()
		}

		testSimplex(t, nil, c, a, b, convergenceTol)
	}
}

func makedata(minsize int, dice *rand.Rand) string {
	b := make([]rune, minsize+dice.Intn(minsize))
	for i := range b {
		b[i] = letters[dice.Intn(len(letters))]
	}
	return string(b)
}

func throw(g *rand.Rand, edge_amount, throws_amount int) int {
	var result int = 0
	for i := 0; i < throws_amount; i++ {
		result += g.Intn(edge_amount) + 1
	}
	return result
}

func randomMemory(rng *rand.Rand) *MemoryRegion {
	var mr *MemoryRegion
	var err error
	options := 3
	if tmpfsBuf != nil && hugeBuf != nil {
		options += 2
	}
	switch rng.Intn(options) {
	case 0:
		mr, err = AllocateMemory(4096)
	case 1:
		mr, err = AllocateMemory(65536)
	case 2:
		mr, err = AllocateMemory(1048576)
	case 3:
		mr, err = RegisterMemory(tmpfsBuf.Bytes())
	case 4:
		mr, err = RegisterMemory(hugeBuf.Bytes())
	default:
		panic("invalid mode")
	}
	if err != nil {
		panic(err)
	}
	return mr
}

// There are lots of ways of doing this faster, but this is good
// enough.
func RandomString(rng *rand.Rand, size int) string {
	out := make([]byte, size)
	for i := 0; i < size; i++ {
		out[i] = alphabet[rng.Intn(size)]
	}
	return string(out)
}

// iterate through the deck, and swap values with
// a random card from another location in the deck
func (sd *StandardDeck) Shuffle(r *rand.Rand) {
	s := sd.Size()
	for k := range sd.cards {
		i := r.Intn(s)
		sd.cards[k], sd.cards[i] = sd.cards[i], sd.cards[k]
	}
}

func (c *STChain) GenerateSlice(max int, r *rand.Rand) []string {
	var s []string
	var p STPrefix

	for i := 0; i < max; i++ {
		suffix := c.Chain[p]
		if suffix.Count == 0 {
			return s
		}

		j := r.Intn(suffix.Count)

		for word, freq := range suffix.Words {
			j -= freq
			if j < 0 {
				if word == 0 {
					return s
				}

				p.shift(word)
				s = append(s, c.Strings[word])
			}
		}
	}

	return s
}

func (ss *SessionScenario) NextCall(rg *rand.Rand) (*Call, error) {
	for {
		if i := rg.Intn(ss.SessionAmount); i >= 0 {
			select {
			case st := <-ss._sessions[i].StepLock:
				switch st {
				case STEP1:
					if ss._sessions[i]._calls[st].GenParam != nil {
						ss._sessions[i]._calls[st].Method, ss._sessions[i]._calls[st].Type, ss._sessions[i]._calls[st].URL, ss._sessions[i]._calls[st].Body = ss._sessions[i]._calls[st].GenParam()
					}
					// execute session call for the first time
					return ss._sessions[i]._calls[st], nil
				default:
					// choose a non-initialized call randomly
					ss._sessions[i].StepLock <- REST
					q := rg.Float32() * ss._sessions[i]._totalWeight
					for j := STEP1 + 1; j < ss._sessions[i]._count; j++ {
						if q <= ss._sessions[i]._calls[j].RandomWeight {
							if ss._sessions[i]._calls[j].GenParam != nil {
								ss._sessions[i]._calls[j].Method, ss._sessions[i]._calls[j].Type, ss._sessions[i]._calls[j].URL, ss._sessions[i]._calls[j].Body = ss._sessions[i]._calls[j].GenParam()
							}
							return ss._sessions[i]._calls[j], nil
						}
					}
				}
			default:
				continue
			}
		}
	}

	log.Fatal("what? should never reach here")
	return nil, errors.New("all sessions are being initialized")
}

func (self *LSystem) PickRule(name string, random *rand.Rand) int {

	// Sum up the weights of all rules with this name:
	var sum int = 0
	for _, rule := range self.Rules {
		if rule.Name != name {
			continue
		}
		weight := rule.Weight
		sum += weight
	}

	// Choose a rule at random:
	n := random.Intn(sum)
	for i, rule := range self.Rules {
		if rule.Name != name {
			continue
		}
		weight := rule.Weight
		if n < weight {
			return i
		}
		n -= weight
	}

	fmt.Println("Error.")
	return -1
}

// Apply partially mixed crossover.
func (c CrossPMX) Apply(p1 Individual, p2 Individual, rng *rand.Rand) (Individual, Individual) {
	var (
		nbGenes = len(p1.Genome)
		o1      = makeIndividual(nbGenes, rng)
		o2      = makeIndividual(nbGenes, rng)
	)
	copy(o1.Genome, p1.Genome)
	copy(o2.Genome, p2.Genome)
	// Choose a random crossover point p such that 0 < p < (nbGenes - 1)
	var (
		p = rng.Intn(nbGenes-2) + 1
		a int
		b int
	)
	// Paste the father's genome up to the crossover point
	for i := 0; i < p; i++ {
		// Find where the second parent's gene is in the first offspring's genome
		a = getIndex(p2.Genome[i], o1.Genome)
		// Swap the genes
		o1.Genome[a], o1.Genome[i] = o1.Genome[i], p2.Genome[i]
		// Find where the first parent's gene is in the second offspring's genome
		b = getIndex(p1.Genome[i], o2.Genome)
		// Swap the genes
		o2.Genome[b], o2.Genome[i] = o2.Genome[i], p1.Genome[i]
	}
	return o1, o2
}

func randCoord(r *rand.Rand) []int {
	var coord []int = make([]int, 3)
	coord[0] = r.Intn(S_MAP)
	coord[1] = r.Intn(S_MAP)
	coord[2] = r.Intn(S_MAP)
	return coord
}

func replaceLabels(l *lexer, r *rand.Rand) string {
	var buf bytes.Buffer
	var labelCounter uint
	var remLabels []uint

	for i := l.nextItem(); i.typ != itemEOF; i = l.nextItem() {
		switch i.typ {
		case itemText:
			buf.WriteString(i.val)
		case itemLabel:
			buf.WriteString("label")
			buf.WriteString(strconv.Itoa(int(labelCounter)))
			remLabels = append(remLabels, labelCounter)
			labelCounter++
		case itemNewLine:
			buf.WriteString("\n")

			// randomly put a label here, if any
			if len(remLabels) > 0 && r.Intn(8) == 0 {
				buf.WriteString("label")
				buf.WriteString(strconv.Itoa(int(remLabels[0])))
				buf.WriteString(":\n")
				remLabels = remLabels[1:]
			}
		}
	}

	for _, l := range remLabels {
		buf.WriteString("label")
		buf.WriteString(strconv.Itoa(int(l)))
		buf.WriteString(":\n")
	}

	return buf.String()
}

// randomColor returns a random RGB color from a random seed.
func randomColor(seed *rand.Rand) color.RGBA {
	return color.RGBA{
		uint8(seed.Intn(255)),
		uint8(seed.Intn(255)),
		uint8(seed.Intn(255)),
		0xff} // No alpha.
}

// ensureExits makes sure there is an outside exit on two sides
// of the room. The corners are left alone.
func (rms *rooms) ensureExits(random *rand.Rand, rm *room) {
	var top, bot, left, right []*cell
	xmax, ymax := rm.w, rm.h
	for x := rm.x + 1; x < rm.x+rm.w-1; x++ {
		u := rms.cells[x][rm.y]
		if u.isWall {
			top = append(top, u)
		}
		u = rms.cells[x][rm.y+rm.h-1]
		if u.isWall {
			bot = append(bot, u)
		}
	}
	for y := rm.y + 1; y < rm.y+rm.h-1; y++ {
		u := rms.cells[rm.x][y]
		if u.isWall {
			left = append(left, u)
		}
		u = rms.cells[rm.x+rm.w-1][y]
		if u.isWall {
			right = append(right, u)
		}
	}

	// randomize which sides get exits.
	if random.Intn(2) == 0 {
		rms.ensureExit(random, top, xmax-2)
		rms.ensureExit(random, left, ymax-2)
	} else {
		rms.ensureExit(random, bot, xmax-2)
		rms.ensureExit(random, right, ymax-2)
	}
}

func (s *sim) run(t *testing.T, rng *rand.Rand) {
	dbg(s.graph.Graph().Map())

	step := 0
	for len(s.pending) > 0 {
		if step > 1000000 {
			t.Fatal("non-convergence")
		}
		step++

		// Maybe add or remove a link
		if rng.Intn(100) == 0 {
			e := s.graph.RandomEdge(rng)
			if s.graph.Contains(e) {
				s.graph.Remove(e)

				// Check that the graph did not become
				// disconnected.
				if s.graph.Graph().Connected() {
					dbg("Disconnecting", e)
					s.disconnect(e)
				} else {
					s.graph.Add(e)
				}
			} else {
				dbg("Connecting", e)
				s.graph.Add(e)
				s.link(e)
			}
		}

		// Propagate an update
		i := rng.Intn(len(s.pending))
		l := s.pending[i]
		s.pending[i] = s.pending[len(s.pending)-1]
		s.pending = s.pending[:len(s.pending)-1]

		if l.closed {
			continue
		}

		for prop, updates := range l.sender.Outgoing() {
			dbg(l.sender.c.id, "->", l.receiver.c.id, ":", updates)
			l.receiver.Incoming(l.receiver.c.ConnectivityPropagation(), updates)
			l.sender.Delivered(prop, updates)
		}
	}

	var expect map[NodeID]interface{}
	var expectNode NodeID
	for _, node := range s.graph.Nodes {
		c := s.cs[node]
		if expect == nil {
			expect = c.Dump()
			expectNode = node
		} else {
			require.Equal(t, expect, c.Dump(), "mismatch %s %s", expectNode, node)
		}
	}
}