func u64rand() uint64 { a := uint64(rand.Uint32()); a = (a<<32) | uint64(rand.Uint32()); a >>= uint(rand.Intn(64)); return a; }
// Continuously update the screen with something interesting func render() { counter := 0 for { w, h := leggo.Dimensions() for y := 0; y < h; y += 1 { for x := 0; x < w; x += 1 { var r, g, b byte // Some random things to look at switch mode % 8 { case 0: r = byte(rand.Uint32()) g = r b = r case 1: r = byte(rand.Uint32()) g = byte(rand.Uint32()) b = byte(rand.Uint32()) case 2: r = byte(x * y) case 3: r = byte(x*y - int(rand.Uint32())%50) case 4: if x == counter%w { r = 255 g = 255 b = 255 } case 5: if counter%2 == 1 { g = 255 } else { r = 255 } time.Sleep(10000) case 6: if x == w/2 { g = 255 } if y == h/2 { r = 255 } case 7: if x == y { b = 255 } } leggo.WritePixel(x, y, r, g, b, 0) } } counter += 1 } }
func setupHash(size int) { emptyBoard[size] = make([]Hash, size*size) blackBoard[size] = make([]Hash, size*size) whiteBoard[size] = make([]Hash, size*size) rand.Seed(int64(size)) for i := 0; i < size*size; i++ { emptyBoard[size][i] = Hash(rand.Uint32()) blackBoard[size][i] = Hash(rand.Uint32()) whiteBoard[size][i] = Hash(rand.Uint32()) } }
func i64rand() int64 { for { a := int64(rand.Uint32()) a = (a << 32) | int64(rand.Uint32()) a >>= uint(rand.Intn(64)) if -a != a { return a } } return 0 // impossible }
func main() { if sdl.Init(sdl.INIT_VIDEO) != 0 { panic(sdl.GetError()) } defer sdl.Quit() screen := sdl.SetVideoMode(400, 300, 32, 0) if screen == nil { panic(sdl.GetError()) } sdl.WM_SetCaption("Template", "") ticker := time.NewTicker(1e9 / 2 /*2 Hz*/) loop: for { select { case <-ticker.C: // Note: For better efficiency, use UpdateRects instead of Flip screen.FillRect(nil /*color*/, rand.Uint32()) //screen.Blit(&sdl.Rect{x,y, 0, 0}, image, nil) screen.Flip() case event := <-sdl.Events: fmt.Printf("%#v\n", event) switch e := event.(type) { case sdl.QuitEvent: break loop } } } }
func u8rand() uint8 { a := uint8(rand.Uint32()); a >>= uint(rand.Intn(8)); return a; }
func main() { flag.Parse() // prime(); var blocks [1]struct { base *byte siz uintptr } for i := 0; i < 1<<10; i++ { if i%(1<<10) == 0 && *chatty { println(i) } b := rand.Int() % len(blocks) if blocks[b].base != nil { // println("Free", blocks[b].siz, blocks[b].base); runtime.Free(blocks[b].base) blocks[b].base = nil allocated -= uint64(blocks[b].siz) continue } siz := uintptr(rand.Int() >> (11 + rand.Uint32()%20)) base := runtime.Alloc(siz) // ptr := uintptr(syscall.BytePtr(base))+uintptr(siz/2); // obj, size, ref, ok := allocator.find(ptr); // if obj != base || *ref != 0 || !ok { // panicln("find", siz, obj, ref, ok); // } blocks[b].base = base blocks[b].siz = siz allocated += uint64(siz) // println("Alloc", siz, base); memset(base, 0xbb, siz) bigger() } }
func u32rand() uint32 { a := uint32(rand.Uint32()); a >>= uint(rand.Intn(32)); return a; }
func NewMessage(xid uint32, op, hwtype byte, hwaddr []byte, C, Y, S, G net.IP) (msg *Message, err os.Error) { // select a random XID if xid == 0 { xid = rand.Uint32() } if len(hwaddr) > 16 { err = os.NewError("Invalid DHCP hardware address (too long)") return } msg = &Message{ Operation: op, HardwareType: hwtype, HardwareLen: byte(len(hwaddr)), Xid: xid, // Secs: 0? // We default to FLAG_BROADCAST to avoid needing raw packets in Linux // This works for EC2, ISC, and possibly others, but no idea where else. Flags: FLAG_BROADCAST, ClientIP: C, YourIP: Y, ServerIP: S, GatewayIP: G, } copy(msg.ClientHWAddr[0:], hwaddr) return }
func u16rand() uint16 { a := uint16(rand.Uint32()); a >>= uint(rand.Intn(16)); return a; }
func TestStore(t *testing.T) { bloom := New() for i := 0; i < STORE_RUNS; i++ { bloom.Add(string(rand.Uint32())) } }
func randBytes(len int) []byte { bytes := make([]byte, len) for i := len - 1; i >= 0; i-- { bytes[i] = byte(rand.Uint32() % 256) } return bytes }
// Create a random string func randString(strLen int) (randStr string) { strChars := "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890" for i := 0; i < strLen; i++ { randUint := rand.Uint32() pos := randUint % uint32(len(strChars)) randStr += string(strChars[pos]) } return }
func createTempDir() string { once.Do(seedRand) result := fmt.Sprintf("/tmp/files_test.%d", rand.Uint32()) err := os.Mkdir(result, 0700) if err != nil { panic(fmt.Sprintf("Can't create dir [%s]: %s", result, err)) } return result }
func i16rand() int16 { for { a := int16(rand.Uint32()) a >>= uint(rand.Intn(16)) if -a != a { return a } } return 0 // impossible }
func i8rand() int8 { for { a := int8(rand.Uint32()) a >>= uint(rand.Intn(8)) if -a != a { return a } } return 0 // impossible }
// Vygeneruje nahodne cislo v intervalu [2^len, 2^len+1) func RandNum(len int) *big.Int { bytes := randBytes((len + 7) / 8) s := byte(len % 8) bytes[0] %= 2 << s for bytes[0] == 0 { bytes[0] = byte(rand.Uint32() % (2 << s)) } return new(big.Int).SetBytes(bytes) }
func i32rand() int32 { for { a := int32(rand.Uint32()) a >>= uint(rand.Intn(32)) if -a != a { return a } } return 0 // impossible }
func NewRandomTetrisFigureNot(figure *TetrisFigure) *TetrisFigure { var ri uint32 for { ri = rand.Uint32() % uint32(len(specs)) if ri != figure.Class { break } } f := NewTetrisFigure(specs[ri], specColors[ri]) f.Class = ri return f }
func chooseID() bson.ObjectId { rand.Seed(time.Nanoseconds()) b := make([]byte, IDLEN) for i := 0; i < IDLEN/4; i++ { u := rand.Uint32() b[4*i] = byte(u & 0xff) b[4*i+1] = byte((u >> 8) & 0xff) b[4*i+2] = byte((u >> 16) & 0xff) b[4*i+3] = byte((u >> 24) & 0xff) } return bson.ObjectId(b) }
func TestRetrieveFalse(t *testing.T) { bloom := New() var toTest [RETRIEVE_RUNS]string for i := 0; i < RETRIEVE_RUNS; i++ { toTest[i] = string(rand.Uint32()) } for i := 0; i < RETRIEVE_RUNS; i++ { if bloom.In(toTest[i]) { t.Error("BloomFilter.In returns false negative for string ", toTest[i]) } } }
func TestRetrieveTrue(t *testing.T) { bloom := New() var toAdd [RETRIEVE_RUNS]string for i := 0; i < RETRIEVE_RUNS; i++ { toAdd[i] = string(rand.Uint32()) bloom.Add(toAdd[i]) } for i := 0; i < RETRIEVE_RUNS; i++ { if !bloom.In(toAdd[i]) { t.Error("BloomFilter.In returns false posative for string ", toAdd[i]) } } }
func main() { flag.Parse() log.Printf("Server starting on port %d\n", *portnum) if *nodeID == 0 { rand.Seed(time.Nanoseconds()) *nodeID = uint(rand.Uint32()) } ss := storageserver.NewStorageserver(*storageMasterNodePort, *numNodes, *portnum, uint32(*nodeID)) ts := NewTribserver(ss) rpc.Register(ts) srpc := storagerpc.NewStorageRPC(ss) rpc.Register(srpc) rpc.HandleHTTP() l, e := net.Listen("tcp", fmt.Sprintf(":%d", *portnum)) if e != nil { log.Fatal("listen error:", e) } log.Printf("Establishing connection with storage servers") go ss.Connect(l.Addr()) http.Serve(l, nil) }
// Generate a random, valid session ID. // The returned session ID is guaranteed not to currently be in use // on the server, and not to be the zero-value for integers (0). func (server *Server) GenSessionId() (session uint32) { for { session = rand.Uint32() // The 0 session is disallowed in Grumble. 0 is the zero-value for // integer types, and as such, an uninitialized session id could // point to a valid client if we allowed the 0 session id. if session == 0 { continue } // Is there already a client on the sever with the generated id? // Give us a new one, please. if _, exists := server.clients[session]; exists { continue } break } return }
func (cm *CallManager) Call(addr net.Addr, name string, args []interface{}) (retis []interface{}, err os.Error) { cm.logger.Logf("call called\n") fmt.Printf("CALL\n") rpc := new(RPC) header := new(Header) rpc.Header = header header.Version = 1 header.Sender = cm.Id // TODO: DHTId! header.DHTId = nil header.Id = uint64(rand.Uint32())<<32 | uint64(rand.Uint32()) header.Call = 0x01 packet := new(Packet) rpc.Packet = packet packet.To = addr rpcframe := new(RPCFrame) rpc.RPCFrame = rpcframe rpcframe.Name = name rpcframe.OutArgs = args rpcdesc := make(map[string]interface{}) rpcdesc["name"] = name rpcdesc["args"] = args rpc.Payload = rpcdesc cm.logger.Logf("Call: encoding packet") data := cm.EncodeRPC(rpc) if packet == nil { return nil, RPCError("could not encode packet") } packet.Data = data // register RPC... running := &RunningRPC{rpc, make(chan *RPC)} cm.regchan <- running err = cm.transceiver.SendRPC(rpc) if err != nil { return nil, err } retrpc := <-running.retchan if retrpc == nil { return nil, RPCError("time out") } if retis, ok := retrpc.Payload.([]interface{}); ok { return retis, nil } if cm.log { cm.logger.Logf("return payload was not []interface{}\n") } return nil, nil }
func NewRandomTetrisFigure() *TetrisFigure { ri := rand.Uint32() % uint32(len(specs)) f := NewTetrisFigure(specs[ri], specColors[ri]) f.Class = ri return f }