Exemple #1
0
func init() {

	SyncChannel = make(chan float64, 100000)
	fmt.Println(" SyncChannel created")

	Rgen = rand.New(rand.NewSource(123813541954235))
	Rgen2 = rand.New(rand.NewSource(12384235))
	fmt.Println("init done")

	// function called automatically on pacakge load, initializes system channels

	// create channels

	SystemChan = make([]*channel, NCh)
	for i := range SystemChan {
		c := new(channel)
		c.i = i
		c.Emitters = list.New()
		c.Change = make(chan EmitterInt, 100)
		go c.changeChan()
		SystemChan[i] = c
	}

	// evaluate overlaping factors of channels

	overlapN := int(math.Floor(1.0 / (1.0 - float64(roverlap))))
	if overlapN < 1 {
		overlapN = 1
	}
	if roverlap > 0.0 {

		for i := NChRes; i < NCh; i++ {

			SystemChan[i].coIntC = make([]coIntChan, overlapN*2)

			for k := 1; k <= overlapN; k++ {

				fac := 1.0 - float64(k)*(1.0-roverlap)

				SystemChan[i].coIntC[overlapN-k].c = i - k
				SystemChan[i].coIntC[overlapN-k].factor = float64(fac)

				if i+k < NCh {
					SystemChan[i].coIntC[overlapN+k-1].c = i + k
					SystemChan[i].coIntC[overlapN+k-1].factor = float64(fac)
				}

			}

		}
	}

}
Exemple #2
0
func LoadWorldStore(worldPath string) (world *WorldStore, err os.Error) {
	levelData, err := loadLevelData(worldPath)
	if err != nil {
		return
	}

	// In both single-player and SMP maps, the 'spawn position' is stored in
	// the level data.
	x, xok := levelData.Lookup("Data/SpawnX").(*nbt.Int)
	y, yok := levelData.Lookup("Data/SpawnY").(*nbt.Int)
	z, zok := levelData.Lookup("Data/SpawnZ").(*nbt.Int)
	if !xok || !yok || !zok {
		err = os.NewError("Invalid map level data: does not contain Spawn{X,Y,Z}")
		log.Printf("%#v", levelData)
		return
	}
	spawnPosition := BlockXyz{
		BlockCoord(x.Value),
		BlockYCoord(y.Value),
		BlockCoord(z.Value),
	}

	var timeTicks Ticks
	if timeTag, ok := levelData.Lookup("Data/Time").(*nbt.Long); ok {
		timeTicks = Ticks(timeTag.Value)
	}

	var chunkStores []chunkstore.IChunkStore
	persistantChunkStore, err := chunkstore.ChunkStoreForLevel(worldPath, levelData, DimensionNormal)
	if err != nil {
		return
	}
	chunkStores = append(chunkStores, chunkstore.NewChunkService(persistantChunkStore))

	var seed int64
	if seedNbt, ok := levelData.Lookup("Data/RandomSeed").(*nbt.Long); ok {
		seed = seedNbt.Value
	} else {
		seed = rand.NewSource(time.Seconds()).Int63()
	}

	chunkStores = append(chunkStores, chunkstore.NewChunkService(generation.NewTestGenerator(seed)))

	for _, store := range chunkStores {
		go store.Serve()
	}

	world = &WorldStore{
		WorldPath:     worldPath,
		Seed:          seed,
		Time:          timeTicks,
		LevelData:     levelData,
		ChunkStore:    chunkstore.NewChunkService(chunkstore.NewMultiStore(chunkStores)),
		SpawnPosition: spawnPosition,
	}

	go world.ChunkStore.Serve()

	return
}
Exemple #3
0
func BenchmarkMonte(b *testing.B) {
	rng := rand.New(rand.NewSource(1))

	start := ALoc(40)
	l := start
	n := 0
	tn := 0
	s := 0
	for i := 0; i < b.N*NMonte; i++ {
		var d maps.Direction
		for _, d = range maps.Permute5(rng) {
			s++
			if d == maps.NoMovement {
				break
			} else if nl := A.LocStep[l][d]; maps.StepableItem[A.Grid[nl]] {
				l = nl
				break
			}
		}
		if l == 0 {
			l = start
			n++
			tn += s
			s = 0
		}
	}
	if arenachatty {
		log.Printf("mean steps to exit %.2f exited %d Steps %d %d", float64(tn)/float64(n), n, tn, b.N)
	}
}
Exemple #4
0
func (b *Bytes) fab(parent string) os.Error {
	fh, err := os.OpenFile(parent, os.O_RDWR|os.O_APPEND, 0644)
	if fh == nil {
		return err
	}
	defer fh.Close()

	rnd := rand.New(rand.NewSource(b.Seed))

	for toWrite := b.Length; toWrite > 0; {
		buf := &bytes.Buffer{}

		for i := 0; i < CHUNKSIZE && toWrite > 0; i++ {
			buf.WriteByte(byte(rnd.Int()))
			toWrite--
		}

		_, err = buf.WriteTo(fh)
		if err != nil {
			return err
		}
	}

	return nil
}
func (t RoundRobin) Run(array player.Array, match Match) []int {
	rand := rand.New(rand.NewSource(time.Seconds()))
	results := make([]int, array.Len())
	wins := make([]int, array.Len())

	// Every player plays every other once, sort players by number of wins

	for a := 0; a < array.Len(); a++ {
		for b := a + 1; b < array.Len(); b++ {
			winner, _, _ := match.Play(a, b, array, rand)
			wins[winner]++
		}
	}

	for i := 0; i < len(results); i++ {
		best := 0

		for j := range wins {
			if wins[j] > wins[best] {
				best = j
			}
		}

		results[i] = best
		wins[best] = -1
	}

	return results
}
Exemple #6
0
func main() {
	api = twitter.NewApi()
	done = make(chan bool)
	r = rand.New(rand.NewSource(time.Seconds()))
	crawl(kStart, 0)
	<-done
}
Exemple #7
0
func NewGame(worldPath string) (game *Game, err os.Error) {
	worldStore, err := worldstore.LoadWorldStore(worldPath)
	if err != nil {
		return nil, err
	}

	game = &Game{
		players:          make(map[EntityId]*player.Player),
		playerNames:      make(map[string]*player.Player),
		workQueue:        make(chan func(*Game), 256),
		playerConnect:    make(chan *player.Player),
		playerDisconnect: make(chan EntityId),
		time:             worldStore.Time,
		worldStore:       worldStore,
	}

	game.entityManager.Init()

	game.serverId = fmt.Sprintf("%016x", rand.NewSource(worldStore.Seed).Int63())
	//game.serverId = "-"

	game.shardManager = shardserver.NewLocalShardManager(worldStore.ChunkStore, &game.entityManager)

	// TODO: Load the prefix from a config file
	gamerules.CommandFramework = command.NewCommandFramework("/")

	go game.mainLoop()
	return
}
Exemple #8
0
func TestMarshalUnmarshal(t *testing.T) {
	rand := rand.New(rand.NewSource(0))
	for i, iface := range messageTypes {
		ty := reflect.ValueOf(iface).Type()

		n := 100
		if testing.Short() {
			n = 5
		}
		for j := 0; j < n; j++ {
			v, ok := quick.Value(ty, rand)
			if !ok {
				t.Errorf("#%d: failed to create value", i)
				break
			}

			m1 := v.Elem().Interface()
			m2 := iface

			marshaled := marshal(msgIgnore, m1)
			if err := unmarshal(m2, marshaled, msgIgnore); err != nil {
				t.Errorf("#%d failed to unmarshal %#v: %s", i, m1, err)
				break
			}

			if !reflect.DeepEqual(v.Interface(), m2) {
				t.Errorf("#%d\ngot: %#v\nwant:%#v\n%x", i, m2, m1, marshaled)
				break
			}
		}
	}
}
Exemple #9
0
func NewPerlinNoise(seed int64) *PerlinNoise {
	gen := &PerlinNoise{
		seed: seed,
	}

	// The source's seed is reset to seed for each precomputed set so that any
	// code reordering in this implementation does not alter the noise values
	// produced for a given seed.
	source := rand.NewSource(0)
	rnd := rand.New(source)

	// Initialize gen.permut.
	source.Seed(seed)
	perm := rnd.Perm(len(gen.permut))
	for i := range perm {
		gen.permut[i] = perm[i]
	}

	// Initialize gen.g2d.
	source.Seed(seed)
	for i := range perm {
		randVector(gen.g2d[i][:], rnd)
		normVector(gen.g2d[i][:])
	}

	return gen
}
Exemple #10
0
func TestSum(t *testing.T) {
	var buf [100000]uint8
	rnd := rand.New(rand.NewSource(4))
	for i := range buf {
		buf[i] = uint8(rnd.Intn(256))
	}

	sum := func(offset, len int) uint32 {
		rs := New()
		for count := offset; count < len; count++ {
			rs.Roll(buf[count])
		}
		return rs.Digest()
	}

	sum1a := sum(0, len(buf))
	sum1b := sum(1, len(buf))
	sum2a := sum(len(buf)-windowSize*5/2, len(buf)-windowSize)
	sum2b := sum(0, len(buf)-windowSize)
	sum3a := sum(0, windowSize+3)
	sum3b := sum(3, windowSize+3)

	if sum1a != sum1b {
		t.Errorf("sum1a=%d sum1b=%d", sum1a, sum1b)
	}
	if sum2a != sum2b {
		t.Errorf("sum2a=%d sum2b=%d", sum2a, sum2b)
	}
	if sum3a != sum3b {
		t.Errorf("sum3a=%d sum3b=%d", sum3a, sum3b)
	}
}
Exemple #11
0
func BenchmarkMonteFull(b *testing.B) {
	rng := rand.New(rand.NewSource(1))

	start := torus.Location(136)
	l := start
	n := 0
	tn := 0
	s := 0
	for i := 0; i < b.N*NMonte; i++ {
		s++
		var d maps.Direction
		for _, d = range maps.Permute5(rng) {
			if d == maps.NoMovement {
				break
			} else if nl := M.LocStep[l][d]; maps.StepableItem[M.Grid[nl]] {
				l = nl
				break
			}
		}
		if l == 0 {
			l = start
			n++
			tn += s
			s = 0
		}
	}
	if arenachatty {
		log.Printf("mean steps to exit %.2f", float64(tn)/float64(n))
	}
}
func (t SingleElimination) Run(array player.Array, match Match) []int {
	rand := rand.New(rand.NewSource(time.Seconds()))
	results := make([]int, array.Len())
	num_ranked := len(results) - 1

	rounds := make([][]int, intlog(array.Len())+1)
	rounds[0] = initialSeeds(array.Len())

	for r := 1; ; r++ {
		if len(rounds[r-1])/2 == 0 {
			break
		}

		rounds[r] = make([]int, len(rounds[r-1])/2)

		for i := range rounds[r] {
			a := rounds[r-1][2*i]
			b := rounds[r-1][2*i+1]

			rounds[r][i], results[num_ranked], _ = match.Play(a, b, array, rand)
			num_ranked--
		}
	}

	results[num_ranked] = rounds[len(rounds)-1][0]

	if num_ranked != 0 {
		panic("Didn't rank all the players!")
	}

	return results
}
Exemple #13
0
func initColors(seed int64) {
	fmt.Printf("%d ", seed)
	r := rand.New(rand.NewSource(seed))
	for i := 0; i < 100; i++ {
		colors[i] = image.RGBAColor{uint8rand(r), uint8rand(r), uint8rand(r), 255}
	}
}
Exemple #14
0
func TestMakeMatrix3(t *testing.T) {
	const size = 3
	r := rand.New(rand.NewSource(time.Nanoseconds()))
	data := make([]float32, size*size)
	for iterations := 0; iterations < 1000; iterations++ {
		// Initialize the data
		for i := 0; i < size*size; i++ {
			data[i] = (Randf(r) - 0.5) * 1000
		}

		m1 := MakeMatrix3(true, data...)
		m2 := MakeMatrix3(false, data...)

		for r := 0; r < size; r++ {
			for c := 0; c < size; c++ {
				if m1.At(r, c) != data[r*size+c] {
					t.Errorf("m[%d][%d] (%f) != data[%d] (%f)", r, c, m1.At(r, c), r*size+c, data[r*size+c])
				}
				if m2.At(r, c) != data[c*size+r] {
					t.Errorf("m[%d][%d] (%f) != data[%d] (%f)", r, c, m1.At(r, c), r*size+c, data[r*size+c])
				}
			}
		}
	}
}
Exemple #15
0
func TestMatrix3_MultiplyV(t *testing.T) {
	const size = 3
	r := rand.New(rand.NewSource(time.Nanoseconds()))

	// Simple math test
	for iterations := 0; iterations < 1000; iterations++ {
		data1 := (Randf(r) - 0.5) * 1000
		data2 := (Randf(r) - 0.5) * 1000

		data3 := data1 * data2
		for element := 0; element < size*size; element++ {

			var m Matrix3
			m[element] = data1

			row_index := element / size
			col_index := element % size

			for v_element := 0; v_element < size; v_element++ {
				var v Vector3
				v[v_element] = data2

				r1 := m.MultiplyV(v)
				if col_index != v_element {
					var r2 Vector3
					if !r1.Equals(r2) {
						t.Error("r1 != r2\n\tm:", m, "\n\r1:", r1, "\n\r2:", r2)
					}
				} else {
					var r2 Vector3
					r2[row_index] = data3
					if !r1.Equals(r2) {
						t.Error("r1 != r2\n\tm:", m, "\n\r1:", r1, "\n\r2:", r2)
					}
				}
			}
		}
	}

	// Test identity matrix
	{
		data := make([]float32, size)
		m := MakeMatrix3Identity()
		for iterations := 0; iterations < 1000; iterations++ {
			for i := 0; i < size; i++ {
				data[i] = (Randf(r) - 0.5) * 1000
			}

			v1 := MakeVector3(data...)
			v2 := m.MultiplyV(v1)
			if !v1.Equals(v2) {
				t.Error("v1 != v2\n\tm:", m, "\n\v1:", v1, "\n\v2:", v2)
			}
		}
	}

	// TODO: Get a bunch of test data to do this
	input_matrix_data := [...][size * size]float32{}
	_ = input_matrix_data
}
Exemple #16
0
func TestMatrix3_IdentityThis(t *testing.T) {
	const size = 3
	r := rand.New(rand.NewSource(time.Nanoseconds()))
	data := make([]float32, size*size)
	for iterations := 0; iterations < 1000; iterations++ {
		// Initialize the data
		for i := 0; i < size*size; i++ {
			data[i] = (Randf(r) - 0.5) * 1000
		}

		m1 := MakeMatrix3(true, data...)
		m1.IdentityThis()

		for r := 0; r < size; r++ {
			for c := 0; c < size; c++ {
				if r == c {
					if m1.At(r, c) != 1 {
						t.Errorf("m[%d][%d] (%f) != 0", r, c, m1.At(r, c))
					}
				} else if m1.At(r, c) != 0 {
					t.Errorf("m[%d][%d] (%f) != 0", r, c, m1.At(r, c))
				}
			}
		}
	}
}
Exemple #17
0
func BenchmarkEncodeRGBOpaque(b *testing.B) {
	b.StopTimer()
	img := image.NewRGBA(640, 480)
	// Set all pixels to 0xFF alpha to force opaque mode.
	bo := img.Bounds()
	rnd := rand.New(rand.NewSource(123))
	for y := bo.Min.Y; y < bo.Max.Y; y++ {
		for x := bo.Min.X; x < bo.Max.X; x++ {
			img.Set(x, y, image.RGBAColor{
				uint8(rnd.Intn(256)),
				uint8(rnd.Intn(256)),
				uint8(rnd.Intn(256)),
				255})
		}
	}
	if !img.Opaque() {
		panic("expected image to be opaque")
	}
	b.SetBytes(640 * 480 * 4)
	b.StartTimer()
	options := &Options{Quality: 90}
	for i := 0; i < b.N; i++ {
		Encode(ioutil.Discard, img, options)
	}
}
Exemple #18
0
// returns an equivalent but completlely independent copy of b
func (b *Board) Copy() *Board {
	sec, nsec, _ := os.Time()
	l := b.boardSize * b.boardSize
	cpy := &Board{
		fields:                make([]*Group, l),
		colorOfNextPlay:       b.colorOfNextPlay,
		boardSize:             b.boardSize,
		currentSequence:       b.currentSequence,
		actionOnNextBlackMove: make([]*actionFunc, l),
		actionOnNextWhiteMove: make([]*actionFunc, l),
		fieldSequencesBlack:   make([]uint32, l),
		fieldSequencesWhite:   make([]uint32, l),
		rand:                  rand.New(rand.NewSource(sec + nsec)),
		prisonersBlack:        b.prisonersBlack,
		prisonersWhite:        b.prisonersWhite,
	}
	if b.ko != nil {
		cpy.ko = &koLock{
			Pos:   b.ko.Pos,
			Color: b.ko.Color,
		}
	}
	copy(cpy.fieldSequencesBlack, b.fieldSequencesBlack)
	copy(cpy.fieldSequencesWhite, b.fieldSequencesWhite)

	// Copy .fields in a seperate loop first. The next loop, in which we set .actionOnNext{Black,White}Move
	// depends upon correcty and already completely set .fields. Remember to copy each group only once!
	copiedGroups := make(map[*Group]bool)
	for i := 0; i < l; i++ {
		grp := b.fields[i]
		_, present := copiedGroups[grp]
		if !present && grp != nil {
			gcpy := grp.Copy()
			last := gcpy.Fields.Last()
			for it := gcpy.Fields.First(); it != last; it = it.Next() {
				cpy.fields[it.Value()] = gcpy
			}
			// remember that we already copied grp
			copiedGroups[grp] = true
		}
	}

	for i := 0; i < l; i++ {
		// copy .actionOnNextBlackMove and adjust its context
		if f := b.actionOnNextBlackMove[i]; f != nil {
			cpy.actionOnNextBlackMove[i] = NewActionFunc(cpy, nil, f.f)
			_, cpy.actionOnNextBlackMove[i].context = cpy.getEnvironmentAndContext(i, Black)
		}
		// copy .actionOnNextWhiteMove and adjust its context
		if f := b.actionOnNextWhiteMove[i]; f != nil {
			cpy.actionOnNextWhiteMove[i] = NewActionFunc(cpy, nil, f.f)
			_, cpy.actionOnNextWhiteMove[i].context = cpy.getEnvironmentAndContext(i, White)
		}
	}

	return cpy
}
Exemple #19
0
func BenchmarkGetTest(b *testing.B) {
	b.StopTimer()
	r := rand.New(rand.NewSource(0))
	sz := 100000
	s := New(uint(sz))
	b.StartTimer()
	for i := 0; i < b.N; i++ {
		s.Test(uint(r.Int31n(int32(sz))))
	}
}
Exemple #20
0
/*
 * Create a pseudo-random block using given seed.
 */
func randBuf(seed int64) []byte {
	rnd := rand.New(rand.NewSource(seed))

	buf := &bytes.Buffer{}

	for i := 0; i < fs.BLOCKSIZE; i++ {
		buf.WriteByte(byte(rnd.Int()))
	}

	return buf.Bytes()
}
Exemple #21
0
func addHorde() {
	src := rand.NewSource(time.Nanoseconds())
	rng := rand.New(src)
	horde := make([]*core.User, 20000)

	// Add the horde.
	for i, _ := range horde {
		data := make([]core.DataChange, 4)
		data[0].Name, data[0].Data = "ip", fmt.Sprintf("%d.%d.%d.%d", rng.Int()%255, rng.Int()%255, rng.Int()%255, rng.Int()%255)
		data[1].Name, data[1].Data = "hostname", fmt.Sprintf("%d.Horde.FakeUsers.PsuedoUserUnion.org", rng.Int()%1000000)
		data[2].Name, data[2].Data = "ident", fmt.Sprintf("horde-%d", rng.Int()%1000000)
		data[3].Name, data[3].Data = "account", fmt.Sprintf("horde-%d", rng.Int()%1000000)

		horde[i] = core.NewUser("oddcomm/modules/dev/horde", nil, true, "", data)
		horde[i].SetNick(me, fmt.Sprintf("horde-%d", rng.Int()%1000000), -1)
		horde[i].PermitRegistration(me)
	}

	// Make a huge channel containing the entire horde.
	core.GetChannel("", "huge").Join(me, horde)

	// Make 100 channels containing roughly a twentieth of the horde each.
	// Each horde user is in an average of roughly five.
	for i := 0; i < 100; i++ {
		joiners := make([]*core.User, len(horde)/20)
		for i, _ := range joiners {
			joiners[i] = horde[rand.Int()%len(horde)]
		}
		name := fmt.Sprintf("big_%d", i)
		core.GetChannel("", name).Join(me, joiners)
	}

	// Make 2000 channels containing roughly 1/400th of the horde each.
	// Each horde user is in an average of roughly five.
	for i := 0; i < 2000; i++ {
		joiners := make([]*core.User, len(horde)/400)
		for i, _ := range joiners {
			joiners[i] = horde[rand.Int()%len(horde)]
		}
		name := fmt.Sprintf("medium_%d", i)
		core.GetChannel("", name).Join(me, joiners)
	}

	// Make horde*2 channels containing roughly four of the horde each.
	// Each horde user is in an average of roughly eight.
	for i := 0; i < len(horde)*2; i++ {
		joiners := make([]*core.User, 4)
		for i, _ := range joiners {
			joiners[i] = horde[rand.Int()%len(horde)]
		}
		name := fmt.Sprintf("small_%d", i)
		core.GetChannel("", name).Join(me, joiners)
	}
}
Exemple #22
0
func NewFileSeededSource(filename string) (src rand.Source, err os.Error) {
	fileSource, err := NewFileBasedSource(filename)
	defer fileSource.Close()
	if err != nil {
		return src, err
	}

	var seed int64 = fileSource.Int63()
	src = rand.NewSource(seed)
	return src, err
}
Exemple #23
0
func NewUnsignedPermanode() map[string]interface{} {
	m := newCamliMap(1, "permanode")
	chars := make([]byte, 20)
	// Don't need cryptographically secure random here, as this
	// will be GPG signed anyway.
	rnd := rand.New(rand.NewSource(time.Nanoseconds()))
	for idx, _ := range chars {
		chars[idx] = byte(32 + rnd.Intn(126-32))
	}
	m["random"] = string(chars)
	return m
}
func TestFuzz(t *testing.T) {
	rand := rand.New(rand.NewSource(0))
	for _, iface := range tests {
		m := iface.(testMessage)

		for j := 0; j < 1000; j++ {
			len := rand.Intn(100)
			bytes := randomBytes(len, rand)
			// This just looks for crashes due to bounds errors etc.
			m.unmarshal(bytes)
		}
	}
}
Exemple #25
0
func initGame(obj *Game) *Game {
	obj.Random = rand.New(rand.NewSource(time.Nanoseconds()))
	for Y := 0; Y < BOARD_MAX_Y; Y++ {
		for X := 0; X < BOARD_MAX_X; X++ {
			if X == 0 || X == LIMIT_X || Y >= LIMIT_Y {
				obj.Board[Y][X] = 0
			} else {
				obj.Board[Y][X] = -1
			}
		}
	}
	return obj
}
Exemple #26
0
func TestMatrix3_Equals(t *testing.T) {
	const size = 3
	r := rand.New(rand.NewSource(time.Nanoseconds()))
	data1 := make([]float32, size*size)
	data2 := make([]float32, size*size)

	// Test Equals
	for iterations := 0; iterations < 1000; iterations++ {
		// Initialize the data
		for i := 0; i < size*size; i++ {
			data1[i] = (Randf(r) - 0.5) * 1000
		}

		m1 := MakeMatrix3(true, data1...)
		m2 := MakeMatrix3(true, data1...)

		if !m1.Equals(m2) {
			t.Error("m1 != m2\n\tm1:", m1, "\n\tm2:", m2)
		}
		if !m2.Equals(m1) {
			t.Error("m2 != m1\n\tm1:", m1, "\n\tm2:", m2)
		}
	}

	// Test !Equals
	for iterations := 0; iterations < 1000; iterations++ {
		// Initialize the data
		for i := 0; i < size*size; i++ {
			data1[i] = (Randf(r) - 0.5) * 1000
		}

		m1 := MakeMatrix3(true, data1...)

		for element := 0; element < size*size; element++ {
			for i := 0; i < size*size; i++ {
				data2[i] = data1[i]
			}
			data2[element] += 1
			m2 := MakeMatrix3(true, data2...)

			if m1.Equals(m2) {
				t.Error("m1 == m2\n\tm1:", m1, "\n\tm2:", m2)
			}
			if m2.Equals(m1) {
				t.Error("m2 == m1\n\tm1:", m1, "\n\tm2:", m2)
			}
		}
	}
}
Exemple #27
0
func calcPartialPI(result chan<- float64, iter int) {
	var circle, i int

	rg := rand.New(rand.NewSource(time.Nanoseconds() % 1e9))

	for i = 0; i < iter; i++ {
		x, y := getCoord(rg), getCoord(rg)
		if (x*x + y*y) < 1.0 {
			circle++

		}
	}

	result <- 4 * float64(circle) / float64(i)
}
Exemple #28
0
// Creates a new Consumer instance.
// - consumerKey and consumerSecret
//   values you should obtain from the ServiceProvider when you register your application.
//
// - serviceProvider:
//   see the documentation for ServiceProvider for how to create this.
//
func NewConsumer(consumerKey string, consumerSecret string,
	serviceProvider ServiceProvider) *Consumer {
	clock := &defaultClock{}
	return &Consumer{
		consumerKey:     consumerKey,
		consumerSecret:  consumerSecret,
		serviceProvider: serviceProvider,
		clock:           clock,
		HttpClient:      &http.Client{},
		nonceGenerator:  rand.New(rand.NewSource(clock.Seconds())),
		signer:          &SHA1Signer{},

		AdditionalParams: make(map[string]string),
	}
}
Exemple #29
0
func NewTestGenerator(seed int64) *TestGenerator {
	perlin := perlin.NewPerlinNoise(seed)

	randSource := rand.NewSource(time.Nanoseconds())
	randGen := rand.New(randSource)

	return &TestGenerator{
		randSource: randSource,
		randGen:    randGen,
		heightSource: &Sum{
			Inputs: []ISource{
				&Turbulence{
					Dx:     &Scale{50, 1, &Offset{20.1, 0, perlin}},
					Dy:     &Scale{50, 1, &Offset{10.1, 0, perlin}},
					Factor: 50,
					Source: &Scale{
						Wavelength: 200,
						Amplitude:  50,
						Source:     perlin,
					},
				},
				&Turbulence{
					Dx:     &Scale{40, 1, &Offset{20.1, 0, perlin}},
					Dy:     &Scale{40, 1, &Offset{10.1, 0, perlin}},
					Factor: 10,
					Source: &Mult{
						A: &Scale{
							Wavelength: 40,
							Amplitude:  20,
							Source:     perlin,
						},
						// Local steepness.
						B: &Scale{
							Wavelength: 200,
							Amplitude:  1,
							Source:     &Add{perlin, 0.6},
						},
					},
				},
				&Scale{
					Wavelength: 5,
					Amplitude:  2,
					Source:     perlin,
				},
			},
		},
	}
}
Exemple #30
0
func BenchmarkMatrix3_ScalarMultiply(b *testing.B) {
	b.StopTimer()
	const size = 3
	r := rand.New(rand.NewSource(time.Nanoseconds()))
	data1 := make([]float32, size*size)
	data2 := (Randf(r) - 0.5) * 1000
	for i := 0; i < size*size; i++ {
		data1[i] = (Randf(r) - 0.5) * 1000
	}
	m1 := MakeMatrix3(true, data1...)

	b.StartTimer()
	for iterations := 0; iterations < b.N; iterations++ {
		m1.ScalarMultiply(data2)
	}
}