func init() { rand.Seed(time.Now().UnixNano()) http.HandleFunc("/dirtexto", directorioTexto) //http.HandleFunc("/carr", carr) http.HandleFunc("/carr", carrVip) rand.Seed(time.Now().UnixNano()) }
// Start the agent-based model func (m *Model) Start() error { if m.running { return errors.New("Model: Start() failed: model already running") } m.running = true if m.RNGRandomSeed { rand.Seed(time.Now().UnixNano()) } else { rand.Seed(m.RNGSeedVal) } timestamp := fmt.Sprintf("%s", time.Now()) m.popCpPrey = GenerateCpPreyPopulation(m.CpPreyPopulationStart, m.numCpPreyCreated, m.Turn, m.ConditionParams, timestamp) m.numCpPreyCreated += m.CpPreyPopulationStart m.popVisualPredator = GenerateVPredatorPopulation(m.VpPopulationStart, m.numVpCreated, m.Turn, m.ConditionParams, timestamp) m.numVpCreated += m.VpPopulationStart if m.Logging { go m.log(m.e) } if m.Visualise { go m.vis(m.e) } time.Sleep(pause) go m.run(m.e) return nil }
func main() { fmt.Println("My favortie number is ", rand.Intn(10)) fmt.Println("Another random int", rand.Intn(10)) // Try to Seed with 1 rand.Seed(1) fmt.Println("First sequence") for i := 0; i < 10; i++ { fmt.Println(rand.Intn(10)) } // Seed again with 1: Numbers are the same rand.Seed(1) fmt.Println("Second sequence") for i := 0; i < 10; i++ { fmt.Println(rand.Intn(10)) } // Seed with 2 rand.Seed(2) fmt.Println("Third sequence") for i := 0; i < 10; i++ { fmt.Println(rand.Intn(10)) } }
func main() { var i = 0 var buf []byte // Repeatable payloads. if seed, err := strconv.ParseInt(os.Getenv("SEED"), 10, 32); err == nil { rand.Seed(seed) } else { rand.Seed(defaultSeed) } sleepTime, err := parseRate(os.Getenv("RATE")) if err != nil { log.Println("Duration Parsing: ", err) log.Println("Continuing w/o duration") } mlen, err := strconv.ParseInt(os.Getenv("MSGSIZE"), 10, 32) if err == nil && mlen > 0 { buf = make([]byte, mlen) } else { log.Println("Unable to parse MSGSIZE, defaulting to MSGSIZE of", defaultMsgSize) buf = make([]byte, defaultMsgSize) } for { i++ if sleepTime > 0 { time.Sleep(sleepTime) } fmt.Println(i, "spews", randStr(buf)) } }
// seed PRNG to value given, if it is 0 seed to current time func seedPRNG(seed int64) { if seed == 0 { rand.Seed(time.Now().UTC().UnixNano()) } else { rand.Seed(seed) } }
//pada fungsi ini akan menyimpan data yang digunakan sebagai input func main() { // change "64" to anything else to see rand.Seed(8) sl := New() sl.Set(Int(6), 1) sl.Set(Int(5), 2) sl.Set(Int(4), 4) sl.Set(Int(9), 0) sl.draw() // 4-5-6-9- valuenya, ketemu := sl.Search(Int(5)) // Found! = 5 fmt.Println(valuenya) //2 fmt.Println(ketemu) // true valuenya, ketemu = sl.Search(Int(4)) // Found! = 4 fmt.Println(valuenya) //4 fmt.Println(ketemu) // true valuenya, ketemu = sl.Search(Int(6)) // Found! = 6 fmt.Println(valuenya) //1 fmt.Println(ketemu) // true valuenya, ketemu = sl.Search(Int(9)) // Found! = 9 fmt.Println(valuenya) //0 fmt.Println(ketemu) // true sl.Delete(Int(5)) sl.draw() // 4---6-9- valuenya, ketemu = sl.Search(Int(5)) // No Match Found! fmt.Println(valuenya) //<nil> fmt.Println(ketemu) // false sl.draw() // 4---6-9- rand.Seed(8) s2 := New() s2.Set(String("h"), 1) s2.Set(String("c"), 2) s2.Set(String("i"), 4) s2.Set(String("s"), 0) s2.draw() // c-h-i-s- valuenya, ketemu = s2.Search(String("c")) // Found! = c fmt.Println(valuenya) //2 fmt.Println(ketemu) // true valuenya, ketemu = s2.Search(String("i")) // Found! = i fmt.Println(valuenya) //4 fmt.Println(ketemu) // true valuenya, ketemu = s2.Search(String("s")) // Found! = s fmt.Println(valuenya) //0 fmt.Println(ketemu) // true valuenya, ketemu = s2.Search(String("h")) // Found! = h fmt.Println(valuenya) //1 fmt.Println(ketemu) // true s2.Delete(String("i")) s2.draw() // c-h---s- valuenya, ketemu = s2.Search(String("i")) // No Match Found! fmt.Println(valuenya) //<nil> fmt.Println(ketemu) // false s2.draw() // c-h---s- }
func main() { IntSlice := make(IntArr, 12) fmt.Print("Awal : ") for i := 0; i < 12; i++ { rand.Seed(time.Now().UTC().UnixNano()) IntSlice[i] = rand.Intn(50) fmt.Print(IntSlice[i], " ") } fmt.Println() CocktailSort(IntSlice) fmt.Print("Sesudah Sorting : ") for i := 0; i < 12; i++ { fmt.Print(IntSlice[i], " ") } fmt.Println("\n") StringSlice := StringArr{"nama", "saya", "adalah", "alvreda", "ivena"} fmt.Print("Awal : ") for i := 0; i < 5; i++ { fmt.Print(StringSlice[i], " ") } fmt.Println() CocktailSort(StringSlice) fmt.Print("Sesudah Sorting : ") for i := 0; i < 5; i++ { fmt.Print(StringSlice[i], " ") } fmt.Println("\n") Float32Slice := make(Float32Arr, 6) fmt.Print("Awal : ") for i := 0; i < 6; i++ { rand.Seed(time.Now().UTC().UnixNano()) Float32Slice[i] = rand.Float32() fmt.Print(Float32Slice[i], " ") } fmt.Println() CocktailSort(Float32Slice) fmt.Print("Sesudah Sorting : ") for i := 0; i < 6; i++ { fmt.Print(Float32Slice[i], " ") } fmt.Println("\n") Float64Slice := make(Float64Arr, 6) fmt.Print("Awal : ") for i := 0; i < 6; i++ { rand.Seed(time.Now().UTC().UnixNano()) Float64Slice[i] = rand.Float64() fmt.Print(Float64Slice[i], " ") } fmt.Println() CocktailSort(Float64Slice) fmt.Print("Sesudah Sorting : ") for i := 0; i < 6; i++ { fmt.Print(Float64Slice[i], " ") } fmt.Println() }
func TestReserveOneVolume(t *testing.T) { topo := setup(topologyLayout) rand.Seed(time.Now().UnixNano()) rand.Seed(1) ret, node, vid := topo.RandomlyReserveOneVolume() fmt.Println("assigned :", ret, ", node :", node, ", volume id:", vid) }
func randomDate() time.Time { rand.Seed(time.Now().Unix()) randomMonth := rand.Intn(108) rand.Seed(time.Now().Unix() + int64(randomMonth)) randomDay := rand.Intn(30) return time.Now().AddDate(0, -randomMonth, -randomDay) }
func TestRetry(t *testing.T) { defer func() { timeAfter = time.After }() rh := &Helper{ Backoff: 2, Retries: 5, Delay: 300 * time.Millisecond, MaxDelay: 2 * time.Second, MaxJitter: 5 * time.Millisecond, } durations := []time.Duration{ 300 * time.Millisecond, 600 * time.Millisecond, 1200 * time.Millisecond, 2 * time.Second, 2 * time.Second, } rand.Seed(1) for i := range durations { jitter := rand.Int63n(int64(rh.MaxJitter)) durations[i] += time.Duration(jitter) } actualRetries := 0 timeAfter = func(d time.Duration) <-chan time.Time { if actualRetries >= len(durations) { t.Fatalf("Maximum retry attempts exceeded: got %d", actualRetries) } if d != durations[actualRetries] { t.Errorf("Mismatched duration: got %s; want %s", d, durations[actualRetries]) } actualRetries++ c := make(chan time.Time, 1) c <- time.Now().Add(d) return c } noErrFunc := func() error { return nil } rand.Seed(1) retries, err := rh.RetryFunc(noErrFunc) if err != nil { t.Errorf("RetryFunc returned error for non-error function: %s", err) } if retries != 0 { t.Errorf("Mismatched retry attempt count: got %d", retries) } lastErr := &retryErr{5, true} errFunc := func() (err error) { return lastErr } rand.Seed(1) retries, err = rh.RetryFunc(errFunc) if retries != actualRetries { t.Errorf("Mismatched retry attempt count: got %d; want %d", retries, actualRetries) } if err != lastErr { t.Errorf("Unexpected retry error: got %q; want %q", err, lastErr) } }
// Seed sequential random with crypto or math/random and current time // and generate crypto prefix. func init() { r, err := rand.Int(rand.Reader, big.NewInt(math.MaxInt64)) if err != nil { prand.Seed(time.Now().UnixNano()) } else { prand.Seed(r.Int64()) } globalNUID = &lockedNUID{NUID: New()} globalNUID.RandomizePrefix() }
func seedRand() { n, err := rand.Int(rand.Reader, big.NewInt(9223372036854775806)) if err != nil { mathrand.Seed(time.Now().UTC().UnixNano()) return } mathrand.Seed(n.Int64()) return }
func initGo() { fmt.Printf("Initializing Go System (%d threads)\n", numProcs) if debug { rt.GOMAXPROCS(2) rand.Seed(0) } else { rt.GOMAXPROCS(numProcs) rand.Seed(rand.Int63()) } }
func init() { // Seed the math/rand RNG from crypto/rand. s := make([]byte, 8) if _, err := crand.Read(s); err == nil { rand.Seed(int64(binary.BigEndian.Uint64(s))) return } // Fall back to system time, boo hoo. rand.Seed(time.Now().UnixNano()) }
/** * Tests that the key is correctly updated in each node's storage system. */ func testSingleProposerUpdateKey(doneChan chan bool) { key := "b" // send first proposal randint, _ := crand.Int(crand.Reader, big.NewInt(math.MaxInt64)) rand.Seed(randint.Int64()) value := rand.Uint32() if _, ok := pt.cliMap[1]; !ok { LOGE.Println("FAIL: missing node 1") doneChan <- false return } pnum, err := pt.GetNextProposalNumber(key, 1) reply, err := pt.Propose(key, value, pnum.N, 1) if err != nil { printFailErr("Propose", err) doneChan <- false return } // send second proposal randint, _ = crand.Int(crand.Reader, big.NewInt(math.MaxInt64)) rand.Seed(randint.Int64()) value = rand.Uint32() pnum2, err := pt.GetNextProposalNumber(key, 1) // the proposal numbers should be monotonically increasing if pnum.N >= pnum2.N { LOGE.Println("FAIL: newer proposal number is less than or equal to older proposal number") doneChan <- false return } reply, err = pt.Propose(key, value, pnum2.N, 1) if err != nil { printFailErr("Propose", err) doneChan <- false return } if !checkProposeReply(reply, key, value) { doneChan <- false return } if !checkGetValueAll(key, value) { doneChan <- false return } doneChan <- true }
// SeedMathRand provides weak, but guaranteed seeding, which is better than // running with Go's default seed of 1. A call to SeedMathRand() is expected // to be called via init(), but never a second time. func SeedMathRand() { once.Do(func() { n, err := crand.Int(crand.Reader, big.NewInt(math.MaxInt64)) if err != nil { rand.Seed(time.Now().UTC().UnixNano()) return } rand.Seed(n.Int64()) SeededSecurely = true }) }
func __init() { allModels = make(map[ModelName]ModelInterface, maxModels) allModelProps = make(map[ModelName]map[string]interface{}, maxModels) if config.srand == 0 { rand.Seed(time.Now().UTC().UnixNano()) } else { rand.Seed(int64(config.srand)) } inited = true }
func beer(t time.Time) string { if t.Weekday().String() == "Friday" && t.Hour() >= 16 { rand.Seed(time.Now().UnixNano()) yup := ayes[rand.Intn(len(ayes))] return yup } else if t.Month().String() == "December" && t.Day() == 24 { return "Merry Beermas!" } else { rand.Seed(time.Now().UnixNano()) nope := nays[rand.Intn(len(nays))] return nope } }
func testDeterm(i int, t *testing.T) { var length = 500000 if testing.Short() { length = 100000 } rand.Seed(1337) t1 := make([]byte, length) for idx := range t1 { t1[idx] = byte(65 + rand.Intn(8)) } br := bytes.NewBuffer(t1) var b1 bytes.Buffer w, err := NewWriterLevel(&b1, i) if err != nil { t.Fatal(err) } _, err = io.Copy(w, br) if err != nil { t.Fatal(err) } w.Flush() w.Close() // We rand.Seed(1337) t2 := make([]byte, length) for idx := range t2 { t2[idx] = byte(65 + rand.Intn(8)) } br2 := bytes.NewBuffer(t2) var b2 bytes.Buffer w2, err := NewWriterLevel(&b2, i) if err != nil { t.Fatal(err) } _, err = io.Copy(w2, br2) if err != nil { t.Fatal(err) } w2.Flush() w2.Close() b1b := b1.Bytes() b2b := b2.Bytes() if bytes.Compare(b1b, b2b) != 0 { t.Fatalf("Level %d did not produce deterministric result, len(a) = %d, len(b) = %d", i, len(b1b), len(b2b)) } }
func (ts *AtomicWriteTestSuite) TestAtomicWriteFileNoOverwriteTmpExisting(c *C) { tmpdir := c.MkDir() // ensure we always get the same result rand.Seed(1) expectedRandomness := strutil.MakeRandomString(12) // ensure we always get the same result rand.Seed(1) p := filepath.Join(tmpdir, "foo") err := ioutil.WriteFile(p+"."+expectedRandomness, []byte(""), 0644) c.Assert(err, IsNil) err = AtomicWriteFile(p, []byte(""), 0600, 0) c.Assert(err, ErrorMatches, "open .*: file exists") }
// create the space needed by the grid. This is the same for all grid // implementations. The cellType is expected to be allFloors or allWalls. func (g *grid) create(width, height int, cellType bool) { gridWidth, gridHeight := g.validateSize(width), g.validateSize(height) g.cells = make([][]*cell, gridWidth) for x, _ := range g.cells { g.cells[x] = make([]*cell, gridHeight) for y, _ := range g.cells[x] { g.cells[x][y] = &cell{x, y, cellType} } } if g.seed == 0 { rand.Seed(time.Now().UnixNano()) } else { rand.Seed(g.seed) } }
func NewStressLattice(L uint16, dim uint8) *StressLattice { sys := new(StressLattice) sys.L = L sys.dim = dim sys.failureStress = 1.0 sys.residualStress = 0.625 rand.Seed(time.Now().UTC().UnixNano()) sys.seed = rand.Int63() rand.Seed(sys.seed) sys.N = powInteger(L, dim) sys.lattice = make([]float32, sys.N, sys.N) sys.randomSysInit() sys.failedSites = mapset.NewSet() return sys }
func TestShuffleNil(t *testing.T) { a := sort.StringSlice{"foo", "bar", "baz", "quux"} b := make(sort.StringSlice, len(a)) copy(b, a) rand.Seed(42) Shuffle(a, nil) rand.Seed(42) Shuffle(b, nil) for i := range a { if a[i] != b[i] { t.Errorf("mismatch at %d: %q != %q", i, a[i], b[i]) } } }
func main() { // Generate a number between 0 and max max := 10 rand.Seed(time.Now().Unix()) for i := 0; i < 6; i++ { fmt.Print(rand.Intn(max), " / ") } fmt.Println() // float times := int64(time.Now().Nanosecond()) rand.Seed(times) for i := 0; i < 6; i++ { fmt.Printf("%2.2f / ", 100*rand.Float32()) } }
func TestRetryAttempt(t *testing.T) { defer func() { timeAfter = time.After }() timeAfter = func(d time.Duration) <-chan time.Time { c := make(chan time.Time, 1) c <- time.Now().Add(d) return c } rh := &Helper{ Backoff: 3, Retries: 5, Delay: 150 * time.Millisecond, MaxDelay: 5 * time.Second, MaxJitter: 300 * time.Millisecond, } expectedDelays := []time.Duration{ 150 * time.Millisecond, 450 * time.Millisecond, 1350 * time.Millisecond, 4050 * time.Millisecond, 5 * time.Second, } // Add expected jitter. rand.Seed(1) for i := range expectedDelays { expectedDelays[i] += time.Duration(rand.Int63n(int64(rh.MaxJitter))) } rand.Seed(1) for i, expected := range expectedDelays { attempt := i + 1 actual, ok := rh.RetryAttempt(attempt, 1, nil) if !ok { t.Errorf("Retry attempt %d failed: %s", attempt, actual) } if actual != expected { t.Errorf("Wrong delay for attempt %d: got %d; want %d", attempt, actual, expected) } } // Exceeds maximum retry attempts; should return immediately. delay, ok := rh.RetryAttempt(6, 1, nil) if ok { t.Errorf("Retry attempt 6 succeeded") } if delay != 0 { t.Errorf("Got delay %s for retry attempt 6", delay) } }
func getRandomString() string { rand.Seed(time.Now().Unix()) maxLength := 4 strLen := rand.Intn(maxLength-1) + 1 return randStringBytes(strLen) }
/* if first line from client == LOGIN, reconnect to old bot if its something else, create new bot return true on LOGIN, false on any other command so it can be processed further */ func (c *Client) registerBot(cmd string, msg string) bool { if cmd == "LOGIN" { if bot, ok := bots[msg]; ok { c.ID = msg c.bot = bot c.bot.client.toClient = c.toClient close(c.join) c.join = make(chan string, 50000) go c.joinChannels() c.bot.clientConnected = true Log.Debug("old bot reconnected", msg) return true } c.bot = newBot(c) c.ID = msg c.bot.ID = msg c.bot.clientConnected = true bots[msg] = c.bot return true } c.bot = newBot(c) // generate random ID if c.bot.ID == "" { rand.Seed(int64(time.Now().Nanosecond())) r := rand.Int31n(123456) ID := fmt.Sprintf("%s%d", c.bot.nick, r) bots[ID] = c.bot c.ID = ID } return false }
func main() { worker, _ := zmq.NewSocket(zmq.REQ) defer worker.Close() // Set random identity to make tracing easier rand.Seed(time.Now().UnixNano()) identity := fmt.Sprintf("%04X-%04X", rand.Intn(0x10000), rand.Intn(0x10000)) worker.SetIdentity(identity) worker.Connect("tcp://localhost:5556") // Tell broker we're ready for work fmt.Printf("I: (%s) worker ready\n", identity) worker.Send(WORKER_READY, 0) for cycles := 0; true; { msg, err := worker.RecvMessage(0) if err != nil { break // Interrupted } // Simulate various problems, after a few cycles cycles++ if cycles > 3 && rand.Intn(5) == 0 { fmt.Printf("I: (%s) simulating a crash\n", identity) break } else if cycles > 3 && rand.Intn(5) == 0 { fmt.Printf("I: (%s) simulating CPU overload\n", identity) time.Sleep(3 * time.Second) } fmt.Printf("I: (%s) normal reply\n", identity) time.Sleep(time.Second) // Do some heavy work worker.SendMessage(msg) } }
func Test_Tree(t *testing.T) { defer guard_ut(t) var tree Tree var cnt = 0 const size = 2000 var list = new([size]int32) rand.Seed(time.Now().Unix()) for i := 0; i < size; i++ { list[i] = int32(rand.Int()) } for i := 0; i < size; i++ { if tree.Insert(list[i]) { cnt++ } } for i := 0; i < size; i++ { assert(t, tree.Search(list[i])) assert(t, !tree.Insert(list[i])) } for i := 0; i < size; i++ { if tree.Remove(list[i]) { cnt-- } assert(t, !tree.Search(list[i])) } assert(t, tree.IsEmpty() && cnt == 0) assert(t, !tree.Remove(0)) }
func testMultiplex(t *testing.T, multi func(output SimpleInChannel, inputs ...SimpleOutChannel)) { a := NewNativeChannel(None) b := NewNativeChannel(None) multi(b, a) testChannelPair(t, "simple multiplex", a, b) a = NewNativeChannel(None) inputs := []Channel{ NewNativeChannel(None), NewNativeChannel(None), NewNativeChannel(None), NewNativeChannel(None), } multi(a, inputs[0], inputs[1], inputs[2], inputs[3]) go func() { rand.Seed(time.Now().Unix()) for i := 0; i < 1000; i++ { inputs[rand.Intn(len(inputs))].In() <- i } for i := range inputs { inputs[i].Close() } }() for i := 0; i < 1000; i++ { val := <-a.Out() if i != val.(int) { t.Fatal("multiplexing expected", i, "but got", val.(int)) } } }