Example #1
0
func ComplexOperationsSpec(c gospec.Context) {
	c.Specify("Vec2.DistToLine() works.", func() {
		centers := []linear.Vec2{
			linear.Vec2{10, 12},
			linear.Vec2{1, -9},
			linear.Vec2{-100, -42},
			linear.Vec2{0, 1232},
		}
		radiuses := []float64{3, 10.232, 435, 1}
		thetas := []float64{0.001, 0.1, 1, 1.01, 0.034241, 0.789, 90, 179, 180}
		angles := []float64{1.01, 1.0, 1.11111, 930142}
		for _, center := range centers {
			for _, radius := range radiuses {
				for _, angle := range angles {
					for _, theta := range thetas {
						a := linear.Vec2{math.Cos(angle), math.Sin(angle)}
						b := linear.Vec2{math.Cos(angle + theta), math.Sin(angle + theta)}
						seg := linear.Seg2{a.Scale(radius).Add(center), b.Scale(radius).Add(center)}
						dist := center.DistToLine(seg)
						real_dist := radius * math.Cos(theta/2)
						if real_dist < 0 {
							real_dist = -real_dist
						}
						c.Expect(dist, IsWithin(1e-9), real_dist)
					}
				}
			}
		}
	})
}
Example #2
0
func Alloc3dSpec(c gospec.Context) {
	d100x20x10 := Alloc3d(100, 20, 10)
	c.Specify("Allocates the appropriate memory for 3d arrays.", func() {
		c.Expect(len(d100x20x10), gospec.Equals, 100)
		for _, v := range d100x20x10 {
			c.Expect(len(v), gospec.Equals, 20)
			for _, v := range v {
				c.Expect(len(v), gospec.Equals, 10)
			}
		}
		counter := 0.0
		for i := range d100x20x10 {
			for j := range d100x20x10[i] {
				for k := range d100x20x10[i][j] {
					d100x20x10[i][j][k] = complex(counter, 0)
					counter += 1.0
				}
			}
		}
		counter = 0.0
		for i := range d100x20x10 {
			for j := range d100x20x10[i] {
				for k := range d100x20x10[i][j] {
					c.Expect(real(d100x20x10[i][j][k]), gospec.Equals, counter)
					counter += 1.0
				}
			}
		}
	})
}
Example #3
0
// Helpers
func DecodeBoundBoxSpecs(c gospec.Context) {
	c.Specify("[DecodeBoundBox] Decodes GeoHash to DecodedBoundBox", func() {
		value := DecodeBoundBox("ww8p1r4t8")

		c.Expect(value.Min.Latitude, gospec.Equals, 37.83236503601074)
		c.Expect(value.Min.Longitude, gospec.Equals, 112.55836486816406)
		c.Expect(value.Max.Latitude, gospec.Equals, 37.83240795135498)
		c.Expect(value.Max.Longitude, gospec.Equals, 112.5584077835083)
	})
}
Example #4
0
func NumRemainingValuesSpec(c gospec.Context) {
	c.Specify("Can handle any number of terms remaining after evaluation.", func() {
		context := polish.MakeContext()
		context.AddFunc("makeZero", func() {})
		context.AddFunc("makeTwo", func() (int, int) { return 1, 2 })
		res, err := context.Eval("makeTwo")
		c.Assume(len(res), Equals, 2)
		c.Assume(err, Equals, nil)
		res, err = context.Eval("makeZero")
		c.Assume(len(res), Equals, 0)
		c.Assume(err, Equals, nil)
	})
}
Example #5
0
func MatrixIndexerSpec(c gospec.Context) {
	size := 100
	usedIds := make(map[int]bool)
	nodesIds := make(map[VertexId]int)
	for i := 0; i < size; i++ {
		for j := 0; j < i; j++ {
			connId := matrixConnectionsIndexer(VertexId(i), VertexId(j), nodesIds, size, true)
			_, ok := usedIds[connId]
			c.Expect(ok, IsFalse)
			usedIds[connId] = true
		}
	}
}
Example #6
0
func FFT1dSpec(c gospec.Context) {
	signal := Alloc1d(16)
	new_in := Alloc1d(16)
	new_out := Alloc1d(16)
	for i := range signal {
		signal[i] = complex(float32(i), float32(-i))
		new_in[i] = signal[i]
	}
	forward := PlanDft1d(signal, signal, Forward, Estimate)
	c.Specify("Creating a plan doesn't overwrite an existing array if fftw.Estimate is used.", func() {
		for i := range signal {
			c.Expect(signal[i], gospec.Equals, complex(float32(i), float32(-i)))
		}
	})

	// A simple real cosine should result in transform with two spikes, one at S[1] and one at S[-1]
	// The spikes should be real and have amplitude equal to len(S)/2 (because fftw doesn't normalize)
	for i := range signal {
		signal[i] = complex(float32(math.Cos(float64(i)/float64(len(signal))*math.Pi*2)), 0)
		new_in[i] = signal[i]
	}
	forward.Execute()
	c.Specify("Forward 1d FFT works properly.", func() {
		peakVerifier(signal, c)
	})

	// This should also be the case when using new arrays...
	forward.ExecuteNewArray(new_in, new_out)
	c.Specify("New array Forward 1d FFT works properly", func() {
		peakVerifier(new_out, c)
	})
}
Example #7
0
func MultiValueReturnSpec(c gospec.Context) {
	c.Specify("Functions with zero or more than one return values work.", func() {
		context := polish.MakeContext()
		polish.AddIntMathContext(context)
		rev3 := func(a, b, c int) (int, int, int) {
			return c, b, a
		}
		context.AddFunc("rev3", rev3)
		rev5 := func(a, b, c, d, e int) (int, int, int, int, int) {
			return e, d, c, b, a
		}
		context.AddFunc("rev5", rev5)

		res, err := context.Eval("- - - - rev5 rev3 1 2 rev3 4 5 6")
		c.Assume(len(res), Equals, 1)
		c.Assume(err, Equals, nil)
		// - - - - rev5 rev3 1 2 rev3 4 5 6
		// - - - - rev5 rev3 1 2 6 5 4
		// - - - - rev5 6 2 1 5 4
		// - - - - 4 5 1 2 6
		// - - - -1 1 2 6
		// - - -2 2 6
		// - -4 6
		// -10
		c.Expect(int(res[0].Int()), Equals, -10)
	})
}
Example #8
0
func NewArray3Spec(c gospec.Context) {
	d100x20x10 := NewArray3(100, 20, 10)
	c.Specify("Allocates the appropriate memory for 3D arrays.", func() {
		n0, n1, n2 := d100x20x10.Dims()
		c.Expect(n0, gospec.Equals, 100)
		c.Expect(n1, gospec.Equals, 20)
		c.Expect(n2, gospec.Equals, 10)
		var counter float32 = 0.0
		for i := 0; i < n0; i++ {
			for j := 0; j < n1; j++ {
				for k := 0; k < n2; k++ {
					d100x20x10.Set(i, j, k, complex(counter, 0))
					counter += 1.0
				}
			}
		}
		counter = 0.0
		for i := 0; i < n0; i++ {
			for j := 0; j < n1; j++ {
				for k := 0; k < n2; k++ {
					c.Expect(real(d100x20x10.At(i, j, k)), gospec.Equals, counter)
					counter += 1.0
				}
			}
		}
	})
}
Example #9
0
func Mapper2Spec(c gospec.Context) {
	c.Specify("Map from []int to []float64", func() {
		a := []int{0, 1, 2, 3, 4}
		var b []float64
		algorithm.Map2(a, &b, func(n int) float64 { return float64(n) })
		c.Expect(b, ContainsInOrder, []float64{0, 1, 2, 3, 4})
	})
	// c.Specify("Map from []int to []string", func() {
	//   a := []int{0,1,2,3,4}
	//   var b []string
	//   b = algorithm.Map(a, []string{}, func(v interface{}) interface{} { return fmt.Sprintf("%d", v) }).([]string)
	//   c.Expect(b, ContainsInOrder, []string{"0", "1", "2", "3", "4"})
	// })
}
Example #10
0
func CMWCSpec(c gospec.Context) {
	c.Specify("CMWC32 produces the same output as SlowCMWC.", func() {
		fast := core.MakeCMWC32(11, 4)
		slow := core.MakeSlowCMWC(11, 1<<32, 1<<4)
		N := 100000
		for i := 0; i < N; i++ {
			f := fast.Next()
			s := slow.Next()
			c.Expect(f, Equals, s)
			if f != s {
				break
			}
		}
	})
}
Example #11
0
func QuebraLinhaTest(c gospec.Context) {
	c.Specify("Caso texto seja menor q tamanho maximo", func() {
		c.Expect(QuebraLinha("ola mundo", 14), Equals, "ola mundo")
	})

	c.Specify("Caso texto seja maior q tamanho maximo", func() {
		c.Expect(QuebraLinha("lavarini lindo demais", 15), Equals, "lavarini lindo\ndemais")
	})
}
Example #12
0
func ParsingSpec(c gospec.Context) {
	c.Specify("Whitespace is parsed properly.", func() {
		context := polish.MakeContext()
		polish.AddIntMathContext(context)
		res, err := context.Eval("    +           1                      3")
		c.Assume(len(res), Equals, 1)
		c.Assume(err, Equals, nil)
		c.Expect(int(res[0].Int()), Equals, 4)
	})
}
Example #13
0
func BellmanFordSingleSourceSpec(c gospec.Context) {
	gr := generateDirectedGraph1()

	marks := BellmanFordSingleSource(gr, VertexId(2), SimpleWeightFunc)
	c.Expect(len(marks), Equals, gr.Order())

	c.Expect(PathFromMarks(marks, VertexId(6)), ContainsExactly, Values(VertexId(2), VertexId(6)))
	c.Expect(PathFromMarks(marks, VertexId(5)), ContainsExactly, Values(VertexId(2), VertexId(4), VertexId(5)))
	c.Expect(PathFromMarks(marks, VertexId(1)), ContainsExactly, Values())
}
Example #14
0
func NewArraySpec(c gospec.Context) {
	d10 := NewArray(10)
	d100 := NewArray(100)
	d1000 := NewArray(1000)
	c.Specify("Allocates the appropriate memory for 1D arrays.", func() {
		c.Expect(len(d10.Elems), gospec.Equals, 10)
		c.Expect(len(d100.Elems), gospec.Equals, 100)
		c.Expect(len(d1000.Elems), gospec.Equals, 1000)
	})
}
Example #15
0
func Alloc1dSpec(c gospec.Context) {
	d10 := Alloc1d(10)
	d100 := Alloc1d(100)
	d1000 := Alloc1d(1000)
	c.Specify("Allocates the appropriate memory for 1d arrays.", func() {
		c.Expect(len(d10), gospec.Equals, 10)
		c.Expect(len(d100), gospec.Equals, 100)
		c.Expect(len(d1000), gospec.Equals, 1000)
	})
}
Example #16
0
func FFTC2RSpec(c gospec.Context) {
	signal := make([]float64, 16)
	F_signal := make([]complex128, 9)

	forward := PlanDftR2C1d(signal, F_signal, Estimate)
	backward := PlanDftC2R1d(F_signal, signal, Estimate)
	for i := range signal {
		signal[i] = float64(i)
	}
	forward.Execute()
	backward.Execute()

	c.Specify("Forward 1d Complx to Real FFT  works properly.", func() {
		for i := 0; i < len(signal); i++ {
			c.Expect(signal[i], gospec.IsWithin(1e-7), float64(i*len(signal)))
		}
	})
}
Example #17
0
func GetAllMixedPathsSpec(c gospec.Context) {
	gr := generateMixedGraph1()
	/*
		[1 2 4 6]
		[1 2 6]
		[1 2 3 4 6]
		[1 6]
	*/

	pathsCnt := 0

	for path := range GetAllMixedPaths(gr, 1, 6) {
		pathsCnt++
		c.Expect(ContainMixedPath(gr, path, true), IsTrue)
	}

	c.Expect(pathsCnt, Equals, 4)
}
Example #18
0
// Helpers
func NeighborSpecs(c gospec.Context) {
	c.Specify("[Neighbor] North neighbor", func() {
		value := Neighbor("dqcjq", [2]CardialDirections{North, None})
		c.Expect(string(value), gospec.Equals, "dqcjw")
	})

	c.Specify("[Neighbor] South West neighbor", func() {
		value := Neighbor("dqcjq", [2]CardialDirections{South, West})
		c.Expect(string(value), gospec.Equals, "dqcjj")
	})
}
Example #19
0
func FFTSpec(c gospec.Context) {
	signal := NewArray(16)
	new_in := NewArray(16)
	for i := range signal.Elems {
		signal.Elems[i] = complex(float32(i), float32(-i))
		new_in.Elems[i] = signal.Elems[i]
	}

	// A simple real cosine should result in transform with two spikes, one at S[1] and one at S[-1]
	// The spikes should be real and have amplitude equal to len(S)/2 (because fftw doesn't normalize)
	for i := range signal.Elems {
		signal.Elems[i] = complex(float32(math.Cos(float64(i)/float64(len(signal.Elems))*math.Pi*2)), 0)
		new_in.Elems[i] = signal.Elems[i]
	}
	NewPlan(signal, signal, Forward, Estimate).Execute().Destroy()
	c.Specify("Forward 1D FFT works properly.", func() {
		peakVerifier(signal.Elems, c)
	})
}
Example #20
0
func EventListenerSpec(c gospec.Context) {
	input := gin.Make()
	AB_binding := input.MakeBinding('a', []gin.KeyId{'b'}, []bool{true})
	AB := input.BindDerivedKey("AB", AB_binding)
	events := make([]gin.OsEvent, 0)

	c.Specify("Check keys report state properly while handling events", func() {
		injectEvent(&events, 'a', 1, 1)
		injectEvent(&events, 'a', 0, 2)
		injectEvent(&events, 'b', 1, 3)
		injectEvent(&events, 'a', 1, 4)
		injectEvent(&events, 'b', 0, 5)
		injectEvent(&events, 'a', 0, 6)

		c.Specify("Test a", func() {
			la := &listener{
				input:   input,
				key_id:  'a',
				context: c,
			}
			input.RegisterEventListener(la)
			la.ExpectPressCounts(1, 1, 1, 2, 2, 2)
			la.ExpectReleaseCounts(0, 1, 1, 1, 1, 2)
			la.ExpectPressAmts(1, 0, 0, 1, 1, 0)
			input.Think(0, false, events)
		})
		c.Specify("Test b", func() {
			lb := &listener{
				input:   input,
				key_id:  'b',
				context: c,
			}
			input.RegisterEventListener(lb)
			lb.ExpectPressCounts(0, 0, 1, 1, 1, 1)
			lb.ExpectReleaseCounts(0, 0, 0, 0, 1, 1)
			lb.ExpectPressAmts(0, 0, 1, 1, 0, 0)
			input.Think(0, false, events)
		})
		c.Specify("Test ab", func() {
			lab := &listener{
				input:   input,
				key_id:  AB.Id(),
				context: c,
			}
			input.RegisterEventListener(lab)
			lab.ExpectPressCounts(0, 0, 0, 1, 1, 1)
			lab.ExpectReleaseCounts(0, 0, 0, 0, 0, 1)
			lab.ExpectPressAmts(0, 0, 0, 1, 1, 0)
			input.Think(0, false, events)
		})
	})
}
Example #21
0
func FibSpec(c gospec.Context) {
	fib := NewFib().Sequence(10)

	c.Specify("The first two Fibonacci numbers are 0 and 1", func() {
		c.Expect(fib[0], Equals, 0)
		c.Expect(fib[1], Equals, 1)
	})
	c.Specify("Each remaining number is the sum of the previous two", func() {
		for i := 2; i < len(fib); i++ {
			c.Expect(fib[i], Equals, fib[i-1]+fib[i-2])
		}
	})
}
Example #22
0
func ErrorSpec(c gospec.Context) {
	c.Specify("Type-mismatch panics are caught and returned as errors.", func() {
		context := polish.MakeContext()
		polish.AddIntMathContext(context)
		_, err := context.Eval("+ 1.0 2.0")
		c.Assume(err.Error(), Not(Equals), nil)
	})
	c.Specify("Panics from inside functions are caught and returned as errors.", func() {
		context := polish.MakeContext()
		context.AddFunc("panic", func() { panic("rawr") })
		_, err := context.Eval("panic")
		c.Assume(err.Error(), Not(Equals), nil)
	})
}
Example #23
0
func FFT3Spec(c gospec.Context) {
	signal := NewArray3(32, 16, 8)

	n0, n1, n2 := signal.Dims()
	for i := 0; i < n0; i++ {
		for j := 0; j < n1; j++ {
			for k := 0; k < n2; k++ {
				signal.Set(i, j, k, complex(float32(i+j+k), float32(-i-j-k)))
			}
		}
	}

	// As long as fx < dx/2, fy < dy/2, and fz < dz/2, where dx,dy,dz  are the lengths in
	// each dimension, there will be 2^n spikes, where n is the number of dimensions.
	// Each spike will be real and have magnitude equal to dx*dy*dz / 2^n
	dx := n0
	fx := float64(dx) / 4
	dy := n1
	fy := float64(dy) / 4
	dz := n2
	fz := float64(dz) / 4
	for i := 0; i < n0; i++ {
		for j := 0; j < n1; j++ {
			for k := 0; k < n2; k++ {
				cosx := math.Cos(float64(i) / float64(dx) * fx * math.Pi * 2)
				cosy := math.Cos(float64(j) / float64(dy) * fy * math.Pi * 2)
				cosz := math.Cos(float64(k) / float64(dz) * fz * math.Pi * 2)
				signal.Set(i, j, k, complex(float32(cosx*cosy*cosz), 0))
			}
		}
	}
	NewPlan3(signal, signal, Forward, Estimate).Execute().Destroy()
	c.Specify("Forward 3D FFT works properly.", func() {
		for i := 0; i < n0; i++ {
			for j := 0; j < n1; j++ {
				for k := 0; k < n2; k++ {
					if (i == int(fx) || i == dx-int(fx)) &&
						(j == int(fy) || j == dy-int(fy)) &&
						(k == int(fz) || k == dz-int(fz)) {
						c.Expect(real(signal.At(i, j, k)), gospec.IsWithin(1e-7), float32(dx*dy*dz/8))
						c.Expect(imag(signal.At(i, j, k)), gospec.IsWithin(1e-7), 0.0)
					} else {
						c.Expect(real(signal.At(i, j, k)), gospec.IsWithin(1e-7), 0.0)
						c.Expect(imag(signal.At(i, j, k)), gospec.IsWithin(1e-7), 0.0)
					}
				}
			}
		}
	})
}
Example #24
0
func CommandNSpec(c gospec.Context) {
	c.Specify("Sample sprite loads correctly", func() {
		s, err := sprite.LoadSprite("test_sprite")
		c.Expect(err, Equals, nil)
		for i := 0; i < 2000; i++ {
			s.Think(50)
		}
		s.CommandN([]string{
			"turn_right",
			"turn_right",
			"turn_right",
			"turn_right",
			"turn_right",
			"turn_right",
			"turn_left",
			"turn_left",
			"turn_right",
			"turn_right",
			"turn_right",
			"turn_left",
			"turn_left"})
		s.Think(5000)
		c.Expect(s.Facing(), Equals, 1)
		for i := 0; i < 3000; i++ {
			s.Think(50)
		}
	})
}
Example #25
0
func SplitGraphToIndependentSubgraphs_directedSpec(c gospec.Context) {
	c.Specify("Directed graph with 2 independent parts", func() {
		gr1, gr2, gr_merged := genDgr2IndependentSubGr()
		subgraphs := SplitGraphToIndependentSubgraphs_directed(gr_merged)
		c.Expect(len(subgraphs), Equals, 2)
		if subgraphs[0].CheckNode(VertexId(1)) {
			c.Expect(DirectedGraphsEquals(subgraphs[0], gr1), IsTrue)
			c.Expect(DirectedGraphsEquals(subgraphs[1], gr2), IsTrue)
		} else {
			c.Expect(DirectedGraphsEquals(subgraphs[0], gr2), IsTrue)
			c.Expect(DirectedGraphsEquals(subgraphs[1], gr1), IsTrue)
		}
	})
}
Example #26
0
func LoadSpriteSpec(c gospec.Context) {
	c.Specify("Sample sprite loads correctly", func() {
		s, err := sprite.LoadSprite("test_sprite")
		c.Expect(err, Equals, nil)
		for i := 0; i < 2000; i++ {
			s.Think(50)
		}
		s.Command("defend")
		s.Command("undamaged")
		s.Command("defend")
		s.Command("undamaged")
		for i := 0; i < 3000; i++ {
			s.Think(50)
		}
		s.Command("turn_right")
		s.Command("turn_right")
		s.Command("turn_right")
		s.Command("turn_right")
		s.Command("turn_right")
		s.Command("turn_right")
		s.Command("turn_left")
		s.Command("turn_left")
		s.Command("turn_right")
		s.Command("turn_right")
		s.Command("turn_right")
		s.Command("turn_left")
		s.Command("turn_left")
		// s.Think(5000)
		for i := 0; i < 300; i++ {
			s.Think(50)
		}
		c.Expect(s.Facing(), Equals, 1)
	})
}
Example #27
0
func TriangleSpec(c gospec.Context) {
	c.Specify("Check that areaOfPGram() works properly.", func() {
		v0 := linear.Vec2{1, 0}
		v1 := linear.Vec2{0, 0}
		v2 := linear.Vec2{0, 1}
		c.Expect(linear.AreaOfPGram(v0, v1, v2), IsWithin(1e-9), 1.0)
		v3 := linear.Vec2{-1000, 1}
		c.Expect(linear.AreaOfPGram(v0, v1, v3), IsWithin(1e-9), 1.0)
		v4 := linear.Vec2{-10, 20}
		v5 := linear.Vec2{10, 10}
		v6 := linear.Vec2{-5, 10}
		c.Expect(linear.AreaOfPGram(v4, v5, v6), IsWithin(1e-9), 150.0)
	})
}
Example #28
0
func PolySpec2(c gospec.Context) {
	p := linear.Poly{
		{-1, 0},
		{-3, 0},
		{0, 10},
		{3, 0},
		{1, 0},
		{2, 1},
		{-2, 1},
	}
	c.Specify("Check that exterior and interior segments of a polygon are correctly identified.", func() {
		visible_exterior := []linear.Seg2{
			linear.MakeSeg2(-1, 0, -3, 0),
			linear.MakeSeg2(2, 1, -2, 1),
			linear.MakeSeg2(3, 0, 1, 0),
		}
		visible_interior := []linear.Seg2{
			linear.MakeSeg2(2, 1, -2, 1),
			linear.MakeSeg2(-3, 0, 0, 10),
			linear.MakeSeg2(0, 10, 3, 0),
			linear.MakeSeg2(-1, 0, -3, 0),
			linear.MakeSeg2(3, 0, 1, 0),
		}
		c.Expect(p.VisibleExterior(linear.Vec2{0, -10}), ContainsExactly, visible_exterior)
		c.Expect(p.VisibleInterior(linear.Vec2{0, 5}), ContainsExactly, visible_interior)
	})
}
Example #29
0
func CMWCRandSpec(c gospec.Context) {
	c.Specify("CMWC32 conforms properly to math/rand.Rand interface.", func() {
		c1 := cmwc.MakeCmwc(3278470471, 4)
		c2 := cmwc.MakeCmwc(3278470471, 4)
		c1.Seed(1234)
		c2.Seed(4321)

		// Make sure that we don't generate numbers with the most significant
		// bit set
		for i := 0; i < 1000000; i++ {
			v1 := c1.Int63()
			c.Expect(v1 >= 0, Equals, true)
			if v1 < 0 {
				break
			}
			c2.Int63()
		}

		// Make sure that two generators with the same parameters, but in
		// different states, are in the exact same state when seeded with
		// the same seed.
		c1.Seed(0xabcdef12)
		c2.Seed(0xabcdef12)
		for i := 0; i < 10000; i++ {
			v1 := c1.Int63()
			v2 := c2.Int63()
			c.Expect(v1, Equals, v2)
			if v1 != v2 {
				break
			}
		}
	})
}
Example #30
0
func MapperSpec(c gospec.Context) {
	c.Specify("Map from []int to []float64", func() {
		a := []int{0, 1, 2, 3, 4}
		var b []float64
		b = algorithm.Map(a, []float64{}, func(v interface{}) interface{} { return float64(v.(int)) }).([]float64)
		c.Expect(b, ContainsInOrder, []float64{0, 1, 2, 3, 4})
	})
	c.Specify("Map from []int to []string", func() {
		a := []int{0, 1, 2, 3, 4}
		var b []string
		b = algorithm.Map(a, []string{}, func(v interface{}) interface{} { return fmt.Sprintf("%d", v) }).([]string)
		c.Expect(b, ContainsInOrder, []string{"0", "1", "2", "3", "4"})
	})
}