예제 #1
0
func testSortFn(t *testing.T, fn sortFn, fnName string) {
	for _, test := range []sort.Interface{
		sort.IntSlice([]int{660, 14, 796, 336, 223, 594, 419, 574, 372, 103, 991, 718, 436, 351, 844, 277, 668, 250, 330, 86}),
		sort.Float64Slice([]float64{213.237, 458.642, 978.311, 547.351, 57.8992, 245.518, 445.638, 251.79, 960.202, 100.069, 483.136, 407.858, 496.913, 562.943, 557.959, 219.648, 164.599, 843.304, 671.732, 222.676}),
		sort.StringSlice([]string{"assaults", "brackish", "monarchism", "ascribe", "mechanize", "andiron", "overpricing", "jading", "hauliers", "snug", "zodiac", "credit", "tremendous", "palavered", "hibiscuses", "amplest", "interrogated", "geologic", "unorthodoxy", "propagated"}),
	} {
		// Make a copy to avoid modification of the original slice.
		var data sort.Interface
		switch v := test.(type) {
		case sort.IntSlice:
			data = append(sort.IntSlice(nil), v...)
		case sort.Float64Slice:
			data = append(sort.Float64Slice(nil), v...)
		case sort.StringSlice:
			data = append(sort.StringSlice(nil), v...)
		default:
			t.Errorf("missing case: cannot copy %T", v)
			continue
		}
		fn(data)
		if !sort.IsSorted(data) {
			t.Errorf("%s(%v)", fnName, test)
			t.Errorf(" got %v", data)
			sort.Sort(data)
			t.Errorf("want %v", data)
		}
	}
}
예제 #2
0
func writeGff3(chromMapDict map[string]*ContigMap, comparisonMethod *string) {

	for chrom, value := range chromMapDict {
		// Open a file-handle for this chromosome
		var (
			chromFh *os.File
			err     error
			f       string = chrom + OutputSuffix
		)
		log.Println("Writing gff3 for", f)

		// Try to create the file
		if chromFh, err = os.Create(f); err != nil {
			log.Fatal(err)
		}
		currentContig := value.firstContig

		chromFh.WriteString("##gff-version3\n")
		// TODO: Find a way to replace the -1. Not easy and not important.
		chromFh.WriteString("##sequence-region  " + currentContig.chromosome + "   1   -1\n")

		for currentContig != nil {
			lineSlice := getGff3Line(currentContig)
			chromFh.WriteString(strings.Join(lineSlice, "\t") + "\n")

			if len(currentContig.dictOfPartners) > 0 {
				// We can place unplaced contigs here!
				// sort the keys of the dictOfPartners by score
				scores := make([]float64, len(currentContig.dictOfPartners))
				i := 0
				for key, _ := range currentContig.dictOfPartners {
					scores[i] = key
					i++
				}
				// With Hamming, the lowest score is the best, so normal sorting is alright - in all other cases, high is better, so we have to invert
				if *comparisonMethod == "hamming" {
					// sort by lowest to highest
					sort.Sort(sort.Float64Slice(scores))
				} else {
					sort.Sort(sort.Reverse(sort.Float64Slice(scores)))
				}

				// Each value for the keys is a slice of contigs - we can't sort these, so keep them the way they showed up
				// In 99.9999% of cases the slice has only one contig
				for _, score := range scores {
					contigs := currentContig.dictOfPartners[score]
					for _, c := range contigs {
						lineSlice := getGff3Line(c)
						chromFh.WriteString(strings.Join(lineSlice, "\t") + "\n")
					}
				}
			}
			currentContig = currentContig.nextContig
		}
	}
}
예제 #3
0
파일: sort.go 프로젝트: upccup/cuplearn
func main() {
	files, _ := ioutil.ReadDir("../")
	sort.Sort(ByTime(files))
	for i := 0; i < len(files); i++ {
		fmt.Println(files[i].ModTime())
		// 2015-08-10 14:43:35 +0800 CST
		// 2015-08-10 16:03:25 +0800 CST
		// ...
	}

	d := []int{5, 2, 4, 6, 5, 5, 1, 11, 43, 0, -1}
	sort.Sort(sort.IntSlice(d))
	fmt.Println(d) // [-1 0 1 2 4 5 5 5 6 11 43]

	a := []float64{1.2, -1, 0.0, 1.0, 89.2, 0.0001, 1.2345}
	sort.Sort(sort.Float64Slice(a))
	fmt.Println(a) // [-1 0 0.0001 1 1.2 1.2345 89.2]

	s := []string{"PHP", "go", "Go", "java", "python", "c"}
	sort.Sort(sort.StringSlice(s))
	fmt.Println(s) // [Go PHP c go java python]

	fruits := []string{"peach", "banana", "kiwi"}
	sort.Sort(ByLenth(fruits))
	fmt.Println(fruits) // [banana kiwi peach]
}
예제 #4
0
func (self *DB) Zsort(name string) {
	//
	//self.mu.Lock()

	values := make([]float64, len(self.zmp[name]))
	tm := make(map[float64][]NF, len(self.zmp[name]))
	for i := 0; i < len(self.zmp[name]); i += 1 {
		value := self.zmp[name][i].Value
		values[i] = value
		tm[value] = append(tm[value], self.zmp[name][i])
	}
	a := sort.Float64Slice(values[0:])
	sort.Sort(a)

	var temp []NF
	var old float64
	for i := 0; i < len(a); i += 1 {
		if old != a[i] {
			temp = append(temp, tm[a[i]]...)
		}
		old = a[i]
	}
	self.zmp[name] = temp
	//self.mu.Unlock()
}
예제 #5
0
파일: svd_test.go 프로젝트: jvlmdr/lin-go
func TestSVD_vsEig(t *testing.T) {
	m, n := 150, 100
	a := randMat(m, n)
	g := mat.Mul(mat.T(a), a)

	// Take eigen decomposition of Gram matrix.
	_, eigs, err := EigSymm(g)
	if err != nil {
		t.Fatal(err)
	}
	// Sort in descending order.
	sort.Sort(sort.Reverse(sort.Float64Slice(eigs)))
	// Take square root of eigenvalues.
	for i := range eigs {
		// Clip small negative values to zero.
		eigs[i] = math.Sqrt(math.Max(0, eigs[i]))
	}

	// Take singular value decomposition.
	_, svals, _, err := SVD(a)
	if err != nil {
		t.Fatal(err)
	}

	testSliceEq(t, eigs, svals)
}
예제 #6
0
func (nv *NearestValueThreshold) compute(data map[string]float64, total int) (float64, error, string) {
	var err error
	var msg string
	testValue := float64(0)

	testFloat, err := strconv.ParseFloat(nv.Value, 64)
	if err != nil {
		msg = fmt.Sprintf("Error converting value to float: %s", err)
		logrus.Error(msg)
		return testValue, err, msg
	}

	fm, _ := numeric.ND_Mapper(data)
	keys := fm.FloatSlice
	m := fm.Float2String
	sort.Sort(sort.Float64Slice(keys))

	for _, k := range keys {
		if testFloat >= k {
			testValue = data[m[k]]
		} else {
			break
		}
	}

	testValue = testValue * 100
	return testValue, err, msg
}
func main() {
	intList := []int{2, 4, 3, 5, 7, 6, 9, 8, 1, 0}
	float8List := []float64{4.2, 5.9, 12.3, 10.0, 50.4, 99.9, 31.4, 27.81828, 3.14}
	stringList := []string{"a", "c", "b", "d", "f", "i", "z", "x", "w", "y"}
	fmt.Println("------------正序---------------")
	sort.Ints(intList)
	sort.Float64s(float8List)
	sort.Strings(stringList)
	fmt.Printf("%v\n%v\n%v\n", intList, float8List, stringList)
	fmt.Println("------------倒序---------------")
	sort.Sort(sort.Reverse(sort.IntSlice(intList)))
	sort.Sort(sort.Reverse(sort.Float64Slice(float8List)))
	sort.Sort(sort.Reverse(sort.StringSlice(stringList)))
	fmt.Printf("%v\n%v\n%v\n", intList, float8List, stringList)
	fmt.Println("-------------结构体(特定字段)排序-----------")
	people := []Person{
		{"zhang san", 12},
		{"li si", 30},
		{"wang wu", 52},
		{"zhao liu", 26},
	}
	fmt.Println(people)
	sort.Sort(PersonWrapper{people, func(p, q *Person) bool {
		return q.Age < p.Age //Age 递减排序
	}})
	fmt.Println(people)
	sort.Sort(PersonWrapper{people, func(p, q *Person) bool {
		return p.Name < q.Name //Name 递增排序
	}})
	fmt.Println(people)
}
예제 #8
0
func (bc *BayesianClassifier) filteredProbabilities(tokens []string, categories []string) (map[string][]float64, error) {
	probs, err := bc.probabilities(tokens, categories)
	if err != nil {
		return nil, err
	}

	for cat, pr := range probs {
		if bc.MinProbabilityStrength > 0.0 {
			i := 0
			for i < len(pr) {
				dist := math.Abs(pr[i] - 0.5)
				if dist >= bc.MinProbabilityStrength {
					i++
				} else {
					if i == len(pr)-1 {
						pr = pr[:len(pr)-1]
						break
					}
					pr[i] = pr[len(pr)-1]
					pr = pr[:len(pr)-1]
				}
			}
		}

		if bc.MaxDiscriminators > 0 && len(pr) > bc.MaxDiscriminators {
			sort.Sort(sort.Float64Slice(pr))
			pr = pr[:bc.MaxDiscriminators]
		}

		probs[cat] = pr
	}

	return probs, nil
}
예제 #9
0
파일: percentile.go 프로젝트: ARodri/hume
//NEAREST RANK METHOD (USES ONLY MEMBERS OF POPULATION - NO INTERPOLATION)
func (p *Percentile) Finalize() error {
	p.result = make(map[string]float64)

	fm, _ := numeric.ND_Mapper(p.counts)
	keys := fm.FloatSlice
	m := fm.Float2String
	totalFloat := fm.TotalFloat
	sort.Sort(sort.Float64Slice(keys))

	for c := float64(0); c < 100; c++ {
		threshold := totalFloat * c / 100
		sum := float64(0)
		//keep index of key coorsponding to last sum
		var i int
		var k float64
		for i, k = range keys {
			sum += p.counts[m[k]]
			if sum >= threshold {
				break
			}
		}
		p.result[strconv.FormatFloat(c, 'f', -1, 64)] = keys[i]
	}

	return nil
}
예제 #10
0
// Export the set of values in the Ring Buffer, where the latest value
// will be last in the array.  If the Buffer was not full, 0 will be exported.
func (buf *RingBuffer) Export() []float64 {
	buf.mu.Lock()
	defer buf.mu.Unlock()

	length := len(buf.values)
	data := make([]float64, length)

	idx := 0
	for i := buf.oldest; i < len(buf.values); i++ {
		v := buf.values[i]
		if v != nil {
			data[idx] = *v
			idx++
		}
	}

	for i := 0; i < buf.oldest; i++ {
		v := buf.values[i]
		if v != nil {
			data[idx] = *v
			idx++
		}
	}

	sort.Reverse(sort.Float64Slice(data))
	shrink := make([]float64, idx)
	copy(shrink, data)

	return shrink
}
예제 #11
0
func doloop() {
	var f0 float64 // Nominal lens focal length
	var fm float64 // Focal length at minimum focus distance
	var md float64 // Minimum focus distance w/out extension
	var err error  // Error return
	var exlist []float64

	flag.Parse()
	if flag.NArg() < 3 {
		println("Sorry, need 3+ args")
		return
	}
	f0, err = strconv.ParseFloat(flag.Arg(0), 64)
	if err != nil {
		println("Sorry - bad focal length")
		return
	}
	md, err = strconv.ParseFloat(flag.Arg(1), 64)
	if err != nil {
		println("Sorry - bad minimum distance")
		return
	}
	exlist = getext()
	sort.Sort(sort.Reverse(sort.Float64Slice(exlist)))
	mdm := 1000 * md
	fm = f0 * (mdm - f0) / mdm
	fmt.Printf("Lens: %5.0f mm, Min focus: %0.3f m, Fmin %0.1f mm\n", f0, md, fm)
	calcext(exlist, f0, fm)
	return
}
예제 #12
0
// BinarySuffix returns the given number with a binary suffix.
func BinarySuffix(number float64) string {
	var str string
	if number < 0 {
		str = "-"
		number = math.Abs(number)
	}
	var binarySuffixPrefixes = map[float64]string{
		1125899906842624: "%.2f PB",
		1099511627776:    "%.2f TB",
		1073741824:       "%.2f GB",
		1048576:          "%.2f MB",
		1024:             "%.1f kB",
	}
	intSlice := make([]float64, 0, len(binarySuffixPrefixes))
	for num := range binarySuffixPrefixes {
		intSlice = append(intSlice, num)
	}
	sort.Sort(sort.Reverse(sort.Float64Slice(intSlice)))
	for _, size := range intSlice {
		if size <= number {
			var value float64
			if number >= BinaryConvertThreshold {
				value = number / float64(size)
			}
			return str + fmt.Sprintf(binarySuffixPrefixes[size], value)
		}
	}
	return fmt.Sprintf("%s%.0f bytes", str, number)
}
예제 #13
0
파일: main.go 프로젝트: whitezhang/TDT-Web
func NewSlice(n []float64) *Slice {
	s := &Slice{Float64Slice: sort.Float64Slice(n), idx: make([]int, len(n))}
	for i := range s.idx {
		s.idx[i] = i
	}
	return s
}
예제 #14
0
파일: hist.go 프로젝트: benbooth493/bender
func (h *Histogram) Percentiles(percentiles ...float64) []int {
	result := make([]int, len(percentiles))
	if percentiles == nil || len(percentiles) == 0 {
		return result
	}

	sort.Sort(sort.Float64Slice(percentiles))

	accum := 0
	p_idx := int(math.Max(1.0, percentiles[0]*float64(h.n)))
	for i, j := 0, 0; i < len(percentiles) && j < len(h.values); j++ {
		accum += h.values[j]

		for accum >= p_idx {
			result[i] = j
			i++
			if i >= len(percentiles) {
				break
			}
			p_idx = int(math.Max(1.0, percentiles[i]*float64(h.n)))
		}
	}

	return result
}
예제 #15
0
파일: util.go 프로젝트: 1394/skia-buildbot
// Float64StableSum returns the sum of the elements of the given []float64
// in a relatively stable manner.
func Float64StableSum(s []float64) float64 {
	sort.Sort(sort.Float64Slice(s))
	sum := 0.0
	for _, elem := range s {
		sum += elem
	}
	return sum
}
예제 #16
0
파일: versions.go 프로젝트: vonwenm/spdy
// SupportedVersions will return a slice of supported SPDY versions.
// The returned versions are sorted into order of most recent first.
func SupportedVersions() []float64 {
	s := make([]float64, 0, len(supportedVersions))
	for v, _ := range supportedVersions {
		s = append(s, v)
	}
	sort.Sort(sort.Reverse(sort.Float64Slice(s)))
	return s
}
예제 #17
0
func TestFloat64s(t *testing.T) {
	data := float64s
	Sort(sort.Float64Slice(data[0:]))
	if !sort.Float64sAreSorted(data[0:]) {
		t.Errorf("sorted %v", float64s)
		t.Errorf("   got %v", data)
	}
}
예제 #18
0
func TestSortFloat64Slice(t *testing.T) {
	data := float64s
	a := sort.Float64Slice(data[0:])
	Sort(a)
	if !sort.IsSorted(a) {
		t.Errorf("sorted %v", float64s)
		t.Errorf("   got %v", data)
	}
}
예제 #19
0
func withinError(t *testing.T, fn Estimate, q, e float64) func(N uint32) bool {
	return func(N uint32) bool {
		n := int(N % 1000000)
		est := New(fn)
		obs := make([]float64, 0, n)

		for i := 0; i < n; i++ {
			s := rand.NormFloat64()*1.0 + 0.0
			obs = append(obs, s)
			est.Add(s)
		}

		if est.Samples() != n {
			return false
		}

		sort.Float64Slice(obs).Sort()

		// "v" the estimate
		estimate := est.Get(q)
		if n == 0 {
			return estimate == 0
		}

		// A[⌈(φ − ε)n⌉] ≤ v ≤ A[⌈(φ + ε)n⌉]
		// The bounds of the estimate
		lower := int((q-e)*float64(n)) - 1
		upper := int((q+e)*float64(n)) + 1

		// actual v
		exact := int(q * float64(n))

		min := obs[0]
		if lower > 0 {
			min = obs[lower]
		}

		max := obs[len(obs)-1]
		if upper < len(obs) {
			max = obs[upper]
		}

		t.Logf("delta: %d ex: %f min: %f (%f) max: %f (%f) est: %f n: %d l: %d",
			upper-lower, obs[exact], min, obs[0], max, obs[len(obs)-1], estimate, n, est.items)

		fits := (min <= estimate && estimate <= max)

		if !fits {
			for cur := est.head; cur != nil; cur = cur.next {
				t.Log(cur)
			}
		}

		return fits
	}
}
예제 #20
0
파일: grid.go 프로젝트: mrfuxi/sudoku
// Splits lines into groups of 10 with score of how much linearly distributed they are
func linearDistances(lines []polarLine, dividerLine polarLine) []scoredLines {
	// Lines have to be sorted correctly!
	var matches []scoredLines

	linesCount := len(lines)
	if linesCount < 10 {
		return matches
	}

	intersections := make([]image.Point, linesCount, linesCount)
	for i, line := range lines {
		_, point := intersection(line, dividerLine)
		intersections[i] = point
	}

	points := make([]float64, len(lines), len(lines))
	for i, point := range intersections {
		points[i] = distanceBetweenPoints(intersections[0], point)
	}

	distances := preparePointDistances(points)

	expectedPoints := make([]float64, 10, 10)

	for i := range points[:linesCount-10+1] {
		dI := i + 10 - 1
		for j := range points[dI:] {
			start, end := points[i], points[j+dI]
			step := (end - start) / 9.0
			for k := range expectedPoints {
				expectedPoints[k] = start + step*float64(k)
			}
			score, selectedPoints := pointSimilarities(expectedPoints, distances)

			if len(selectedPoints) != 10 {
				continue
			}

			match := scoredLines{
				Score: score,
				Lines: make([]polarLine, 10, 10),
			}

			searchablePoints := sort.Float64Slice(points)
			for l := range match.Lines {
				match.Lines[l] = lines[searchablePoints.Search(selectedPoints[l])]
			}

			matches = append(matches, match)
		}
	}

	return matches
}
예제 #21
0
func main() {
	a := []int{10, 5, 3, 7, 6}
	b := []float64{4.2, 7.6, 5.5, 1.3, 9.9}
	c := []string{"Maria", "Andrew", "John"}

	sort.Sort(sort.IntSlice(a)) // int 슬라이스를 오름차순으로 정렬
	fmt.Println(a)
	sort.Sort(sort.Reverse(sort.IntSlice(a))) // int 슬라이스를 내림차순으로 정렬
	fmt.Println(a)

	sort.Sort(sort.Float64Slice(b)) // float64 슬라이스를 오름차순으로 정렬
	fmt.Println(b)
	sort.Sort(sort.Reverse(sort.Float64Slice(b))) // float64 슬라이스를 내림차순으로 정렬
	fmt.Println(b)

	sort.Sort(sort.StringSlice(c)) // string 슬라이스를 오름차순으로 정렬
	fmt.Println(c)
	sort.Sort(sort.Reverse(sort.StringSlice(c))) // string 슬라이스를 내림차순으로 정렬
	fmt.Println(c)
}
예제 #22
0
// Dlasrt sorts the numbers in the input slice d. If sort == lapack.SortIncreasing,
// the elements are sorted in increasing order. If sort == lapack.SortDecreasing,
// the elements are sorted in decreasing order.
//
// Dlasrt is an internal routine. It is exported for testing purposes.
func (impl Implementation) Dlasrt(s lapack.Sort, n int, d []float64) {
	checkVector(n, d, 1)
	d = d[:n]
	switch s {
	default:
		panic("lapack: bad sort")
	case lapack.SortIncreasing:
		sort.Float64s(d)
	case lapack.SortDecreasing:
		sort.Sort(sort.Reverse(sort.Float64Slice(d)))
	}
}
예제 #23
0
파일: ks.go 프로젝트: ARodri/hume
func (ks *KS) compute(data map[string]float64, total int) (float64, error, string) {
	var err error
	var msg string
	testValue := float64(0)

	fm_data, _ := numeric.ND_Mapper(data)
	keys_data := fm_data.FloatSlice
	map_data := fm_data.Float2String
	totalZero := fm_data.TotalFloat

	benchmark, err := histogram.GetFloatMap(ks.BenchmarkJSON)
	if err != nil {
		msg = fmt.Sprintf("Error in benchmark float map: %s", err)
		logrus.Error(msg)
		return testValue, err, msg
	}
	fm_benchmark, err := numeric.ND_Mapper(benchmark)
	if err != nil {
		msg = fmt.Sprintf("Error in mapping benchmark to NumericDistribution: %s", err)
		logrus.Error(msg)
		return testValue, err, msg
	}
	keys_benchmark := fm_benchmark.FloatSlice
	map_benchmark := fm_benchmark.Float2String
	totalOne := fm_benchmark.TotalFloat

	key_map, keys_all := arrayMapper(keys_data, keys_benchmark)
	sort.Sort(sort.Float64Slice(keys_all))

	zeroSoFar := float64(0)
	oneSoFar := float64(0)
	currentKS := math.NaN()
	maxKS := float64(0)

	for _, f := range keys_all {
		if key_map[f][0] {
			zeroSoFar += data[map_data[f]]
		}
		if key_map[f][1] {
			oneSoFar += benchmark[map_benchmark[f]]
		}

		currentKS = (zeroSoFar / totalZero) - (oneSoFar / totalOne)

		if math.Abs(currentKS) > math.Abs(maxKS) || math.IsNaN(currentKS) {
			maxKS = currentKS
		}
	}

	testValue = maxKS * 100
	return testValue, err, msg
}
예제 #24
0
파일: sort_test.go 프로젝트: tornyak/goalg
func TestSortFloat64Slice(t *testing.T) {
	data := float64s

	for _, alg := range algorithms {
		a := sort.Float64Slice(data[:])
		alg(a)
		if !sort.IsSorted(a) {
			t.Errorf("%v\n", util.GetFuncName(alg))
			t.Errorf("sorted: %v\n", float64s)
			t.Errorf("   got: %v\n", data)
		}
	}
}
예제 #25
0
/*KindFromSides determines the type of triangle formed by sides a, b and c
the triangle is invaid if the longest side is equal or longer than the shorter sides
or any of the sides are invalid (0 or less, NaN or Inf+)*/
func KindFromSides(a, b, c float64) Kind {
	sides := []float64{a, b, c}
	sort.Sort(sort.Float64Slice(sides))
	switch {
	case math.IsNaN(sides[0]) || sides[0] <= 0 || sides[2] == math.Inf(1) ||
		sides[1]+sides[0] <= sides[2]:
		return NaT
	case sides[0] == sides[1] && sides[1] == sides[2]:
		return Equ
	case sides[0] == sides[1] || sides[1] == sides[2]:
		return Iso
	}
	return Sca
}
예제 #26
0
func main() {
	var n int
	fmt.Scanln(&n)
	w := make([]float64, n)
	for i := 0; i < n; i++ {
		fmt.Scanln(&w[i])
	}
	for n > 1 {
		sort.Sort(sort.Float64Slice(w))
		val := 2 * math.Sqrt(w[n-2]*w[n-1])
		n--
		w = w[:n]
		w[n-1] = val
	}
	fmt.Println(w[0])
}
예제 #27
0
func (cdf *CDF) Finalize() error {
	cdf.result = make(map[string]float64)

	fm, _ := numeric.ND_Mapper(cdf.counts)
	keys := fm.FloatSlice
	m := fm.Float2String
	totalFloat := fm.TotalFloat
	sort.Sort(sort.Float64Slice(keys))

	sum := float64(0)
	for _, f := range keys {
		sum += cdf.counts[m[f]]
		cdf.result[m[f]] = sum / totalFloat
	}

	return nil
}
예제 #28
0
func ExampleEigSymm() {
	a := mat.NewRows([][]float64{
		{7, -2, 0},
		{-2, 6, -2},
		{0, -2, 5},
	})

	_, d, err := EigSymm(a)
	if err != nil {
		fmt.Println(err)
		return
	}
	sort.Sort(sort.Float64Slice(d))
	fmt.Printf("%.6g\n", d)
	// Output:
	// [3 6 9]
}
예제 #29
0
// NewDataset constructs a dataset from the provided records. The records can be
// provided in any order and are automatically sorted (but NOT de-duplicated).
// If no records are provided, this function will return nil.
func NewDataset(records ...float64) *Dataset {
	if len(records) == 0 {
		return nil
	}
	slice := sort.Float64Slice(records)
	slice.Sort()
	d := &Dataset{
		records: []float64(slice),
		len:     len(records),
	}
	d.min = d.records[0]
	d.max = d.records[d.len-1]
	for _, record := range d.records {
		d.sum = d.sum + record
	}
	return d
}
예제 #30
0
func (r *SVGReport) drawDurationsHistogram(report *Report) int {
	waitTimes := []float64{}
	for _, start := range report.AuctionResults.SuccessfulLRPs {
		waitTimes = append(waitTimes, start.WaitDuration.Seconds())
	}
	sort.Sort(sort.Float64Slice(waitTimes))

	bins := binUp([]float64{0, 0.25, 0.5, 1, 2, 5, 10, 20, 40, 1e9}, waitTimes)
	labels := []string{"<0.25s", "0.25-0.5s", "0.5-1s", "1-2s", "2-5s", "5-10s", "10-20s", "20-40s", ">40s"}

	r.SVG.Translate(border*2+instanceBoxWidth, border)

	yBottom := r.drawHistogram(bins, labels)

	r.SVG.Gend()

	return yBottom + border //'cause of the translate
}