[ { "path": "LICENSE", "content": "Copyright (c) 2015 The Go Authors. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are\nmet:\n\n * Redistributions of source code must retain the above copyright\nnotice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above\ncopyright notice, this list of conditions and the following disclaimer\nin the documentation and/or other materials provided with the\ndistribution.\n * Neither the name of Google Inc. nor the names of its\ncontributors may be used to endorse or promote products derived from\nthis software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\nLIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\nA PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\nOWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\nSPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\nLIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\nDATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\nTHEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n" }, { "path": "abi/abi.go", "content": "// Copyright 2020 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage main\n\n// To analyze kubelet:\n//\n// ( X=$PWD; cd -q ~/s/kubernetes && $X/abi $(go list -deps ./cmd/kubelet) )\n\nimport (\n\t\"flag\"\n\t\"fmt\"\n\t\"go/types\"\n\t\"io\"\n\t\"log\"\n\t\"math\"\n\t\"os\"\n\t\"reflect\"\n\t\"sort\"\n\n\t\"golang.org/x/tools/go/packages\"\n)\n\nconst (\n\tminIntRegs = 0\n\tmaxIntRegs = 16\n\n\t// The number of floating-point registers has little\n\t// effect. Just fix it at 8.\n\tminFloatRegs = 8\n\tmaxFloatRegs = 8\n\n\t// Comparison mode.\n\tmodeCompare = false\n)\n\nfunc main() {\n\tflag.Parse()\n\tpkgPaths := flag.Args()\n\n\t// Get the package count to give the user some feedback.\n\tcfg := &packages.Config{}\n\tcfg.Mode = packages.NeedName\n\tpkgs, err := packages.Load(cfg, pkgPaths...)\n\tif err != nil {\n\t\tlog.Fatal(err)\n\t}\n\tif packages.PrintErrors(pkgs) > 0 {\n\t\tos.Exit(1)\n\t}\n\tfmt.Fprintf(os.Stderr, \"checking %d packages...\\n\", len(pkgs))\n\n\t// Parse and type-check the packages.\n\tcfg.Mode = packages.NeedName | packages.NeedTypes | packages.NeedTypesInfo | packages.NeedTypesSizes\n\tpkgs, err = packages.Load(cfg, pkgPaths...)\n\tif err != nil {\n\t\tlog.Fatal(err)\n\t}\n\tif packages.PrintErrors(pkgs) > 0 {\n\t\tos.Exit(1)\n\t}\n\n\t// Extract all the functions.\n\tvar funcs []*types.Func\n\tvar sizes types.Sizes\n\tfor _, pkg := range pkgs {\n\t\tsizes = pkg.TypesSizes\n\t\tfor _, obj := range pkg.TypesInfo.Defs {\n\t\t\tif obj, ok := obj.(*types.Func); ok {\n\t\t\t\tfuncs = append(funcs, obj)\n\t\t\t}\n\t\t}\n\t}\n\n\t// Analyze.\n\tqtiles := []float64{0.5, 0.95, 0.99}\n\tqtileLabels := []string{\"p50\", \"p95\", \"p99\"}\n\ttable := [][]interface{}{\n\t\t{\"\", \"\", \"\", \"stack args\", \"spills\", \"stack total\"},\n\t\t{\"ints\", \"floats\", \"% fit\", qtileLabels, qtileLabels, qtileLabels},\n\t}\n\tif modeCompare {\n\t\tqtiles = []float64{0.5, 0.95, 0.99, 1.0}\n\t\tqtileLabels = []string{\"p50\", \"p95\", \"p99\", \"max\"}\n\t\ttable = [][]interface{}{\n\t\t\t{\"\", \"\", \"\", \"\", \"Δ stack bytes\"},\n\t\t\t{\"ints\", \"floats\", \"Δ % fit\", \"diff\", qtileLabels, \"% bigger\"},\n\t\t}\n\t}\n\topts := ABIOptions{\n\t\tEmptyArray: true,\n\t\tOneArray: true,\n\t\tSplitArrays: false,\n\t\tIgnoreBlank: false,\n\t\tSpillRegs: false,\n\t\tEmptyOnStack: true,\n\t}\n\tcmp := opts\n\tcmp.ABI0 = true\n\n\tconst infinity = math.MaxInt32\n\tanalyze := func(opts, cmp ABIOptions) {\n\t\tvar stackBytes []int\n\t\tvar spillBytes []int\n\t\tvar stackTotal []int\n\t\tvar overheads []int // Stack bytes vs ABI0\n\t\tfit := 0 // # functions that fit entirely in registers\n\t\tcmpFit := 0\n\t\tcmpDiff := 0 // # functions with any frame difference\n\t\tcmpLarger := 0 // # functions with larger stack frames in cmp\n\n\t\tfor _, f := range funcs {\n\t\t\tsig := f.Type().(*types.Signature)\n\n\t\t\tframe := opts.Assign(sig, sizes)\n\n\t\t\tstackBytes = append(stackBytes, frame.StackBytes)\n\t\t\tspillBytes = append(spillBytes, frame.StackSpillBytes)\n\t\t\tstackTotal = append(stackTotal, frame.StackTotal)\n\t\t\tif frame.StackBytes == 0 {\n\t\t\t\tfit++\n\t\t\t}\n\n\t\t\tif modeCompare {\n\t\t\t\t// Compare to alternate options.\n\t\t\t\tframeCmp := cmp.Assign(sig, sizes)\n\t\t\t\toverhead := frameCmp.StackTotal - frame.StackTotal\n\t\t\t\toverheads = append(overheads, overhead)\n\t\t\t\tif frameCmp.StackBytes == 0 {\n\t\t\t\t\tcmpFit++\n\t\t\t\t}\n\t\t\t\tif frame != frameCmp {\n\t\t\t\t\tcmpDiff++\n\t\t\t\t}\n\t\t\t\tif overhead > 0 {\n\t\t\t\t\tcmpLarger++\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\trow := []interface{}{opts.IntRegs, opts.FloatRegs}\n\t\tif opts.IntRegs == infinity {\n\t\t\trow[0] = \"∞\"\n\t\t}\n\t\tif opts.FloatRegs == infinity {\n\t\t\trow[1] = \"∞\"\n\t\t}\n\n\t\tif modeCompare {\n\t\t\tpct := func(n int) string {\n\t\t\t\treturn fmt.Sprintf(\"%5.2f%%\", 100*float64(n)/float64(len(funcs)))\n\t\t\t}\n\t\t\trow = append(row, pct(cmpFit-fit))\n\t\t\trow = append(row, []interface{}{cmpDiff, pct(cmpDiff)})\n\t\t\trow = append(row, intQuantiles(overheads, qtiles...))\n\t\t\trow = append(row, pct(cmpLarger))\n\t\t} else {\n\t\t\trow = append(row, fmt.Sprintf(\"%4.1f%%\", 100*float64(fit)/float64(len(funcs))))\n\t\t\trow = append(row, intQuantiles(stackBytes, qtiles...))\n\t\t\trow = append(row, intQuantiles(spillBytes, qtiles...))\n\t\t\trow = append(row, intQuantiles(stackTotal, qtiles...))\n\t\t}\n\n\t\ttable = append(table, row)\n\t}\n\tanalyze(opts, cmp)\n\tfor opts.IntRegs = minIntRegs; opts.IntRegs <= maxIntRegs; opts.IntRegs++ {\n\t\tfor opts.FloatRegs = minFloatRegs; opts.FloatRegs <= maxFloatRegs; opts.FloatRegs++ {\n\t\t\tcmp.IntRegs, cmp.FloatRegs = opts.IntRegs, opts.FloatRegs\n\t\t\tanalyze(opts, cmp)\n\t\t}\n\t}\n\topts.IntRegs, opts.FloatRegs = infinity, maxFloatRegs\n\tcmp.IntRegs, cmp.FloatRegs = opts.IntRegs, opts.FloatRegs\n\tanalyze(opts, cmp)\n\n\t// Print results.\n\tprintTable(os.Stdout, table)\n}\n\ntype ABIOptions struct {\n\tIntRegs, FloatRegs int\n\n\tABI0 bool // Use ABI0 (other options are ignored)\n\n\tEmptyArray bool // Empty arrays don't stack-assign\n\tOneArray bool // Size-1 arrays don't stack-assign\n\tSplitArrays bool // Stack-assign arrays separately from rest of arg\n\tIgnoreBlank bool // Skip assigning blank fields\n\tSpillRegs bool // Structure spill space as register words\n\tEmptyOnStack bool // Stack-assign zero-sized values\n}\n\ntype frameBuilder struct {\n\topts *ABIOptions\n\tsizes types.Sizes\n\tptrSize int\n\n\tints, floats int\n\n\tFrame\n}\n\ntype Frame struct {\n\tArgInts, ArgFloats int\n\tResInts, ResFloats int\n\n\tStackBytes int // Stack bytes without spill slots\n\tStackSpillBytes int // Stack bytes of spill slots\n\tStackTotal int // Stack bytes for complete argument frame.\n}\n\nfunc (a *ABIOptions) Assign(sig *types.Signature, sizes types.Sizes) Frame {\n\tptrSize := int(sizes.Sizeof(types.Typ[types.Uintptr]))\n\tf := frameBuilder{opts: a, sizes: sizes, ptrSize: ptrSize}\n\n\t// Arguments\n\tif r := sig.Recv(); r != nil {\n\t\tf.AddArg(r.Type(), true)\n\t}\n\tps := sig.Params()\n\tfor i := 0; i < ps.Len(); i++ {\n\t\tf.AddArg(ps.At(i).Type(), true)\n\t}\n\tf.ArgInts, f.ArgFloats = f.ints, f.floats\n\tf.StackBytes = align(f.StackBytes, ptrSize)\n\tf.StackSpillBytes = align(f.StackSpillBytes, ptrSize)\n\n\t// Results\n\tf.ints, f.floats = 0, 0\n\trs := sig.Results()\n\tfor i := 0; i < rs.Len(); i++ {\n\t\tf.AddArg(rs.At(i).Type(), false)\n\t}\n\tf.StackBytes = align(f.StackBytes, ptrSize)\n\tf.ResInts, f.ResFloats = f.ints, f.floats\n\n\tf.StackTotal = f.StackBytes + f.StackSpillBytes\n\n\treturn f.Frame\n}\n\nfunc (f *frameBuilder) AddArg(arg types.Type, needsSpill bool) {\n\tif f.opts.ABI0 {\n\t\tf.StackAssign(arg)\n\t\treturn\n\t}\n\n\tsi, sf, sb := f.ints, f.floats, f.StackBytes\n\tif f.RegAssign(arg, true) {\n\t\tif needsSpill {\n\t\t\t// Assign spill space.\n\t\t\tif f.opts.SpillRegs {\n\t\t\t\tf.StackSpillBytes += (f.ints-si)*f.ptrSize + (f.floats-sf)*8\n\t\t\t} else {\n\t\t\t\tf.StackSpillBytes = align(f.StackSpillBytes, int(f.sizes.Alignof(arg)))\n\t\t\t\tf.StackSpillBytes += int(f.sizes.Sizeof(arg))\n\t\t\t}\n\t\t}\n\t} else {\n\t\t// Stack-assign the whole thing.\n\t\tf.ints, f.floats, f.StackBytes = si, sf, sb\n\t\tf.StackAssign(arg)\n\t}\n}\n\nfunc (f *frameBuilder) RegAssign(arg types.Type, top bool) bool {\n\tswitch arg := arg.(type) {\n\tdefault:\n\t\tlog.Fatal(\"unknown type: \", arg)\n\t\treturn false\n\n\tcase *types.Named:\n\t\treturn f.RegAssign(arg.Underlying(), top)\n\n\tcase *types.Array:\n\t\tif f.opts.EmptyArray && arg.Len() == 0 {\n\t\t\t// Special-case empty arrays.\n\t\t\treturn true\n\t\t}\n\t\tif f.opts.OneArray && arg.Len() == 1 {\n\t\t\t// Special-case length-1 arrays.\n\t\t\treturn f.RegAssign(arg.Elem(), false)\n\t\t}\n\t\tif f.opts.SplitArrays {\n\t\t\t// Arrays can go on the stack without failing\n\t\t\t// the whole argument.\n\t\t\tf.StackAssign(arg)\n\t\t\treturn true\n\t\t} else {\n\t\t\t// Arrays fail the whole argument.\n\t\t\treturn false\n\t\t}\n\n\tcase *types.Struct:\n\t\tfor i := 0; i < arg.NumFields(); i++ {\n\t\t\tif f.opts.IgnoreBlank && arg.Field(i).Name() == \"_\" {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tif !f.RegAssign(arg.Field(i).Type(), false) {\n\t\t\t\treturn false\n\t\t\t}\n\t\t}\n\n\tcase *types.Basic:\n\t\tswitch arg.Kind() {\n\t\tcase types.Bool, types.Int, types.Int8, types.Int16, types.Int32, types.Int64,\n\t\t\ttypes.Uint, types.Uint8, types.Uint16, types.Uint32, types.Uint64, types.Uintptr:\n\t\t\t// TODO: 64-bit on 32-bit arch needs two regs.\n\t\t\tf.ints++\n\n\t\tcase types.Float32, types.Float64:\n\t\t\tf.floats++\n\n\t\tcase types.Complex64, types.Complex128:\n\t\t\tf.floats += 2\n\n\t\tcase types.String:\n\t\t\tf.ints += 2\n\n\t\tcase types.UnsafePointer:\n\t\t\tf.ints++\n\n\t\tdefault:\n\t\t\tlog.Fatal(\"unknown basic kind: \", arg)\n\t\t}\n\n\tcase *types.Chan, *types.Map, *types.Pointer, *types.Signature:\n\t\t// These are all represented as a single pointer word.\n\t\tf.ints++\n\n\tcase *types.Interface:\n\t\t// Two pointer words.\n\t\tf.ints += 2\n\n\tcase *types.Slice:\n\t\t// One pointer word plus two scalar words.\n\t\tf.ints += 3\n\t}\n\n\t// Check for out-of-registers.\n\treturn f.ints <= f.opts.IntRegs && f.floats <= f.opts.FloatRegs\n}\n\nfunc (f *frameBuilder) StackAssign(arg types.Type) {\n\tf.StackBytes = align(f.StackBytes, int(f.sizes.Alignof(arg)))\n\tf.StackBytes += int(f.sizes.Sizeof(arg))\n}\n\nfunc align(x, n int) int {\n\treturn (x + n - 1) &^ (n - 1)\n}\n\nfunc intQuantiles(xs []int, qs ...float64) []int {\n\tsort.Ints(xs)\n\tvs := make([]int, 0, len(qs))\n\tfor _, q := range qs {\n\t\ti := int(q * float64(len(xs)))\n\t\tif i < 0 {\n\t\t\ti = 0\n\t\t} else if i >= len(xs) {\n\t\t\ti = len(xs) - 1\n\t\t}\n\t\tvs = append(vs, xs[i])\n\t}\n\treturn vs\n}\n\nfunc floatQuantiles(xs []float64, qs ...float64) []float64 {\n\tsort.Float64s(xs)\n\tvs := make([]float64, 0, len(qs))\n\tfor _, q := range qs {\n\t\ti := int(q * float64(len(xs)))\n\t\tif i < 0 {\n\t\t\ti = 0\n\t\t} else if i >= len(xs) {\n\t\t\ti = len(xs)\n\t\t}\n\t\tvs = append(vs, xs[i])\n\t}\n\treturn vs\n}\n\nfunc printTable(w io.Writer, table [][]interface{}) {\n\ttype layoutNode struct {\n\t\tw int\n\t\tchildren []*layoutNode\n\t}\n\ttype cellKey struct {\n\t\trow int\n\t\tcol *layoutNode\n\t}\n\n\t// Stringify cells and construct layout\n\tcells := make(map[cellKey]string)\n\tlayout := &layoutNode{}\n\tvar walk func(ri int, row reflect.Value, node *layoutNode) int\n\twalk = func(ri int, row reflect.Value, node *layoutNode) int {\n\t\tif row.Kind() == reflect.Interface {\n\t\t\trow = row.Elem()\n\t\t}\n\n\t\tif row.Kind() != reflect.Slice {\n\t\t\t// This is a cell.\n\t\t\tval := fmt.Sprint(row)\n\t\t\tif len(val) > node.w {\n\t\t\t\tnode.w = len(val)\n\t\t\t}\n\t\t\tcells[cellKey{ri, node}] = val\n\t\t\treturn node.w\n\t\t}\n\n\t\t// This is a slice.\n\t\ttotalW := 0\n\t\trowLen := row.Len()\n\t\tfor vi := 0; vi < rowLen; vi++ {\n\t\t\tvar child *layoutNode\n\t\t\tif vi < len(node.children) {\n\t\t\t\tchild = node.children[vi]\n\t\t\t} else {\n\t\t\t\tchild = &layoutNode{}\n\t\t\t\tnode.children = append(node.children, child)\n\t\t\t}\n\t\t\ttotalW += walk(ri, row.Index(vi), child)\n\t\t}\n\t\t// Add in interior column spacing.\n\t\ttotalW += 3 * (rowLen - 1)\n\t\tif totalW > node.w {\n\t\t\tnode.w = totalW\n\t\t}\n\t\treturn node.w\n\t}\n\tfor ri, row := range table {\n\t\twalk(ri, reflect.ValueOf(row), layout)\n\t}\n\n\t// Print table\n\tvar printNode func(ri int, node *layoutNode, fillW int)\n\tprintNode = func(ri int, node *layoutNode, fillW int) {\n\t\tif val, ok := cells[cellKey{ri, node}]; ok {\n\t\t\tif fillW < node.w {\n\t\t\t\tfillW = node.w\n\t\t\t}\n\t\t\tfmt.Fprintf(w, \"| %*s \", fillW, val)\n\t\t\treturn\n\t\t}\n\n\t\tfor ci, child := range node.children {\n\t\t\tparentW := 0\n\t\t\tif ci == len(node.children)-1 {\n\t\t\t\tparentW = fillW\n\t\t\t} else {\n\t\t\t\tfillW -= child.w\n\t\t\t}\n\t\t\tprintNode(ri, child, parentW)\n\t\t}\n\t}\n\tfor ri := range table {\n\t\tprintNode(ri, layout, 0)\n\t\tfmt.Fprintf(w, \"|\\n\")\n\t}\n}\n" }, { "path": "abi/go.mod", "content": "module abi\n\ngo 1.15\n\nrequire golang.org/x/tools v0.0.0-20200815165600-90abf76919f3\n" }, { "path": "abi/go.sum", "content": "github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=\ngolang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=\ngolang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=\ngolang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=\ngolang.org/x/mod v0.3.0 h1:RM4zey1++hCTbCVQfnWeKs9/IEsaBLA8vTkd0WVtmH4=\ngolang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=\ngolang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=\ngolang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=\ngolang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=\ngolang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=\ngolang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=\ngolang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=\ngolang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=\ngolang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=\ngolang.org/x/tools v0.0.0-20200815165600-90abf76919f3 h1:0aScV/0rLmANzEYIhjCOi2pTvDyhZNduBUMD2q3iqs4=\ngolang.org/x/tools v0.0.0-20200815165600-90abf76919f3/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=\ngolang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=\ngolang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=\ngolang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=\ngolang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=\n" }, { "path": "bench/parse.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// Package bench reads and writes Go benchmarks results files.\n//\n// This format is specified at:\n// https://github.com/golang/proposal/blob/master/design/14313-benchmark-format.md\npackage bench\n\nimport (\n\t\"bufio\"\n\t\"io\"\n\t\"regexp\"\n\t\"strconv\"\n\t\"strings\"\n\t\"time\"\n\t\"unicode\"\n\t\"unicode/utf8\"\n)\n\n// Benchmark records the configuration and results of a single\n// benchmark run (a single line of a benchmark results file).\ntype Benchmark struct {\n\t// Name is the name of the benchmark, without the \"Benchmark\"\n\t// prefix and without the trailing GOMAXPROCS number.\n\tName string\n\n\t// Iterations is the number of times this benchmark executed.\n\tIterations int\n\n\t// Config is the set of configuration pairs for this\n\t// Benchmark. These can be specified in both configuration\n\t// blocks and in individual benchmark lines. If the benchmark\n\t// name is of the form \"BenchmarkX-N\", the N is stripped out\n\t// and stored as \"gomaxprocs\" here.\n\tConfig map[string]*Config\n\n\t// Result is the set of (unit, value) metrics for this\n\t// benchmark run.\n\tResult map[string]float64\n}\n\n// Config represents a single key/value configuration pair.\ntype Config struct {\n\t// Value is the parsed value of this configuration value.\n\tValue interface{}\n\n\t// RawValue is the value of this configuration value, exactly\n\t// as written in the original benchmark file.\n\tRawValue string\n\n\t// InBlock indicates that this configuration value was\n\t// specified in a configuration block line. Otherwise, it was\n\t// specified in the benchmark line.\n\tInBlock bool\n}\n\nvar configRe = regexp.MustCompile(`^(\\p{Ll}[^\\p{Lu}\\s\\x85\\xa0\\x{1680}\\x{2000}-\\x{200a}\\x{2028}\\x{2029}\\x{202f}\\x{205f}\\x{3000}]*):(?:[ \\t]+(.*))?$`)\n\n// Parse parses a standard Go benchmark results file from r. It\n// returns a *Benchmark for each benchmark result line in the file.\n// There may be many result lines for the same benchmark name and\n// configuration, indicating that the benchmark was run multiple\n// times.\n//\n// In the returned Benchmarks, RawValue is set, but Value is always\n// nil. Use ParseValues to convert raw values to structured types.\nfunc Parse(r io.Reader) ([]*Benchmark, error) {\n\tbenchmarks := []*Benchmark{}\n\tconfig := make(map[string]*Config)\n\n\tscanner := bufio.NewScanner(r)\n\tfor scanner.Scan() {\n\t\tline := scanner.Text()\n\n\t\tif line == \"testing: warning: no tests to run\" {\n\t\t\tcontinue\n\t\t}\n\n\t\t// Configuration lines.\n\t\tm := configRe.FindStringSubmatch(line)\n\t\tif m != nil {\n\t\t\tconfig[m[1]] = &Config{RawValue: m[2], InBlock: true}\n\t\t\tcontinue\n\t\t}\n\n\t\t// Benchmark lines.\n\t\tif strings.HasPrefix(line, \"Benchmark\") {\n\t\t\tb := parseBenchmark(line, config)\n\t\t\tif b != nil {\n\t\t\t\tbenchmarks = append(benchmarks, b)\n\t\t\t}\n\t\t}\n\t}\n\tif err := scanner.Err(); err != nil {\n\t\treturn nil, err\n\t}\n\n\treturn benchmarks, nil\n}\n\nfunc parseBenchmark(line string, gconfig map[string]*Config) *Benchmark {\n\t// TODO: Consider using scanner to avoid the slice allocation.\n\tf := strings.Fields(line)\n\tif len(f) < 4 {\n\t\treturn nil\n\t}\n\tif f[0] != \"Benchmark\" {\n\t\tnext, _ := utf8.DecodeRuneInString(f[0][len(\"Benchmark\"):])\n\t\tif !unicode.IsUpper(next) {\n\t\t\treturn nil\n\t\t}\n\t}\n\n\tb := &Benchmark{\n\t\tConfig: make(map[string]*Config),\n\t\tResult: make(map[string]float64),\n\t}\n\n\t// Copy global config.\n\tfor k, v := range gconfig {\n\t\tb.Config[k] = v\n\t}\n\n\t// Parse name and configuration.\n\tname := strings.TrimPrefix(f[0], \"Benchmark\")\n\tif strings.Contains(name, \"/\") {\n\t\tparts := strings.Split(name, \"/\")\n\t\tb.Name = parts[0]\n\t\tfor _, part := range parts[1:] {\n\t\t\tif i := strings.Index(part, \":\"); i >= 0 {\n\t\t\t\tk, v := part[:i], part[i+1:]\n\t\t\t\tb.Config[k] = &Config{RawValue: v}\n\t\t\t}\n\t\t}\n\t} else if i := strings.LastIndex(name, \"-\"); i >= 0 {\n\t\t_, err := strconv.Atoi(name[i+1:])\n\t\tif err == nil {\n\t\t\tb.Name = name[:i]\n\t\t\tb.Config[\"gomaxprocs\"] = &Config{RawValue: name[i+1:]}\n\t\t} else {\n\t\t\tb.Name = name\n\t\t}\n\t} else {\n\t\tb.Name = name\n\t}\n\tif b.Config[\"gomaxprocs\"] == nil {\n\t\tb.Config[\"gomaxprocs\"] = &Config{RawValue: \"1\"}\n\t}\n\n\t// Parse iterations.\n\tn, err := strconv.Atoi(f[1])\n\tif err != nil || n <= 0 {\n\t\treturn nil\n\t}\n\tb.Iterations = n\n\n\t// Parse results.\n\tfor i := 2; i+2 <= len(f); i += 2 {\n\t\tval, err := strconv.ParseFloat(f[i], 64)\n\t\tif err != nil {\n\t\t\tcontinue\n\t\t}\n\t\tb.Result[f[i+1]] = val\n\t}\n\n\treturn b\n}\n\n// ValueParser is a function that parses a string value into a\n// structured type or returns an error if the string cannot be parsed.\ntype ValueParser func(string) (interface{}, error)\n\n// DefaultValueParsers is the default sequence of value parsers used\n// by ParseValues if no parsers are specified.\nvar DefaultValueParsers = []ValueParser{\n\tfunc(s string) (interface{}, error) { return strconv.Atoi(s) },\n\tfunc(s string) (interface{}, error) { return strconv.ParseFloat(s, 64) },\n\tfunc(s string) (interface{}, error) { return time.ParseDuration(s) },\n}\n\n// ParseValues parses the raw configuration values in benchmarks into\n// structured types using best-effort pattern-based parsing.\n//\n// If all of the raw values for a given configuration key can be\n// parsed by one of the valueParsers, ParseValues sets the parsed\n// values to the results of that ValueParser. If multiple ValueParsers\n// can parse all of the raw values, it uses the earliest such parser\n// in the valueParsers list.\n//\n// If valueParsers is nil, it uses DefaultValueParsers.\nfunc ParseValues(benchmarks []*Benchmark, valueParsers []ValueParser) {\n\tif valueParsers == nil {\n\t\tvalueParsers = DefaultValueParsers\n\t}\n\n\t// Collect all configuration keys.\n\tkeys := map[string]bool{}\n\tfor _, b := range benchmarks {\n\t\tfor k := range b.Config {\n\t\t\tkeys[k] = true\n\t\t}\n\t}\n\n\t// For each configuration key, try value parsers in priority order.\n\tfor key := range keys {\n\t\tgood := false\n\ttryParsers:\n\t\tfor _, vp := range valueParsers {\n\t\t\t// Clear all values. This way we can detect\n\t\t\t// aliasing and not parse the same value\n\t\t\t// multiple times.\n\t\t\tfor _, b := range benchmarks {\n\t\t\t\tc, ok := b.Config[key]\n\t\t\t\tif ok {\n\t\t\t\t\tc.Value = nil\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tgood = true\n\t\ttryValues:\n\t\t\tfor _, b := range benchmarks {\n\t\t\t\tc, ok := b.Config[key]\n\t\t\t\tif !ok || c.Value != nil {\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\n\t\t\t\tres, err := vp(c.RawValue)\n\t\t\t\tif err != nil {\n\t\t\t\t\t// Parse error. Fail this parser.\n\t\t\t\t\tgood = false\n\t\t\t\t\tbreak tryValues\n\t\t\t\t}\n\t\t\t\tc.Value = res\n\t\t\t}\n\n\t\t\tif good {\n\t\t\t\t// This ValueParser converted all of\n\t\t\t\t// the values.\n\t\t\t\tbreak tryParsers\n\t\t\t}\n\t\t}\n\t\tif !good {\n\t\t\t// All of the value parsers failed. Fall back\n\t\t\t// to strings.\n\t\t\tfor _, b := range benchmarks {\n\t\t\t\tc, ok := b.Config[key]\n\t\t\t\tif ok {\n\t\t\t\t\tc.Value = nil\n\t\t\t\t}\n\t\t\t}\n\t\t\tfor _, b := range benchmarks {\n\t\t\t\tc, ok := b.Config[key]\n\t\t\t\tif ok && c.Value == nil {\n\t\t\t\t\tc.Value = c.RawValue\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n" }, { "path": "bench/parse_test.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage bench\n\nimport (\n\t\"bytes\"\n\t\"reflect\"\n\t\"testing\"\n)\n\nfunc TestParse(t *testing.T) {\n\tfor _, test := range []struct {\n\t\tinput string\n\t\twant []*Benchmark\n\t}{\n\t\t// Test basic line.\n\t\t{`\nBenchmarkX\t1\t2 ns/op 3 MB/s`,\n\t\t\t[]*Benchmark{\n\t\t\t\t{\"X\", 1, map[string]*Config{}, map[string]float64{\"ns/op\": 2, \"MB/s\": 3}},\n\t\t\t},\n\t\t},\n\n\t\t// Test short name.\n\t\t{`\nBenchmark\t1\t2 ns/op`,\n\t\t\t[]*Benchmark{\n\t\t\t\t{\"\", 1, map[string]*Config{}, map[string]float64{\"ns/op\": 2}},\n\t\t\t},\n\t\t},\n\n\t\t// Test bad names.\n\t\t{`\nBenchmarkx\t1\t2 ns/op\nbenchmarkx\t1\t2 ns/op\nbenchmarkX\t1\t2 ns/op`,\n\t\t\t[]*Benchmark{},\n\t\t},\n\n\t\t// Test short lines.\n\t\t{`\nBenchmarkX\nBenchmarkX\t1\nBenchmarkX\t1\t2`,\n\t\t\t[]*Benchmark{},\n\t\t},\n\n\t\t// Test -N.\n\t\t{`\nBenchmarkX-4\t1\t2 ns/op`,\n\t\t\t[]*Benchmark{\n\t\t\t\t{\"X\", 1, map[string]*Config{\n\t\t\t\t\t\"gomaxprocs\": &Config{\"gomaxprocs\", \"4\", \"4\", false},\n\t\t\t\t}, map[string]float64{\"ns/op\": 2}},\n\t\t\t},\n\t\t},\n\n\t\t// Test per-benchmark config.\n\t\t{`\nBenchmarkX/a:20/b:abc\t1\t2 ns/op\nBenchmarkY/c:123\t2\t4 ns/op`,\n\t\t\t[]*Benchmark{\n\t\t\t\t{\"X\", 1, map[string]*Config{\n\t\t\t\t\t\"a\": &Config{\"a\", \"20\", \"20\", false},\n\t\t\t\t\t\"b\": &Config{\"b\", \"abc\", \"abc\", false},\n\t\t\t\t}, map[string]float64{\"ns/op\": 2}},\n\t\t\t\t{\"Y\", 2, map[string]*Config{\n\t\t\t\t\t\"c\": &Config{\"c\", \"123\", \"123\", false},\n\t\t\t\t}, map[string]float64{\"ns/op\": 4}},\n\t\t\t},\n\t\t},\n\n\t\t// Test block config.\n\t\t{`\ncommit: 123456\ndate: Jan 1\ncolon:colon: 42\nblank:\n#not-config: x\nspa ce: x\nfunny space: x\nNot-config: x\nBenchmarkX\t1\t2 ns/op`,\n\t\t\t[]*Benchmark{\n\t\t\t\t{\"X\", 1, map[string]*Config{\n\t\t\t\t\t\"commit\": &Config{\"commit\", \"123456\", \"123456\", true},\n\t\t\t\t\t\"date\": &Config{\"date\", \"Jan 1\", \"Jan 1\", true},\n\t\t\t\t\t\"colon:colon\": &Config{\"colon:colon\", \"42\", \"42\", true},\n\t\t\t\t\t\"blank\": &Config{\"blank\", \"\", \"\", true},\n\t\t\t\t}, map[string]float64{\"ns/op\": 2}},\n\t\t\t},\n\t\t},\n\n\t\t// Test benchmark config overriding block config.\n\t\t{`\ncommit: 123456\ndate: Jan 1\nBenchmarkX/commit:abcdef\t1\t2 ns/op`,\n\t\t\t[]*Benchmark{\n\t\t\t\t{\"X\", 1, map[string]*Config{\n\t\t\t\t\t\"commit\": &Config{\"commit\", \"abcdef\", \"abcdef\", false},\n\t\t\t\t\t\"date\": &Config{\"date\", \"Jan 1\", \"Jan 1\", true},\n\t\t\t\t}, map[string]float64{\"ns/op\": 2}},\n\t\t\t},\n\t\t},\n\n\t\t// Test block config overriding block config.\n\t\t{`\ncommit: 123456\ncommit: abcdef\ndate: Jan 1\nBenchmarkX\t1\t2 ns/op`,\n\t\t\t[]*Benchmark{\n\t\t\t\t{\"X\", 1, map[string]*Config{\n\t\t\t\t\t\"commit\": &Config{\"commit\", \"abcdef\", \"abcdef\", true},\n\t\t\t\t\t\"date\": &Config{\"date\", \"Jan 1\", \"Jan 1\", true},\n\t\t\t\t}, map[string]float64{\"ns/op\": 2}},\n\t\t\t},\n\t\t},\n\t} {\n\t\tr := bytes.NewBufferString(test.input)\n\t\tbs, err := Parse(r)\n\t\tif err != nil {\n\t\t\tt.Error(\"unexpected Parse error\", err)\n\t\t\tcontinue\n\t\t}\n\t\tif !reflect.DeepEqual(bs, test.want) {\n\t\t\tt.Log(\"want:\")\n\t\t\tfor _, b := range test.want {\n\t\t\t\tt.Logf(\"%#v\", b)\n\t\t\t}\n\t\t\tt.Log(\"got:\")\n\t\t\tfor _, b := range bs {\n\t\t\t\tt.Logf(\"%#v\", b)\n\t\t\t}\n\t\t\tt.Fail()\n\t\t}\n\t}\n}\n" }, { "path": "bench/print.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage bench\n\nimport (\n\t\"fmt\"\n\t\"io\"\n\t\"os\"\n\t\"sort\"\n\t\"strings\"\n)\n\nfunc Print(bs []*Benchmark) error {\n\treturn Fprint(os.Stdout, bs)\n}\n\nfunc Fprint(w io.Writer, bs []*Benchmark) error {\n\ttype kv struct {\n\t\tk, v string\n\t}\n\ttype block struct {\n\t\tconfig []kv\n\t\tbs []*Benchmark\n\t}\n\n\tconfigKeys := func(b *Benchmark, inBlock bool) []string {\n\t\tvar keys []string\n\t\tfor k, config := range b.Config {\n\t\t\tif config.InBlock == inBlock {\n\t\t\t\tkeys = append(keys, k)\n\t\t\t}\n\t\t}\n\t\tsort.Strings(keys)\n\t\treturn keys\n\t}\n\n\t// Split bs into configuration blocks.\n\tblocks := []block{}\n\tlastConfig := map[string]string{}\n\tfor _, b := range bs {\n\t\t// Find changed block configuration.\n\t\tvar changed []kv\n\t\tfor _, k := range configKeys(b, true) {\n\t\t\tconfig := b.Config[k]\n\t\t\tlc, ok := lastConfig[k]\n\t\t\tif ok && lc == config.RawValue {\n\t\t\t\tcontinue\n\t\t\t}\n\n\t\t\tchanged = append(changed, kv{k, config.RawValue})\n\t\t\tlastConfig[k] = config.RawValue\n\t\t}\n\n\t\tif len(blocks) == 0 || changed != nil {\n\t\t\t// Start a new configuration block.\n\t\t\tblocks = append(blocks, block{changed, nil})\n\t\t}\n\n\t\t// Add benchmark to latest block.\n\t\tbbs := &blocks[len(blocks)-1].bs\n\t\t*bbs = append(*bbs, b)\n\t}\n\n\t// Format each configuration block.\n\tfor i, block := range blocks {\n\t\t// Print configuration values.\n\t\tif i > 0 {\n\t\t\tif _, err := fmt.Fprint(w, \"\\n\"); err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\t\t}\n\t\tfor _, kv := range block.config {\n\t\t\t// TODO: Syntax check.\n\t\t\tif _, err := fmt.Fprintf(w, \"%s: %s\\n\", kv.k, kv.v); err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\t\t}\n\t\tif len(block.config) > 0 {\n\t\t\tif _, err := fmt.Fprint(w, \"\\n\"); err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\t\t}\n\n\t\t// Construct benchmark lines.\n\t\tlines := make([][]string, len(block.bs))\n\t\tfor _, b := range block.bs {\n\t\t\t// Construct benchmark name.\n\t\t\tname := []string{\"Benchmark\" + b.Name}\n\t\t\tgomaxprocs, haveGMP := \"\", false\n\t\t\tfor _, k := range configKeys(b, false) {\n\t\t\t\tconfig := b.Config[k]\n\t\t\t\tif k == \"gomaxprocs\" {\n\t\t\t\t\tgomaxprocs = config.RawValue\n\t\t\t\t\thaveGMP = true\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\t\t\t\t// TODO: Syntax check.\n\t\t\t\tname = append(name, fmt.Sprintf(\"%s:%s\", k, config.RawValue))\n\t\t\t}\n\t\t\tif haveGMP && gomaxprocs != \"1\" {\n\t\t\t\tif len(name) == 1 {\n\t\t\t\t\t// Use short form.\n\t\t\t\t\tname[0] = fmt.Sprintf(\"%s-%s\", name[0], gomaxprocs)\n\t\t\t\t} else {\n\t\t\t\t\tname = append(name, fmt.Sprintf(\"gomaxprocs:%s\", gomaxprocs))\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Construct results.\n\t\t\tline := []string{\n\t\t\t\tstrings.Join(name, \"/\"),\n\t\t\t\tfmt.Sprint(b.Iterations),\n\t\t\t}\n\t\t\tresultKeys := []string{}\n\t\t\tfor k := range b.Result {\n\t\t\t\tresultKeys = append(resultKeys, k)\n\t\t\t}\n\t\t\tsort.Sort(resultKeySorter(resultKeys))\n\t\t\tfor _, k := range resultKeys {\n\t\t\t\tresult := b.Result[k]\n\t\t\t\t// TODO: Syntax check.\n\t\t\t\tline = append(line, fmt.Sprint(result), k)\n\t\t\t}\n\n\t\t\tlines = append(lines, line)\n\t\t}\n\n\t\t// Compute column widths.\n\t\twidths := make([]int, 0)\n\t\tfor _, line := range lines {\n\t\t\tfor i, elt := range line {\n\t\t\t\tif i >= len(widths) {\n\t\t\t\t\twidths = append(widths, len(elt))\n\t\t\t\t} else if len(elt) > widths[i] {\n\t\t\t\t\twidths[i] = len(elt)\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Print lines.\n\t\tfor _, line := range lines {\n\t\t\tfor i, elt := range line {\n\t\t\t\tvar err error\n\t\t\t\tp := widths[i]\n\t\t\t\tif i == 1 || i >= 2 && i%2 == 0 {\n\t\t\t\t\t// Right align.\n\t\t\t\t\t_, err = fmt.Fprintf(w, \"%*s \", p, elt)\n\t\t\t\t} else if i < len(line)-1 {\n\t\t\t\t\t// Left align and pad.\n\t\t\t\t\t_, err = fmt.Fprintf(w, \"%-*s \", p, elt)\n\t\t\t\t} else {\n\t\t\t\t\t// Left align, no pad, EOL.\n\t\t\t\t\t_, err = fmt.Fprintf(w, \"%s\\n\", elt)\n\t\t\t\t}\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn err\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn nil\n}\n\nvar fixedKeys = map[string]int{\n\t\"ns/op\": -2,\n\t\"MB/s\": -1,\n}\n\ntype resultKeySorter []string\n\nfunc (s resultKeySorter) Len() int {\n\treturn len(s)\n}\n\nfunc (s resultKeySorter) Less(i, j int) bool {\n\tif fixedKeys[s[i]] != fixedKeys[s[j]] {\n\t\treturn fixedKeys[s[i]] < fixedKeys[s[j]]\n\t}\n\n\treturn s[i] < s[j]\n}\n\nfunc (s resultKeySorter) Swap(i, j int) {\n\ts[i], s[j] = s[j], s[i]\n}\n" }, { "path": "benchcmd/main.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// Command benchcmd times a shell command using Go benchmark format.\npackage main\n\nimport (\n\t\"flag\"\n\t\"fmt\"\n\t\"os\"\n\t\"os/exec\"\n\t\"time\"\n)\n\nfunc main() {\n\tflag.Usage = func() {\n\t\tfmt.Fprintf(os.Stderr, \"Usage: %s [-n iters] benchname cmd...\\n\", os.Args[0])\n\t\tflag.PrintDefaults()\n\t}\n\tn := flag.Int(\"n\", 5, \"iterations\")\n\tflag.Parse()\n\tif flag.NArg() < 2 {\n\t\tflag.Usage()\n\t\tos.Exit(2)\n\t}\n\tbenchname := flag.Arg(0)\n\targs := flag.Args()[1:]\n\n\tfor i := 0; i < *n; i++ {\n\t\tcmd := exec.Command(args[0], args[1:]...)\n\t\tcmd.Stdout = os.Stdout\n\t\tcmd.Stderr = os.Stderr\n\t\tbefore := time.Now()\n\t\tif err := cmd.Run(); err != nil {\n\t\t\tfmt.Println(err)\n\t\t\tos.Exit(1)\n\t\t}\n\t\tafter := time.Now()\n\t\tfmt.Printf(\"Benchmark%s\\t\", benchname)\n\t\tfmt.Printf(\"%d\\t%d ns/op\", 1, after.Sub(before))\n\t\tfmt.Printf(\"\\t%d user-ns/op\\t%d sys-ns/op\", cmd.ProcessState.UserTime(), cmd.ProcessState.SystemTime())\n\t\tif maxrss, ok := getMaxRSS(cmd.ProcessState); ok {\n\t\t\tfmt.Printf(\"\\t%d peak-RSS-bytes\", maxrss)\n\t\t}\n\t\tfmt.Printf(\"\\n\")\n\t}\n}\n" }, { "path": "benchcmd/rss_nounix.go", "content": "// Copyright 2025 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build !unix\n\npackage main\n\nimport \"os\"\n\nfunc getMaxRSS(ps *os.ProcessState) (bytes uint64, ok bool) {\n\treturn 0, false\n}\n" }, { "path": "benchcmd/rss_unix.go", "content": "// Copyright 2025 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build unix\n\npackage main\n\nimport (\n\t\"os\"\n\t\"runtime\"\n\t\"syscall\"\n)\n\nfunc getMaxRSS(ps *os.ProcessState) (bytes uint64, ok bool) {\n\tru, ok := ps.SysUsage().(*syscall.Rusage)\n\tif !ok {\n\t\treturn 0, false\n\t}\n\n\tvar rssToBytes uint64\n\tswitch runtime.GOOS {\n\tdefault:\n\t\treturn 0, false\n\tcase \"aix\", \"android\", \"dragonfly\", \"freebsd\", \"linux\", \"netbsd\", \"openbsd\":\n\t\trssToBytes = 1 << 10\n\tcase \"darwin\", \"ios\":\n\t\trssToBytes = 1\n\tcase \"illumos\", \"solaris\":\n\t\trssToBytes = uint64(syscall.Getpagesize())\n\t}\n\treturn uint64(ru.Maxrss) * rssToBytes, true\n}\n" }, { "path": "benchmany/benchmany.go", "content": "// Copyright 2015 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// Benchmany runs Go benchmarks across many git commits.\n//\n// Usage:\n//\n// benchmany [-C git-dir] [-n iterations] ...\n//\n// benchmany runs the benchmarks in the current directory \n// times for each commit in and writes the benchmark\n// results to bench.log. Benchmarks may be Go testing framework\n// benchmarks or benchmarks from golang.org/x/benchmarks.\n//\n// ... can be either a list of individual commits or\n// a revision range. For the spelling of a revision range, see\n// \"SPECIFYING RANGES\" in gitrevisions(7). For exact details, see the\n// --no-walk option to git-rev-list(1).\n//\n// Benchmany will check out each revision in git-dir. The current\n// directory may or may not be in the same git repository as git-dir.\n// If git-dir refers to a Go installation, benchmany will run\n// make.bash at each revision; otherwise, it assumes go test can\n// rebuild the necessary dependencies. Benchmany also supports using\n// gover (https://godoc.org/github.com/aclements/go-misc/gover) to\n// save and reuse Go build trees. This is useful for saving time\n// across multiple benchmark runs and for benchmarks that depend on\n// the Go tree itself (such as compiler benchmarks).\n//\n// Benchmany supports multiple ways of prioritizing the order in which\n// individual iterations are run. By default, it runs in \"sequential\"\n// mode: it runs the first iteration of all benchmarks, then the\n// second, and so forth. It also supports a \"spread\" mode designed to\n// quickly get coverage for large sets of revisions. This mode\n// randomizes the order to run iterations in, but biases this order\n// toward covering an evenly distributed set of revisions early and\n// finishing all of the iterations of the revisions it has started on\n// before moving on to new revisions. This way, if benchmany is\n// interrupted, the revisions benchmarked cover the space more-or-less\n// evenly. Finally, it supports a \"metric\" mode, which zeroes in on\n// changes in a benchmark metric by selecting the commit half way\n// between the pair of commits with the biggest difference in the\n// metric. This is like \"git bisect\", but for performance.\n//\n// Benchmany is safe to interrupt. If it is restarted, it will parse\n// the benchmark log files to recover its state.\npackage main\n\nimport (\n\t\"flag\"\n\t\"fmt\"\n\t\"os\"\n\t\"os/exec\"\n\t\"strings\"\n)\n\nvar gitDir string\nvar dryRun bool\n\n// maxFails is the maximum number of benchmark run failures to\n// tolerate for a commit before giving up on trying to benchmark that\n// commit. Build failures always disqualify a commit.\nconst maxFails = 5\n\nfunc main() {\n\tflag.Parse()\n\tdoRun()\n}\n\n// git runs git subcommand subcmd and returns its stdout. If git\n// fails, it prints the failure and exits.\nfunc git(subcmd string, args ...string) string {\n\tgitargs := []string{}\n\tif gitDir != \"\" {\n\t\tgitargs = append(gitargs, \"-C\", gitDir)\n\t}\n\tgitargs = append(gitargs, subcmd)\n\tgitargs = append(gitargs, args...)\n\tcmd := exec.Command(\"git\", gitargs...)\n\tcmd.Stderr = os.Stderr\n\tif dryRun {\n\t\tdryPrint(cmd)\n\t\tif !(subcmd == \"rev-parse\" || subcmd == \"rev-list\" || subcmd == \"show\") {\n\t\t\treturn \"\"\n\t\t}\n\t}\n\tout, err := cmd.Output()\n\tif err != nil {\n\t\tfmt.Fprintf(os.Stderr, \"git %s failed: %s\\n\", shellEscapeList(gitargs), err)\n\t\tos.Exit(1)\n\t}\n\treturn string(out)\n}\n\nfunc dryPrint(cmd *exec.Cmd) {\n\tout := shellEscape(cmd.Path)\n\tfor _, a := range cmd.Args[1:] {\n\t\tout += \" \" + shellEscape(a)\n\t}\n\tif cmd.Dir != \"\" {\n\t\tout = fmt.Sprintf(\"(cd %s && %s)\", shellEscape(cmd.Dir), out)\n\t}\n\tfmt.Fprintln(os.Stderr, out)\n}\n\nfunc shellEscape(x string) string {\n\tif len(x) == 0 {\n\t\treturn \"''\"\n\t}\n\tfor _, r := range x {\n\t\tif 'a' <= r && r <= 'z' || 'A' <= r && r <= 'Z' || '0' <= r && r <= '9' || strings.ContainsRune(\"@%_-+:,./\", r) {\n\t\t\tcontinue\n\t\t}\n\t\t// Unsafe character.\n\t\treturn \"'\" + strings.Replace(x, \"'\", \"'\\\"'\\\"'\", -1) + \"'\"\n\t}\n\treturn x\n}\n\nfunc shellEscapeList(xs []string) string {\n\tout := make([]string, len(xs))\n\tfor i, x := range xs {\n\t\tout[i] = shellEscape(x)\n\t}\n\treturn strings.Join(out, \" \")\n}\n\nfunc exists(path string) bool {\n\t_, err := os.Stat(path)\n\treturn !os.IsNotExist(err)\n}\n\nfunc trimNL(s string) string {\n\treturn strings.TrimRight(s, \"\\n\")\n}\n\n// indent returns s with each line indented by four spaces. If s is\n// non-empty, the returned string is guaranteed to end in a \"\\n\".\nfunc indent(s string) string {\n\tif len(s) == 0 {\n\t\treturn s\n\t}\n\tif strings.HasSuffix(s, \"\\n\") {\n\t\ts = s[:len(s)-1]\n\t}\n\treturn \" \" + strings.Replace(s, \"\\n\", \"\\n \", -1) + \"\\n\"\n}\n\n// lines splits s in to lines. It omits a final blank line, if any.\nfunc lines(s string) []string {\n\tl := strings.Split(s, \"\\n\")\n\tif len(l) > 0 && l[len(l)-1] == \"\" {\n\t\tl = l[:len(l)-1]\n\t}\n\treturn l\n}\n" }, { "path": "benchmany/commits.go", "content": "// Copyright 2015 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage main\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n\t\"fmt\"\n\t\"io\"\n\t\"io/ioutil\"\n\t\"log\"\n\t\"os\"\n\t\"os/user\"\n\t\"path/filepath\"\n\t\"regexp\"\n\t\"strings\"\n\t\"time\"\n)\n\ntype commitInfo struct {\n\thash string\n\tcommitDate time.Time\n\tgover bool\n\tlogPath string\n\tcount, fails int\n\tbuildFailed bool\n}\n\n// getCommits returns the commit info for all of the revisions in the\n// given git revision range, where the revision range is spelled as\n// documented in gitrevisions(7). Commits are returned in reverse\n// chronological order, most recent commit first (the same as\n// git-rev-list(1)).\nfunc getCommits(revRange []string, logPath string) []*commitInfo {\n\t// Get commit sequence.\n\targs := append(append([]string{\"--no-walk\"}, revRange...), \"--\")\n\thashes := lines(git(\"rev-list\", args...))\n\tcommits := make([]*commitInfo, len(hashes))\n\tcommitMap := make(map[string]*commitInfo)\n\tfor i, hash := range hashes {\n\t\tcommits[i] = &commitInfo{\n\t\t\thash: hash,\n\t\t\tlogPath: logPath,\n\t\t}\n\t\tcommitMap[hash] = commits[i]\n\t}\n\n\t// Get commit dates.\n\t//\n\t// TODO: This can produce a huge command line.\n\targs = append([]string{\"-s\", \"--format=format:%cI\"}, hashes...)\n\tdates := lines(git(\"show\", args...))\n\tfor i := range commits {\n\t\td, err := time.Parse(time.RFC3339, dates[i])\n\t\tif err != nil {\n\t\t\tlog.Fatalf(\"cannot parse commit date: %v\", err)\n\t\t}\n\t\tcommits[i].commitDate = d\n\t}\n\n\t// Get gover-cached builds. It's okay if this fails.\n\tif fis, err := ioutil.ReadDir(goverDir()); err == nil {\n\t\tfor _, fi := range fis {\n\t\t\tif ci := commitMap[fi.Name()]; ci != nil && fi.IsDir() {\n\t\t\t\tci.gover = true\n\t\t\t}\n\t\t}\n\t}\n\n\t// Load current benchmark state.\n\tlogf, err := os.Open(logPath)\n\tif err != nil {\n\t\tif !os.IsNotExist(err) {\n\t\t\tlog.Fatalf(\"opening %s: %v\", logPath, err)\n\t\t}\n\t} else {\n\t\tdefer logf.Close()\n\t\tparseLog(commitMap, logf)\n\t}\n\n\treturn commits\n}\n\n// goverDir returns the directory containing gover-cached builds.\nfunc goverDir() string {\n\tcache := os.Getenv(\"XDG_CACHE_HOME\")\n\tif cache == \"\" {\n\t\thome := os.Getenv(\"HOME\")\n\t\tif home == \"\" {\n\t\t\tu, err := user.Current()\n\t\t\tif err != nil {\n\t\t\t\thome = u.HomeDir\n\t\t\t}\n\t\t}\n\t\tcache = filepath.Join(home, \".cache\")\n\t}\n\treturn filepath.Join(cache, \"gover\")\n}\n\n// parseLog parses benchmark runs and failures from r and updates\n// commits in commitMap.\nfunc parseLog(commitMap map[string]*commitInfo, r io.Reader) {\n\tscanner := bufio.NewScanner(r)\n\tfor scanner.Scan() {\n\t\tb := scanner.Bytes()\n\t\tswitch {\n\t\tcase bytes.HasPrefix(b, []byte(\"commit: \")):\n\t\t\thash := scanner.Text()[len(\"commit: \"):]\n\t\t\tif ci := commitMap[hash]; ci != nil {\n\t\t\t\tci.count++\n\t\t\t}\n\n\t\tcase bytes.HasPrefix(b, []byte(\"# FAILED at \")):\n\t\t\thash := scanner.Text()[len(\"# FAILED at \"):]\n\t\t\tif ci := commitMap[hash]; ci != nil {\n\t\t\t\tci.fails++\n\t\t\t}\n\n\t\tcase bytes.HasPrefix(b, []byte(\"# BUILD FAILED at \")):\n\t\t\thash := scanner.Text()[len(\"# BUILD FAILED at \"):]\n\t\t\tif ci := commitMap[hash]; ci != nil {\n\t\t\t\tci.buildFailed = true\n\t\t\t}\n\t\t}\n\t}\n\tif err := scanner.Err(); err != nil {\n\t\tlog.Fatal(\"parsing benchmark log: \", err)\n\t}\n}\n\n// binPath returns the file name of the binary for this commit.\nfunc (c *commitInfo) binPath() string {\n\t// TODO: This assumes the short commit hash is unique.\n\treturn fmt.Sprintf(\"bench.%s\", c.hash[:7])\n}\n\n// failed returns whether commit c has failed and should not be run\n// any more.\nfunc (c *commitInfo) failed() bool {\n\treturn c.buildFailed || c.fails >= maxFails\n}\n\n// runnable returns whether commit c needs to be benchmarked at least\n// one more time.\nfunc (c *commitInfo) runnable() bool {\n\treturn !c.buildFailed && c.fails < maxFails && c.count < run.iterations\n}\n\n// partial returns true if this commit is both runnable and already\n// has some runs.\nfunc (c *commitInfo) partial() bool {\n\treturn c.count > 0 && c.runnable()\n}\n\nvar commitRe = regexp.MustCompile(`^commit: |^# FAILED|^# BUILD FAILED`)\n\n// cleanLog escapes lines in l that may confuse the log parser and\n// makes sure l is newline terminated.\nfunc cleanLog(l string) string {\n\tl = commitRe.ReplaceAllString(l, \"# $0\")\n\tif !strings.HasSuffix(l, \"\\n\") {\n\t\tl += \"\\n\"\n\t}\n\treturn l\n}\n\n// logRun updates c with a successful run.\nfunc (c *commitInfo) logRun(out string) {\n\tvar log bytes.Buffer\n\tfmt.Fprintf(&log, \"commit: %s\\n\", c.hash)\n\tfmt.Fprintf(&log, \"commit-time: %s\\n\", c.commitDate.UTC().Format(time.RFC3339))\n\tfmt.Fprintf(&log, \"\\n%s\\n\", cleanLog(out))\n\tc.writeLog(log.String())\n\tc.count++\n}\n\n// logFailed updates c with a failed run. If buildFailed is true, this\n// is considered a permanent failure and buildFailed is set.\nfunc (c *commitInfo) logFailed(buildFailed bool, out string) {\n\ttyp := \"FAILED\"\n\tif buildFailed {\n\t\ttyp = \"BUILD FAILED\"\n\t}\n\tc.writeLog(fmt.Sprintf(\"# %s at %s\\n# %s\\n\", typ, c.hash, strings.Replace(cleanLog(out), \"\\n\", \"\\n# \", -1)))\n\tif buildFailed {\n\t\tc.buildFailed = true\n\t} else {\n\t\tc.fails++\n\t}\n}\n\n// writeLog appends msg to c's log file. The caller is responsible for\n// properly formatting it.\nfunc (c *commitInfo) writeLog(msg string) {\n\tlogFile, err := os.OpenFile(c.logPath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)\n\tif err != nil {\n\t\tlog.Fatalf(\"opening %s: %v\", c.logPath, err)\n\t}\n\tif _, err := logFile.WriteString(msg); err != nil {\n\t\tlog.Fatalf(\"writing to %s: %v\", c.logPath, err)\n\t}\n\tif err := logFile.Close(); err != nil {\n\t\tlog.Fatalf(\"closing %s: %v\", c.logPath, err)\n\t}\n}\n" }, { "path": "benchmany/readlog.go", "content": "// Copyright 2015 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage main\n\nimport (\n\t\"io/ioutil\"\n\t\"log\"\n\t\"strconv\"\n\t\"strings\"\n\n\t\"github.com/aclements/go-moremath/stats\"\n)\n\n// ComputeStats updates the derived statistics in s from the raw\n// samples in s.Values.\nfunc (stat *Benchstat) ComputeStats() {\n\tstat.Mean = stats.Mean(stat.Values)\n}\n\n// A Benchstat is the metrics along one axis (e.g., ns/op or MB/s)\n// for all runs of a specific benchmark.\ntype Benchstat struct {\n\tUnit string\n\tValues []float64 // metrics\n\tMean float64 // mean of Values\n}\n\n// A BenchKey identifies one metric (e.g., \"ns/op\", \"B/op\") from one\n// benchmark (function name sans \"Benchmark\" prefix) in one\n// configuration (input file name).\ntype BenchKey struct {\n\tConfig, Benchmark, Unit string\n}\n\ntype Collection struct {\n\tStats map[BenchKey]*Benchstat\n\n\t// Keys gives all keys of Stats in the order added.\n\tKeys []BenchKey\n\n\t// Configs, Benchmarks, and Units give the set of configs,\n\t// benchmarks, and units from the keys in Stats in an order\n\t// meant to match the order the benchmarks were read in.\n\tConfigs, Benchmarks, Units []string\n\n\t// ConfigSet, BenchmarkSet, and UnitSet are set\n\t// representations of Configs, Benchmarks, and Units.\n\tConfigSet, BenchmarkSet, UnitSet map[string]bool\n}\n\nfunc (c *Collection) AddStat(key BenchKey) *Benchstat {\n\tif stat, ok := c.Stats[key]; ok {\n\t\treturn stat\n\t}\n\n\tc.addKey(key)\n\tstat := &Benchstat{Unit: key.Unit}\n\tc.Stats[key] = stat\n\treturn stat\n}\n\nfunc (c *Collection) addKey(key BenchKey) {\n\taddString := func(strings *[]string, set map[string]bool, add string) {\n\t\tif set[add] {\n\t\t\treturn\n\t\t}\n\t\t*strings = append(*strings, add)\n\t\tset[add] = true\n\t}\n\tc.Keys = append(c.Keys, key)\n\taddString(&c.Configs, c.ConfigSet, key.Config)\n\taddString(&c.Benchmarks, c.BenchmarkSet, key.Benchmark)\n\taddString(&c.Units, c.UnitSet, key.Unit)\n}\n\nfunc (c *Collection) Filter(key BenchKey) *Collection {\n\tc2 := NewCollection()\n\tfor _, k := range c.Keys {\n\t\tif (key.Config == \"\" || key.Config == k.Config) &&\n\t\t\t(key.Benchmark == \"\" || key.Benchmark == k.Benchmark) &&\n\t\t\t(key.Unit == \"\" || key.Unit == k.Unit) {\n\t\t\tc2.addKey(k)\n\t\t\tc2.Stats[k] = c.Stats[k]\n\t\t}\n\t}\n\treturn c2\n}\n\nfunc NewCollection() *Collection {\n\treturn &Collection{\n\t\tStats: make(map[BenchKey]*Benchstat),\n\t\tConfigSet: make(map[string]bool),\n\t\tBenchmarkSet: make(map[string]bool),\n\t\tUnitSet: make(map[string]bool),\n\t}\n}\n\n// readFiles reads a set of benchmark files as a Collection.\nfunc readFiles(files ...string) *Collection {\n\tc := NewCollection()\n\tfor _, file := range files {\n\t\treadFile(file, c)\n\t}\n\treturn c\n}\n\nvar unitOfXMetric = map[string]string{\n\t\"time\": \"ns/op\",\n\t\"allocated\": \"allocated bytes/op\", // ΔMemStats.TotalAlloc / N\n\t\"allocs\": \"allocs/op\", // ΔMemStats.Mallocs / N\n\t\"sys-total\": \"bytes from system\", // MemStats.Sys\n\t\"sys-heap\": \"heap bytes from system\", // MemStats.HeapSys\n\t\"sys-stack\": \"stack bytes from system\", // MemStats.StackSys\n\t\"sys-gc\": \"GC bytes from system\", // MemStats.GCSys\n\t\"sys-other\": \"other bytes from system\", // MemStats.OtherSys+MSpanSys+MCacheSys+BuckHashSys\n\t\"gc-pause-total\": \"STW ns/op\", // ΔMemStats.PauseTotalNs / N\n\t\"gc-pause-one\": \"STW ns/GC\", // ΔMemStats.PauseTotalNs / ΔNumGC\n\t\"rss\": \"max RSS bytes\", // Rusage.Maxrss * 1<<10\n\t\"cputime\": \"user+sys ns/op\", // Rusage.Utime+Stime\n\t\"virtual-mem\": \"peak VM bytes\", // /proc/self/status VmPeak\n}\n\n// readFile reads a set of benchmarks from a file in to a Collection.\nfunc readFile(file string, c *Collection) {\n\tc.Configs = append(c.Configs, file)\n\tkey := BenchKey{Config: file}\n\n\ttext, err := ioutil.ReadFile(file)\n\tif err != nil {\n\t\tlog.Fatal(err)\n\t}\n\tfor _, line := range strings.Split(string(text), \"\\n\") {\n\t\tif strings.HasPrefix(line, \"GOPERF-METRIC:\") {\n\t\t\t// x/benchmarks-style output.\n\t\t\tline := line[14:]\n\t\t\tf := strings.Split(line, \"=\")\n\t\t\tval, err := strconv.ParseFloat(f[1], 64)\n\t\t\tif err != nil {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tkey.Benchmark = f[0]\n\t\t\tkey.Unit = unitOfXMetric[f[0]]\n\t\t\tif key.Unit == \"\" {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tstat := c.AddStat(key)\n\t\t\tstat.Values = append(stat.Values, val)\n\t\t\tcontinue\n\t\t}\n\n\t\tf := strings.Fields(line)\n\t\tif len(f) < 4 {\n\t\t\tcontinue\n\t\t}\n\t\tname := f[0]\n\t\tif !strings.HasPrefix(name, \"Benchmark\") {\n\t\t\tcontinue\n\t\t}\n\t\tname = strings.TrimPrefix(name, \"Benchmark\")\n\t\tn, _ := strconv.Atoi(f[1])\n\t\tif n == 0 {\n\t\t\tcontinue\n\t\t}\n\n\t\tkey.Benchmark = name\n\t\tfor i := 2; i+2 <= len(f); i += 2 {\n\t\t\tval, err := strconv.ParseFloat(f[i], 64)\n\t\t\tif err != nil {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tkey.Unit = f[i+1]\n\t\t\tstat := c.AddStat(key)\n\t\t\tstat.Values = append(stat.Values, val)\n\t\t}\n\t}\n}\n" }, { "path": "benchmany/run.go", "content": "// Copyright 2015 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage main\n\nimport (\n\t\"bytes\"\n\t\"flag\"\n\t\"fmt\"\n\t\"io\"\n\t\"io/ioutil\"\n\t\"log\"\n\t\"math\"\n\t\"math/rand\"\n\t\"os\"\n\t\"os/exec\"\n\t\"path/filepath\"\n\t\"regexp\"\n\t\"strings\"\n\t\"time\"\n\n\t\"github.com/aclements/go-misc/bench\"\n\t\"github.com/aclements/go-moremath/stats\"\n)\n\n// TODO: Check CPU performance governor before each benchmark.\n\n// TODO: Support running pre-built binaries without specific hashes.\n// This is useful for testing things that aren't yet committed or that\n// require unusual build steps.\n\nvar run struct {\n\torder string\n\tmetric string\n\tbenchFlags string\n\tbuildCmd string\n\titerations int\n\tsaveTree bool\n\ttimeout time.Duration\n\tclean bool\n\tcleanFlags string\n\n\tlogPath string\n\tbinDir string\n}\n\nfunc init() {\n\t// TODO: This makes a mess of flags during testing.\n\tisXBenchmark := false\n\tif abs, _ := os.Getwd(); strings.HasSuffix(abs, \"golang.org/x/benchmarks/bench\") {\n\t\tisXBenchmark = true\n\t}\n\n\tf := flag.CommandLine\n\tflag.Usage = func() {\n\t\tfmt.Fprintf(os.Stderr, \"Usage: %s [flags] \\n\", os.Args[0])\n\t\tf.PrintDefaults()\n\t}\n\tf.StringVar(&run.order, \"order\", \"seq\", \"run benchmarks in `order`, which must be one of: seq, spread, metric\")\n\tf.StringVar(&run.metric, \"metric\", \"ns/op\", \"for -order metric, the benchmark metric to find differences in\")\n\tf.StringVar(&gitDir, \"C\", \"\", \"run git in `dir`\")\n\tdefaultBenchFlags := \"-test.run NONE -test.bench .\"\n\tif isXBenchmark {\n\t\tdefaultBenchFlags = \"\"\n\t}\n\tf.StringVar(&run.benchFlags, \"benchflags\", defaultBenchFlags, \"pass `flags` to benchmark\")\n\tdefaultBuildCmd := \"go test -c\"\n\tif isXBenchmark {\n\t\tdefaultBuildCmd = \"go build\"\n\t}\n\tf.StringVar(&run.buildCmd, \"buildcmd\", defaultBuildCmd, \"build benchmark using \\\"`cmd` -o \\\"\")\n\tf.IntVar(&run.iterations, \"n\", 5, \"run each benchmark `N` times\")\n\tf.StringVar(&run.logPath, \"o\", \"\", \"write benchmark results to `file` (default \\\"bench.log\\\" in -d directory)\")\n\tf.StringVar(&run.binDir, \"d\", \".\", \"write binaries to `directory`\")\n\tf.BoolVar(&run.saveTree, \"save-tree\", false, \"save Go trees using gover and run benchmarks under saved trees\")\n\tf.DurationVar(&run.timeout, \"timeout\", 30*time.Minute, \"time out a run after `duration`\")\n\tf.BoolVar(&dryRun, \"dry-run\", false, \"print commands but do not run them\")\n\tf.BoolVar(&run.clean, \"clean\", false, \"run \\\"git clean -f\\\" after every checkout\")\n\tf.StringVar(&run.cleanFlags, \"cleanflags\", \"\", \"add `flags` to git clean command\")\n}\n\nfunc doRun() {\n\tif flag.NArg() < 1 {\n\t\tflag.Usage()\n\t\tos.Exit(2)\n\t}\n\n\tvar pickCommit func([]*commitInfo) *commitInfo\n\tswitch run.order {\n\tcase \"seq\":\n\t\tpickCommit = pickCommitSeq\n\tcase \"spread\":\n\t\tpickCommit = pickCommitSpread\n\tcase \"metric\":\n\t\tpickCommit = pickCommitMetric\n\tdefault:\n\t\tfmt.Fprintf(os.Stderr, \"unknown order: %s\\n\", run.order)\n\t\tflag.Usage()\n\t\tos.Exit(2)\n\t}\n\n\tif run.logPath == \"\" {\n\t\trun.logPath = filepath.Join(run.binDir, \"bench.log\")\n\t}\n\n\tcommits := getCommits(flag.Args(), run.logPath)\n\n\t// Write header block to log.\n\tif len(commits) > 0 {\n\t\theader := new(bytes.Buffer)\n\t\tfmt.Fprintf(header, \"# Run started at %s\\n\", time.Now())\n\t\twriteHeader(header)\n\t\tfmt.Fprintf(header, \"\\n\")\n\t\tcommits[0].writeLog(header.String())\n\t}\n\n\t// Always run git from the top level of the git tree. Some\n\t// commands, like git clean, care about this.\n\tgitDir = trimNL(git(\"rev-parse\", \"--show-toplevel\"))\n\n\tstatus := NewStatusReporter()\n\tdefer status.Stop()\n\n\tfor {\n\t\tdoneIters, totalIters, partialCommits, doneCommits, failedCommits := runStats(commits)\n\t\tunstartedCommits := len(commits) - (partialCommits + doneCommits + failedCommits)\n\t\tmsg := fmt.Sprintf(\"%d/%d runs, %d unstarted+%d partial+%d done+%d failed commits\", doneIters, totalIters, unstartedCommits, partialCommits, doneCommits, failedCommits)\n\t\t// TODO: Count builds and runs separately.\n\t\tstatus.Progress(msg, float64(doneIters)/float64(totalIters))\n\n\t\tcommit := pickCommit(commits)\n\t\tif commit == nil {\n\t\t\tbreak\n\t\t}\n\t\trunBenchmark(commit, status)\n\t}\n}\n\nfunc writeHeader(w io.Writer) {\n\tgoos, err := exec.Command(\"go\", \"env\", \"GOOS\").Output()\n\tif err != nil {\n\t\tlog.Fatalf(\"error running go env GOOS: %s\", err)\n\t}\n\tfmt.Fprintf(w, \"goos: %s\\n\", strings.TrimSpace(string(goos)))\n\n\tgoarch, err := exec.Command(\"go\", \"env\", \"GOARCH\").Output()\n\tif err != nil {\n\t\tlog.Fatalf(\"error running go env GOARCH: %s\", err)\n\t}\n\tfmt.Fprintf(w, \"goarch: %s\\n\", strings.TrimSpace(string(goarch)))\n\n\tkernel, err := exec.Command(\"uname\", \"-sr\").Output()\n\tif err != nil {\n\t\tlog.Fatalf(\"error running uname -sr: %s\", err)\n\t}\n\tfmt.Fprintf(w, \"uname-sr: %s\\n\", strings.TrimSpace(string(kernel)))\n\n\tcpuinfo, err := ioutil.ReadFile(\"/proc/cpuinfo\")\n\tif err == nil {\n\t\tsubs := regexp.MustCompile(`(?m)^model name\\s*:\\s*(.*)`).FindSubmatch(cpuinfo)\n\t\tif subs != nil {\n\t\t\tfmt.Fprintf(w, \"cpu: %s\\n\", string(subs[1]))\n\t\t}\n\t}\n\n\tfmt.Fprintf(w, \"tool: benchmany\\n\")\n}\n\nfunc runStats(commits []*commitInfo) (doneIters, totalIters, partialCommits, doneCommits, failedCommits int) {\n\tfor _, c := range commits {\n\t\tif c.count >= run.iterations {\n\t\t\t// Don't care if it failed.\n\t\t\tdoneIters += c.count\n\t\t\ttotalIters += c.count\n\t\t} else if c.runnable() {\n\t\t\tdoneIters += c.count\n\t\t\ttotalIters += run.iterations\n\t\t}\n\n\t\tif c.count == run.iterations {\n\t\t\tdoneCommits++\n\t\t} else if c.runnable() {\n\t\t\tif c.count != 0 {\n\t\t\t\tpartialCommits++\n\t\t\t}\n\t\t} else {\n\t\t\tfailedCommits++\n\t\t}\n\t}\n\treturn\n}\n\n// pickCommitSeq picks the next commit to run based on the most recent\n// commit with the fewest iterations.\nfunc pickCommitSeq(commits []*commitInfo) *commitInfo {\n\tvar minCommit *commitInfo\n\tfor _, commit := range commits {\n\t\tif !commit.runnable() {\n\t\t\tcontinue\n\t\t}\n\t\tif minCommit == nil || commit.count < minCommit.count {\n\t\t\tminCommit = commit\n\t\t}\n\t}\n\treturn minCommit\n}\n\n// pickCommitSpread picks the next commit to run from commits using an\n// algorithm that spreads out the runs.\nfunc pickCommitSpread(commits []*commitInfo) *commitInfo {\n\t// Assign weights to each commit. This is thoroughly\n\t// heuristic, but it's geared toward either increasing the\n\t// iteration count of commits that we have, or picking a new\n\t// commit so as to spread out the commits we have.\n\tweights := make([]int, len(commits))\n\ttotalWeight := 0\n\n\tnPartial := 0\n\tfor _, commit := range commits {\n\t\tif commit.partial() {\n\t\t\tnPartial++\n\t\t}\n\t}\n\tif nPartial >= len(commits)/10 {\n\t\t// Limit the number of partially completed revisions\n\t\t// to 10% by only choosing a partial commit in this\n\t\t// case.\n\t\tfor i, commit := range commits {\n\t\t\tif commit.partial() {\n\t\t\t\t// Bias toward commits that are\n\t\t\t\t// further from done.\n\t\t\t\tweights[i] = run.iterations - commit.count\n\t\t\t}\n\t\t}\n\t} else {\n\t\t// Pick a new commit weighted by its distance from a\n\t\t// commit that we already have.\n\n\t\t// Find distance from left to right.\n\t\tdistance := len(commits)\n\t\thaveAny := false\n\t\tfor i, commit := range commits {\n\t\t\tif commit.count > 0 {\n\t\t\t\tdistance = 1\n\t\t\t\thaveAny = true\n\t\t\t} else if commit.runnable() {\n\t\t\t\tdistance++\n\t\t\t}\n\t\t\tweights[i] = distance\n\t\t}\n\n\t\t// Find distance from right to left.\n\t\tdistance = len(commits)\n\t\tfor i := len(commits) - 1; i >= 0; i-- {\n\t\t\tcommit := commits[i]\n\t\t\tif commit.count > 0 {\n\t\t\t\tdistance = 1\n\t\t\t} else if commit.runnable() {\n\t\t\t\tdistance++\n\t\t\t}\n\n\t\t\tif distance < weights[i] {\n\t\t\t\tweights[i] = distance\n\t\t\t}\n\t\t}\n\n\t\tif !haveAny {\n\t\t\t// We don't have any commits. Pick one uniformly.\n\t\t\tfor i := range commits {\n\t\t\t\tweights[i] = 1\n\t\t\t}\n\t\t}\n\n\t\t// Zero non-runnable commits.\n\t\tfor i, commit := range commits {\n\t\t\tif !commit.runnable() {\n\t\t\t\tweights[i] = 0\n\t\t\t}\n\t\t}\n\t}\n\n\tfor _, w := range weights {\n\t\ttotalWeight += w\n\t}\n\tif totalWeight == 0 {\n\t\treturn nil\n\t}\n\n\t// Pick a commit based on the weights.\n\tx := rand.Intn(totalWeight)\n\tcumulative := 0\n\tfor i, w := range weights {\n\t\tcumulative += w\n\t\tif cumulative > x {\n\t\t\treturn commits[i]\n\t\t}\n\t}\n\tpanic(\"unreachable\")\n}\n\nfunc pickCommitMetric(commits []*commitInfo) *commitInfo {\n\t// If there are any partial commits, finish them up.\n\tfor _, c := range commits {\n\t\tif c.partial() {\n\t\t\treturn c\n\t\t}\n\t}\n\n\t// Remove failed commits. This makes it easier to avoid\n\t// picking a failed commit below.\n\tncommits := []*commitInfo{}\n\tfor _, c := range commits {\n\t\tif !c.failed() {\n\t\t\tncommits = append(ncommits, c)\n\t\t}\n\t}\n\tcommits = ncommits\n\tif len(ncommits) == 0 {\n\t\treturn nil\n\t}\n\n\t// Make sure we've run the most recent commit.\n\tif commits[0].runnable() {\n\t\treturn commits[0]\n\t}\n\n\t// Make sure we've run the earliest commit.\n\tif c := commits[len(commits)-1]; c.runnable() {\n\t\treturn c\n\t}\n\n\t// We're bounded from both sides and every commit we've run\n\t// has the best stats we're going to get. Parse run.metric\n\t// from the log file.\n\tlogf, err := os.Open(run.logPath)\n\tif err != nil {\n\t\tlog.Fatal(\"opening benchmark log: \", err)\n\t}\n\tdefer logf.Close()\n\tbs, err := bench.Parse(logf)\n\tif err != nil {\n\t\tlog.Fatal(\"parsing benchmark log for metrics: \", err)\n\t}\n\tresults := make(map[string]map[string][]float64)\n\tfor _, b := range bs {\n\t\tvar hash string\n\t\tif commitConfig, ok := b.Config[\"commit\"]; !ok {\n\t\t\tcontinue\n\t\t} else {\n\t\t\thash = commitConfig.RawValue\n\t\t}\n\t\tresult, ok := b.Result[run.metric]\n\t\tif !ok {\n\t\t\tcontinue\n\t\t}\n\n\t\tif results[hash] == nil {\n\t\t\tresults[hash] = make(map[string][]float64)\n\t\t}\n\t\tresults[hash][b.Name] = append(results[hash][b.Name], result)\n\t}\n\tgeomeans := make(map[string]float64)\n\tfor hash, benches := range results {\n\t\tvar means []float64\n\t\tfor _, results := range benches {\n\t\t\tmeans = append(means, stats.Mean(results))\n\t\t}\n\t\tgeomeans[hash] = stats.GeoMean(means)\n\t}\n\n\t// Find the pair of commits with the biggest difference in the\n\t// metric.\n\tprevI := -1\n\tmaxDiff, maxMid := -1.0, (*commitInfo)(nil)\n\tfor i, c := range commits {\n\t\tif c.count == 0 || geomeans[c.hash] == 0 {\n\t\t\tcontinue\n\t\t}\n\t\tif prevI == -1 {\n\t\t\tprevI = i\n\t\t\tcontinue\n\t\t}\n\n\t\tif i > prevI+1 {\n\t\t\t// TODO: This isn't branch-aware. We should\n\t\t\t// only compare commits with an ancestry\n\t\t\t// relationship.\n\t\t\tdiff := math.Abs(geomeans[c.hash] - geomeans[commits[prevI].hash])\n\t\t\tif diff > maxDiff {\n\t\t\t\tmaxDiff = diff\n\t\t\t\tmaxMid = commits[(prevI+i)/2]\n\t\t\t}\n\t\t}\n\t\tprevI = i\n\t}\n\treturn maxMid\n}\n\n// runBenchmark runs the benchmark at commit. It updates commit.count,\n// commit.fails, and commit.buildFailed as appropriate and writes to\n// the commit log to record the outcome.\nfunc runBenchmark(commit *commitInfo, status *StatusReporter) {\n\t// Build the benchmark if necessary.\n\tbinPath := filepath.Join(run.binDir, commit.binPath())\n\tif !exists(binPath) {\n\t\trunStatus(status, commit, \"building\")\n\n\t\t// Check out the appropriate commit. This is necessary\n\t\t// even if we're using gover because the benchmark\n\t\t// itself might have changed (e.g., bug fixes).\n\t\tgit(\"checkout\", \"-q\", commit.hash)\n\n\t\tif run.clean {\n\t\t\targs := append([]string{\"-f\"}, strings.Fields(run.cleanFlags)...)\n\t\t\tgit(\"clean\", args...)\n\t\t}\n\n\t\tvar buildCmd []string\n\t\tif commit.gover {\n\t\t\tbuildCmd = []string{\"gover\", \"with\", commit.hash}\n\t\t} else {\n\t\t\t// If this is the Go toolchain, do a full\n\t\t\t// make.bash. Otherwise, we assume that go\n\t\t\t// test -c will build the necessary\n\t\t\t// dependencies.\n\t\t\tif exists(filepath.Join(gitDir, \"src\", \"make.bash\")) {\n\t\t\t\tcmd := exec.Command(\"./make.bash\")\n\t\t\t\tcmd.Dir = filepath.Join(gitDir, \"src\")\n\t\t\t\tif dryRun {\n\t\t\t\t\tdryPrint(cmd)\n\t\t\t\t} else if out, err := combinedOutputTimeout(cmd); err != nil {\n\t\t\t\t\tdetail := indent(string(out)) + indent(err.Error())\n\t\t\t\t\tfmt.Fprintf(os.Stderr, \"failed to build toolchain at %s:\\n%s\", commit.hash, detail)\n\t\t\t\t\tcommit.logFailed(true, detail)\n\t\t\t\t\treturn\n\t\t\t\t}\n\t\t\t\tif run.saveTree && doGoverSave() == nil {\n\t\t\t\t\tcommit.gover = true\n\t\t\t\t}\n\t\t\t}\n\t\t\t// Assume build command is in $PATH.\n\t\t\t//\n\t\t\t// TODO: Force PATH if we built the toolchain.\n\t\t\tbuildCmd = []string{}\n\t\t}\n\n\t\tbuildCmd = append(buildCmd, strings.Fields(run.buildCmd)...)\n\t\tbuildCmd = append(buildCmd, \"-o\", binPath)\n\t\tcmd := exec.Command(buildCmd[0], buildCmd[1:]...)\n\t\tif dryRun {\n\t\t\tdryPrint(cmd)\n\t\t} else if out, err := combinedOutputTimeout(cmd); err != nil {\n\t\t\tdetail := indent(string(out)) + indent(err.Error())\n\t\t\tfmt.Fprintf(os.Stderr, \"failed to build tests at %s:\\n%s\", commit.hash, detail)\n\t\t\tcommit.logFailed(true, detail)\n\t\t\treturn\n\t\t}\n\t}\n\n\t// Run the benchmark.\n\trunStatus(status, commit, \"running\")\n\tif filepath.Base(binPath) == binPath {\n\t\t// Make exec.Command treat this as a relative path.\n\t\tbinPath = \"./\" + binPath\n\t}\n\targs := append([]string{binPath}, strings.Fields(run.benchFlags)...)\n\tif run.saveTree {\n\t\targs = append([]string{\"gover\", \"with\", commit.hash}, args...)\n\t}\n\tcmd := exec.Command(args[0], args[1:]...)\n\tif dryRun {\n\t\tdryPrint(cmd)\n\t\tcommit.count++\n\t\treturn\n\t}\n\tout, err := combinedOutputTimeout(cmd)\n\tif err == nil {\n\t\tcommit.logRun(string(out))\n\t} else {\n\t\tdetail := indent(string(out)) + indent(err.Error())\n\t\tfmt.Fprintf(os.Stderr, \"failed to run benchmark at %s:\\n%s\", commit.hash, detail)\n\t\tcommit.logFailed(false, detail)\n\t}\n}\n\nfunc doGoverSave() error {\n\tcmd := exec.Command(\"gover\", \"save\")\n\tcmd.Dir = gitDir\n\tif dryRun {\n\t\tdryPrint(cmd)\n\t\treturn nil\n\t} else {\n\t\tout, err := cmd.CombinedOutput()\n\t\tif err != nil {\n\t\t\tfmt.Fprintf(os.Stderr, \"gover save failed: %s:\\n%s\", err, indent(string(out)))\n\t\t}\n\t\treturn err\n\t}\n}\n\n// runStatus updates the status message for commit.\nfunc runStatus(sr *StatusReporter, commit *commitInfo, status string) {\n\tsr.Message(fmt.Sprintf(\"commit %s, iteration %d/%d: %s...\", commit.hash[:7], commit.count+1, run.iterations, status))\n}\n\n// combinedOutputTimeout is like c.CombinedOutput(), but if\n// run.timeout != 0, it will kill c after run.timeout time expires.\nfunc combinedOutputTimeout(c *exec.Cmd) (out []byte, err error) {\n\tvar b bytes.Buffer\n\tc.Stdout = &b\n\tc.Stderr = &b\n\tif err := c.Start(); err != nil {\n\t\treturn nil, err\n\t}\n\n\tif run.timeout == 0 {\n\t\terr := c.Wait()\n\t\treturn b.Bytes(), err\n\t}\n\n\ttick := time.NewTimer(run.timeout)\n\ttrace := signalTrace\n\tdone := make(chan error)\n\tgo func() {\n\t\tdone <- c.Wait()\n\t}()\nloop:\n\tfor {\n\t\tselect {\n\t\tcase err = <-done:\n\t\t\tbreak loop\n\t\tcase <-tick.C:\n\t\t\tif trace != nil {\n\t\t\t\tfmt.Fprintf(os.Stderr, \"command timed out; sending %v\\n\", trace)\n\t\t\t\tc.Process.Signal(trace)\n\t\t\t\ttick = time.NewTimer(5 * time.Second)\n\t\t\t\ttrace = nil\n\t\t\t} else {\n\t\t\t\tfmt.Fprintf(os.Stderr, \"command timed out; killing\\n\")\n\t\t\t\tc.Process.Kill()\n\t\t\t}\n\t\t}\n\t}\n\ttick.Stop()\n\treturn b.Bytes(), err\n}\n" }, { "path": "benchmany/run_test.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage main\n\nimport (\n\t\"fmt\"\n\t\"io/ioutil\"\n\t\"math/rand\"\n\t\"os\"\n\t\"os/exec\"\n\t\"path/filepath\"\n\t\"testing\"\n\n\t\"github.com/aclements/go-misc/bench\"\n)\n\nfunc TestPickSpread(t *testing.T) {\n\trun.iterations = 5\n\n\tfor iter := 0; iter < 10; iter++ {\n\t\tcommits := []*commitInfo{}\n\t\tfor i := 0; i < 100; i++ {\n\t\t\tcommits = append(commits, &commitInfo{})\n\t\t}\n\n\t\tfor {\n\t\t\tcommit := pickCommitSpread(commits)\n\t\t\tif commit == nil {\n\t\t\t\tbreak\n\t\t\t}\n\n\t\t\tif rand.Intn(50) == 0 {\n\t\t\t\tcommit.buildFailed = true\n\t\t\t} else if rand.Intn(50) == 1 {\n\t\t\t\tcommit.fails++\n\t\t\t} else {\n\t\t\t\tcommit.count++\n\t\t\t}\n\t\t}\n\n\t\t// Test that all of the commits ran the expected\n\t\t// number of times.\n\t\tfor _, c := range commits {\n\t\t\tif c.runnable() {\n\t\t\t\tt.Fatalf(\"commit still runnable %+v\", c)\n\t\t\t}\n\t\t}\n\t}\n}\n\nfunc TestRun(t *testing.T) {\n\t// Create a git repo for testing.\n\trepo, err := ioutil.TempDir(\"\", \"benchmany-test\")\n\tif err != nil {\n\t\tt.Fatal(\"creating temp dir: \", err)\n\t}\n\tdefer os.RemoveAll(repo)\n\ttgit(t, repo, \"init\")\n\ttgit(t, repo, \"config\", \"user.name\", \"gopher\")\n\ttgit(t, repo, \"config\", \"user.email\", \"gopher@example.com\")\n\n\t// Write benchmark.\n\terr = ioutil.WriteFile(filepath.Join(repo, \"x_test.go\"), []byte(`\npackage main\n\nimport \"testing\"\n\nfunc TestMain(m *testing.M) {\n\tprintln(\"BenchmarkX 1 100 ns/op\")\n}`), 0666)\n\tif err != nil {\n\t\tt.Fatal(\"writing x_test.go: \", err)\n\t}\n\ttgit(t, repo, \"add\", \"x_test.go\")\n\ttgit(t, repo, \"commit\", \"-m\", \"initial\")\n\n\t// Create several commits.\n\tvar revs []string\n\tfor i := 0; i < 3; i++ {\n\t\tstr := fmt.Sprintf(\"%d\", i)\n\t\terr = ioutil.WriteFile(filepath.Join(repo, \"x\"), []byte(str), 0666)\n\t\tif err != nil {\n\t\t\tt.Fatal(\"writing x: \", err)\n\t\t}\n\t\ttgit(t, repo, \"add\", \"x\")\n\t\ttgit(t, repo, \"commit\", \"-m\", str)\n\t\trevs = append(revs, trimNL(tgit(t, repo, \"rev-parse\", \"HEAD\")))\n\t}\n\n\tfor iters := 4; iters <= 5; iters++ {\n\t\t// Run benchmark.\n\t\ttgit(t, repo, \"checkout\", \"master\")\n\t\toldArgs := os.Args\n\t\toldWD, err := os.Getwd()\n\t\tif err != nil {\n\t\t\tt.Fatal(\"Getwd: \", err)\n\t\t}\n\t\tos.Args = []string{os.Args[0], \"-n\", fmt.Sprintf(\"%d\", iters), \"HEAD~3..HEAD\"}\n\t\tos.Chdir(repo)\n\t\tdefer func() {\n\t\t\tos.Args = oldArgs\n\t\t\tos.Chdir(oldWD)\n\t\t}()\n\t\tmain()\n\n\t\t// Check results.\n\t\tf, err := os.Open(filepath.Join(repo, \"bench.log\"))\n\t\tif err != nil {\n\t\t\tt.Fatal(\"opening bench.log: \", err)\n\t\t}\n\t\tdefer f.Close()\n\t\tbs, err := bench.Parse(f)\n\t\tif err != nil {\n\t\t\tt.Fatal(\"malformed benchmark log: \", err)\n\t\t}\n\t\tcounts := make(map[string]int)\n\t\tfor _, b := range bs {\n\t\t\tt.Log(b, b.Config[\"commit\"].RawValue)\n\t\t\tcounts[b.Config[\"commit\"].RawValue]++\n\n\t\t\tif uname, ok := b.Config[\"uname-sr\"]; !ok {\n\t\t\t\tt.Errorf(\"missing uname-sr config\")\n\t\t\t} else {\n\t\t\t\tt.Logf(\"uname-sr: %s\", uname)\n\t\t\t}\n\t\t}\n\t\tfor _, rev := range revs {\n\t\t\tif counts[rev] != iters {\n\t\t\t\tt.Errorf(\"expected %d results for %s, got %d\", iters, rev, counts[rev])\n\t\t\t}\n\t\t}\n\t}\n}\n\nfunc tgit(t *testing.T, repo string, args ...string) string {\n\tcmd := exec.Command(\"git\", args...)\n\tcmd.Dir = repo\n\tout, err := cmd.CombinedOutput()\n\tif err != nil {\n\t\tt.Fatalf(\"git %s failed: %v\\n%s\", args, err, out)\n\t}\n\treturn string(out)\n}\n" }, { "path": "benchmany/signal_notunix.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// +build plan9 windows\n\npackage main\n\nimport \"os\"\n\nvar signalTrace os.Signal = nil\n" }, { "path": "benchmany/signal_unix.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// +build !plan9,!windows\n\npackage main\n\nimport (\n\t\"os\"\n\t\"syscall\"\n)\n\nvar signalTrace os.Signal = syscall.SIGQUIT\n" }, { "path": "benchmany/status.go", "content": "// Copyright 2015 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage main\n\nimport (\n\t\"fmt\"\n\t\"math\"\n\t\"os\"\n\t\"time\"\n\n\t\"github.com/aclements/go-moremath/fit\"\n\t\"golang.org/x/crypto/ssh/terminal\"\n)\n\ntype StatusReporter struct {\n\tupdate chan<- statusUpdate\n\tdone chan bool\n}\n\ntype statusUpdate struct {\n\tprogress float64\n\tmessage string\n}\n\nfunc NewStatusReporter() *StatusReporter {\n\tif os.Getenv(\"TERM\") == \"dumb\" || !terminal.IsTerminal(1) {\n\t\treturn &StatusReporter{}\n\t}\n\tupdate := make(chan statusUpdate)\n\tsr := &StatusReporter{update: update}\n\tgo sr.loop(update)\n\treturn sr\n}\n\nfunc (sr *StatusReporter) Progress(msg string, frac float64) {\n\tif sr.update != nil {\n\t\tsr.update <- statusUpdate{message: msg, progress: frac}\n\t}\n}\n\nfunc (sr *StatusReporter) Message(msg string) {\n\tif sr.update == nil {\n\t\tfmt.Println(msg)\n\t} else {\n\t\tsr.update <- statusUpdate{message: msg, progress: -1}\n\t}\n}\n\nfunc (sr *StatusReporter) Stop() {\n\tif sr.update != nil {\n\t\tsr.done = make(chan bool)\n\t\tclose(sr.update)\n\t\t<-sr.done\n\t\tsr.update = nil\n\t}\n}\n\nfunc (sr *StatusReporter) loop(updates <-chan statusUpdate) {\n\tconst resetLine = \"\\r\\x1b[2K\"\n\tconst wrapOff = \"\\x1b[?7l\"\n\tconst wrapOn = \"\\x1b[?7h\"\n\n\ttick := time.NewTicker(time.Second / 4)\n\tdefer tick.Stop()\n\n\tvar end time.Time\n\tt0 := time.Now()\n\n\tvar times, progress, weights []float64\n\tvar msg string\n\tfor {\n\t\tselect {\n\t\tcase update, ok := <-updates:\n\t\t\tif !ok {\n\t\t\t\tfmt.Print(resetLine)\n\t\t\t\tclose(sr.done)\n\t\t\t\treturn\n\t\t\t}\n\t\t\tif update.progress == -1 {\n\t\t\t\tfmt.Print(resetLine)\n\t\t\t\tfmt.Println(update.message)\n\t\t\t\tbreak\n\t\t\t}\n\t\t\tnow := float64(time.Now().Sub(t0))\n\t\t\ttimes = append(times, float64(now))\n\t\t\tprogress = append(progress, update.progress)\n\t\t\tweights = append(weights, 0)\n\t\t\tmsg = update.message\n\n\t\t\t// Compute ETA using linear regression with\n\t\t\t// exponentially decaying weights.\n\t\t\tconst halfLife = 150 * time.Second\n\t\t\tfor i, t := range times {\n\t\t\t\tweights[i] = math.Exp(-1 / float64(halfLife) * (now - t))\n\t\t\t}\n\t\t\treg := fit.PolynomialRegression(times, progress, weights, 1)\n\t\t\ta, b := reg.Coefficients[0], reg.Coefficients[1]\n\n\t\t\t// The intercept of a + b*x - 1 is the ending\n\t\t\t// time.\n\t\t\tif b == 0 {\n\t\t\t\tend = time.Time{}\n\t\t\t} else {\n\t\t\t\tend = t0.Add(time.Duration((1 - a) / b))\n\t\t\t}\n\n\t\tcase <-tick.C:\n\t\t}\n\n\t\tvar eta string\n\n\t\tif end.IsZero() {\n\t\t\teta = \"unknown\"\n\t\t} else {\n\t\t\tetaDur := end.Sub(time.Now())\n\t\t\t// Trim off sub-second precision.\n\t\t\tetaDur -= etaDur % time.Second\n\t\t\tif etaDur <= 0 {\n\t\t\t\teta = \"0s\"\n\t\t\t} else {\n\t\t\t\teta = etaDur.String()\n\t\t\t}\n\t\t}\n\t\tif msg == \"\" {\n\t\t\teta = \"ETA \" + eta\n\t\t} else {\n\t\t\teta = \", ETA \" + eta\n\t\t}\n\t\t// TODO: This isn't quite right. If we hit the right\n\t\t// edge of the terminal, it won't wrap, but the\n\t\t// right-most character will be the *last* character\n\t\t// in the string, since terminal keeps overwriting it.\n\t\tfmt.Printf(\"%s%s%s%s%s\", resetLine, wrapOff, msg, eta, wrapOn)\n\t}\n}\n" }, { "path": "benchplot/git.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage main\n\nimport (\n\t\"log\"\n\t\"os\"\n\t\"os/exec\"\n\t\"regexp\"\n\t\"strings\"\n\t\"time\"\n)\n\ntype CommitInfo struct {\n\tHash, Subject, Branch string\n\tAuthorDate, CommitDate time.Time\n\n\tParents, Children []string\n}\n\nfunc Commits(repo string, revs ...string) (commits []CommitInfo) {\n\targs := []string{\"-C\", repo, \"log\", \"-s\",\n\t\t\"--format=format:%H %aI %cI %P\\n%s\\n\"}\n\tif len(revs) == 0 {\n\t\targs = append(args, \"--all\")\n\t} else {\n\t\targs = append(append(args, \"--\"), revs...)\n\t}\n\tcmd := exec.Command(\"git\", args...)\n\tcmd.Stderr = os.Stderr\n\tout, err := cmd.Output()\n\tif err != nil {\n\t\tlog.Fatal(\"git show failed: \", err)\n\t}\n\tfor _, line := range strings.Split(string(out), \"\\n\\n\") {\n\t\tparts := strings.Split(line, \"\\n\")\n\t\tsubject := parts[1]\n\t\tparts = strings.Split(parts[0], \" \")\n\n\t\tadate, err := time.Parse(time.RFC3339, parts[1])\n\t\tif err != nil {\n\t\t\tlog.Fatal(\"cannot parse author date: \", err)\n\t\t}\n\t\tcdate, err := time.Parse(time.RFC3339, parts[2])\n\t\tif err != nil {\n\t\t\tlog.Fatal(\"cannot parse commit date: \", err)\n\t\t}\n\n\t\tcommits = append(commits, CommitInfo{\n\t\t\tparts[0], subject, \"\", adate, cdate,\n\t\t\tparts[3:], nil,\n\t\t})\n\t}\n\n\t// Compute hash indexes.\n\thashset := make(map[string]*CommitInfo)\n\tfor i := range commits {\n\t\thashset[commits[i].Hash] = &commits[i]\n\t}\n\n\t// Compute children hashes.\n\tfor h, ci := range hashset {\n\t\tfor _, parent := range ci.Parents {\n\t\t\tif ci2, ok := hashset[parent]; ok {\n\t\t\t\tci2.Children = append(ci2.Children, h)\n\t\t\t}\n\t\t}\n\t}\n\n\t// Compute branch names.\n\tvar branchRe = regexp.MustCompile(`^\\[[^] ]+\\] `)\n\tvar branchOf func(ci *CommitInfo) string\n\tbranchOf = func(ci *CommitInfo) string {\n\t\tsubject := ci.Subject\n\t\tif strings.HasPrefix(subject, \"[\") {\n\t\t\tm := branchRe.FindString(subject)\n\t\t\tif m != \"\" {\n\t\t\t\treturn m[1 : len(m)-2]\n\t\t\t}\n\t\t}\n\t\tif strings.HasPrefix(subject, \"Merge\") || strings.HasPrefix(subject, \"Revert\") {\n\t\t\t// Walk children looking for a branch name.\n\t\t\tfor _, child := range ci.Children {\n\t\t\t\tif ci2 := hashset[child]; ci2 != nil {\n\t\t\t\t\tbranch := branchOf(ci2)\n\t\t\t\t\tif branch != \"master\" {\n\t\t\t\t\t\treturn branch\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn \"master\"\n\t}\n\tfor _, ci := range hashset {\n\t\tci.Branch = branchOf(ci)\n\t}\n\t// Clean up missing branch tags: if all parents and children\n\t// of a commit have the same non-master branch, that commit\n\t// must also have been from that branch.\ncleanBranches:\n\tfor _, ci := range hashset {\n\t\tif ci.Branch == \"master\" {\n\t\t\talt := \"\"\n\t\t\tfor _, child := range ci.Children {\n\t\t\t\tif ci2 := hashset[child]; ci2 != nil {\n\t\t\t\t\tif alt == \"\" {\n\t\t\t\t\t\talt = ci2.Branch\n\t\t\t\t\t} else if ci2.Branch != alt {\n\t\t\t\t\t\tcontinue cleanBranches\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tfor _, parent := range ci.Parents {\n\t\t\t\tif ci2 := hashset[parent]; ci2 != nil {\n\t\t\t\t\tif alt == \"\" {\n\t\t\t\t\t\talt = ci2.Branch\n\t\t\t\t\t} else if ci2.Branch != alt {\n\t\t\t\t\t\tcontinue cleanBranches\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tif alt != \"\" {\n\t\t\t\tci.Branch = alt\n\t\t\t}\n\t\t}\n\t}\n\n\treturn\n}\n" }, { "path": "benchplot/kza.go", "content": "// Copyright 2015 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage main\n\nimport \"math\"\n\n// TODO: This all assumes that data is sampled at a regular interval\n// and there are no missing values. It could be generalized to accept\n// missing values (perhaps represented by NaN), or generalized much\n// further by accepting (t, x) pairs and a vector of times at which to\n// evaluate the filter (and an arbitrary window size). I would have to\n// figure out how that affects the difference array in KZA.\n\n// TODO: These can generate a lot of garbage. Perhaps the caller\n// should pass in the target slice? Or these should just overwrite the\n// input array and leave it to the caller to copy if necessary?\n\n// MovingAverage performs a moving average (MA) filter of xs with\n// window size m. m must be a positive odd integer.\n//\n// Note that this is filter is often described in terms of the half\n// length of the window (m-1)/2.\nfunc MovingAverage(xs []float64, m int) []float64 {\n\tif m <= 0 || m%2 != 1 {\n\t\tpanic(\"m must be a positive, odd integer\")\n\t}\n\tys := make([]float64, len(xs))\n\tsum, n := 0.0, 0\n\tfor l, i, r := -m, -(m-1)/2, 0; i < len(ys); l, i, r = l+1, i+1, r+1 {\n\t\tif l >= 0 {\n\t\t\tsum -= xs[l]\n\t\t\tn--\n\t\t}\n\t\tif r < len(xs) {\n\t\t\tsum += xs[r]\n\t\t\tn++\n\t\t}\n\t\tif i >= 0 {\n\t\t\tys[i] = sum / float64(n)\n\t\t}\n\t}\n\treturn ys\n}\n\n// KolmogorovZurbenko performs a Kolmogorov-Zurbenko (KZ) filter of xs\n// with window size m and k iterations. m must be a positive odd\n// integer. k must be positive.\nfunc KolmogorovZurbenko(xs []float64, m, k int) []float64 {\n\t// k is typically small, and MA is quite efficient, so just do\n\t// the iterated moving average rather than bothering to\n\t// compute the binomial coefficient kernel.\n\tfor i := 0; i < k; i++ {\n\t\t// TODO: Generate less garbage.\n\t\txs = MovingAverage(xs, m)\n\t}\n\treturn xs\n}\n\n// AdaptiveKolmogorovZurbenko performs an adaptive Kolmogorov-Zurbenko\n// (KZA) filter of xs using an initial window size m and k iterations.\n// m must be a positive odd integer. k must be positive.\n//\n// See Zurbenko, et al. 1996: Detecting discontinuities in time series\n// of upper air data: Demonstration of an adaptive filter technique.\n// Journal of Climate, 9, 3548–3560.\nfunc AdaptiveKolmogorovZurbenko(xs []float64, m, k int) []float64 {\n\t// Perform initial KZ filter.\n\tz := KolmogorovZurbenko(xs, m, k)\n\n\t// Compute differenced values.\n\tq := (m - 1) / 2\n\td := make([]float64, len(z)+1)\n\tmaxD := 0.0\n\tfor i := q; i < len(z)-q; i++ {\n\t\td[i] = math.Abs(z[i+q] - z[i-q])\n\t\tif d[i] > maxD {\n\t\t\tmaxD = d[i]\n\t\t}\n\t}\n\n\tif maxD == 0 {\n\t\t// xs is constant, so no amount of filtering will do\n\t\t// anything. Avoid dividing 0/0 below.\n\t\treturn xs\n\t}\n\n\t// Compute adaptive filter.\n\tys := make([]float64, len(xs))\n\tfor t := range ys {\n\t\tdPrime := d[t+1] - d[t]\n\t\tf := 1 - d[t]/maxD\n\n\t\tqt := q\n\t\tif dPrime <= 0 {\n\t\t\t// Zurbenko doesn't specify what to do with\n\t\t\t// the fractional part of qt and qh, so we\n\t\t\t// interpret this as summing all points of xs\n\t\t\t// between qt and qh.\n\t\t\tqt = int(math.Ceil(float64(q) * f))\n\t\t}\n\t\tif t-qt < 0 {\n\t\t\tqt = t\n\t\t}\n\n\t\tqh := q\n\t\tif dPrime >= 0 {\n\t\t\tqh = int(math.Floor(float64(q) * f))\n\t\t}\n\t\tif t+qh >= len(xs) {\n\t\t\tqh = len(xs) - t - 1\n\t\t}\n\n\t\tsum := 0.0\n\t\tfor i := t - qt; i <= t+qh; i++ {\n\t\t\tsum += xs[i]\n\t\t}\n\t\t// Zurbenko divides by qh+qt, but this undercounts the\n\t\t// number of terms in the sum by 1.\n\t\tys[t] = sum / float64(qh+qt+1)\n\t}\n\n\treturn ys\n}\n" }, { "path": "benchplot/kza_test.go", "content": "// Copyright 2015 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage main\n\nimport (\n\t\"math/rand\"\n\t\"testing\"\n)\n\n// Aeq returns true if expect and got are equal to 8 significant\n// figures (1 part in 100 million).\nfunc Aeq(expect, got float64) bool {\n\tif expect < 0 && got < 0 {\n\t\texpect, got = -expect, -got\n\t}\n\treturn expect*0.99999999 <= got && got*0.99999999 <= expect\n}\n\nfunc TestMovingAverage(t *testing.T) {\n\t// Test MovingAverage against the obvious (but slow)\n\t// implementation.\n\txs := make([]float64, 100)\n\tfor iter := 0; iter < 10; iter++ {\n\t\tfor i := range xs {\n\t\t\txs[i] = rand.Float64()\n\t\t}\n\t\tm := 1 + 2*rand.Intn(100)\n\t\tys1, ys2 := MovingAverage(xs, m), slowMovingAverage(xs, m)\n\n\t\t// TODO: Use stuff from mathtest.\n\t\tfor i, y1 := range ys1 {\n\t\t\tif !Aeq(y1, ys2[i]) {\n\t\t\t\tt.Fatalf(\"want %v, got %v\", ys2, ys1)\n\t\t\t}\n\t\t}\n\t}\n}\n\nfunc slowMovingAverage(xs []float64, m int) []float64 {\n\tys := make([]float64, len(xs))\n\tfor i := range ys {\n\t\tpsum, n := 0.0, 0\n\t\tfor j := i - (m-1)/2; j <= i+(m-1)/2; j++ {\n\t\t\tif 0 <= j && j < len(xs) {\n\t\t\t\tpsum += xs[j]\n\t\t\t\tn++\n\t\t\t}\n\t\t}\n\t\tys[i] = psum / float64(n)\n\t}\n\treturn ys\n}\n" }, { "path": "benchplot/main.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// Command benchplot plots the results of benchmarks over time.\n//\n// benchplot takes an input file in Go benchmark format [1]. Each\n// benchmark result must have a \"commit\" configuration key that gives\n// the full commit hash of the revision that gave that result.\n// benchplot will cross-reference these hashes against the specified\n// Git repository and plot each metric over time for each benchmark.\n//\n// [1] https://github.com/golang/proposal/blob/master/design/14313-benchmark-format.md\npackage main\n\nimport (\n\t\"bytes\"\n\t\"flag\"\n\t\"fmt\"\n\t\"log\"\n\t\"os\"\n\t\"os/exec\"\n\t\"runtime\"\n\t\"runtime/pprof\"\n\t\"strings\"\n\n\t\"github.com/aclements/go-gg/gg\"\n\t\"github.com/aclements/go-gg/table\"\n\t\"github.com/aclements/go-misc/bench\"\n)\n\nfunc main() {\n\tlog.SetPrefix(\"benchplot: \")\n\tlog.SetFlags(0)\n\n\tdefaultGitDir, _ := exec.Command(\"git\", \"rev-parse\", \"--show-toplevel\").Output()\n\tdefaultGitDir = bytes.TrimRight(defaultGitDir, \"\\n\")\n\tvar (\n\t\tflagCPUProfile = flag.String(\"cpuprofile\", \"\", \"write CPU profile to `file`\")\n\t\tflagMemProfile = flag.String(\"memprofile\", \"\", \"write heap profile to `file`\")\n\t\tflagGitDir = flag.String(\"C\", string(defaultGitDir), \"run git in `dir`\")\n\t\tflagOut = flag.String(\"o\", \"\", \"write output to `file` (default: stdout)\")\n\t\tflagTable = flag.Bool(\"table\", false, \"output a table instead of a plot\")\n\t)\n\tflag.Usage = func() {\n\t\tfmt.Fprintf(os.Stderr, \"Usage: %s [flags] [inputs...]\\n\", os.Args[0])\n\t\tflag.PrintDefaults()\n\t}\n\tflag.Parse()\n\n\tif *flagCPUProfile != \"\" {\n\t\tf, err := os.Create(*flagCPUProfile)\n\t\tif err != nil {\n\t\t\tlog.Fatal(err)\n\t\t}\n\t\tpprof.StartCPUProfile(f)\n\t\tdefer pprof.StopCPUProfile()\n\t}\n\n\tif *flagMemProfile != \"\" {\n\t\tdefer func() {\n\t\t\truntime.GC()\n\t\t\tf, err := os.Create(*flagMemProfile)\n\t\t\tif err != nil {\n\t\t\t\tlog.Fatal(err)\n\t\t\t}\n\t\t\tpprof.WriteHeapProfile(f)\n\t\t\tf.Close()\n\t\t}()\n\t}\n\n\t// Parse benchmark inputs.\n\tpaths := flag.Args()\n\tif len(paths) == 0 {\n\t\tpaths = []string{\"-\"}\n\t}\n\tvar benchmarks []*bench.Benchmark\n\tfor _, path := range paths {\n\t\tfunc() {\n\t\t\tf := os.Stdin\n\t\t\tif path != \"-\" {\n\t\t\t\tvar err error\n\t\t\t\tf, err = os.Open(path)\n\t\t\t\tif err != nil {\n\t\t\t\t\tlog.Fatal(err)\n\t\t\t\t}\n\t\t\t\tdefer f.Close()\n\t\t\t}\n\n\t\t\tbs, err := bench.Parse(f)\n\t\t\tif err != nil {\n\t\t\t\tlog.Fatal(err)\n\t\t\t}\n\t\t\tbenchmarks = append(benchmarks, bs...)\n\t\t}()\n\t}\n\tbench.ParseValues(benchmarks, nil)\n\n\t// Prepare gg tables.\n\tvar tab table.Grouping\n\tbtab, configCols, resultCols := benchmarksToTable(benchmarks)\n\tif btab.Column(\"commit\") == nil {\n\t\ttab = btab\n\t} else {\n\t\tgtab := commitsToTable(Commits(*flagGitDir))\n\t\ttab = table.Join(btab, \"commit\", gtab, \"commit\")\n\t}\n\n\t// Prepare for output.\n\tf := os.Stdout\n\tif *flagOut != \"\" {\n\t\tvar err error\n\t\tf, err = os.Create(*flagOut)\n\t\tif err != nil {\n\t\t\tlog.Fatal(err)\n\t\t}\n\t\tdefer f.Close()\n\t}\n\n\t// Output table.\n\tif *flagTable {\n\t\ttable.Fprint(f, tab)\n\t\treturn\n\t}\n\n\t// Plot.\n\t//\n\t// TODO: Collect nrows/ncols from the plot itself.\n\tp, nrows, ncols := plot(tab, configCols, resultCols)\n\tif !(len(paths) == 1 && paths[0] == \"-\") {\n\t\tp.Add(gg.Title(strings.Join(paths, \" \")))\n\t}\n\n\t// Render plot.\n\tp.WriteSVG(f, 500*ncols, 350*nrows)\n}\n" }, { "path": "benchplot/plot.go", "content": "package main\n\nimport (\n\t\"fmt\"\n\t\"math\"\n\n\t\"github.com/aclements/go-gg/generic/slice\"\n\t\"github.com/aclements/go-gg/gg\"\n\t\"github.com/aclements/go-gg/ggstat\"\n\t\"github.com/aclements/go-gg/table\"\n)\n\n// TODO: Support plotting non-normalized results.\n\nfunc plot(t table.Grouping, configCols, resultCols []string) (*gg.Plot, int, int) {\n\t//t = table.Flatten(table.HeadTables(table.GroupBy(t, \"name\"), 9))\n\n\t// Filter to just the master branch.\n\t//\n\t// TODO: Flag to control this? Or separate filter command? Or\n\t// accept a filter expression in the argument?\n\tt = table.FilterEq(t, \"branch\", \"master\")\n\n\t// Compute rows and columns.\n\tncols := len(resultCols)\n\tnrows := len(table.GroupBy(t, \"name\").Tables())\n\n\tplot := gg.NewPlot(t)\n\n\t// Turn ordered commit date into a \"commit index\" column.\n\tplot.SortBy(\"commit date\")\n\tplot.Stat(commitIndex{})\n\n\t// Average each result at each commit (but keep columns names\n\t// the same to keep things easier to read).\n\tplot.Stat(ggstat.Agg(\"commit\", \"name\")(ggstat.AggMean(resultCols...)))\n\tfor _, rcol := range resultCols {\n\t\tplot.SetData(table.Rename(plot.Data(), \"mean \"+rcol, rcol))\n\t}\n\n\t// Unpivot all of the metrics into one column.\n\tplot.Stat(convertFloat{resultCols})\n\tplot.SetData(table.Unpivot(plot.Data(), \"metric\", \"result\", resultCols...))\n\ty := \"result\"\n\n\t// Normalize to earliest commit on master. It's important to\n\t// do this before the geomean if there are commits missing.\n\t// Unfortunately, that also means we have to *temporarily*\n\t// group by name and metric, since the geomean needs to be\n\t// done on a different grouping.\n\tplot.GroupBy(\"name\", \"metric\")\n\tplot.Stat(ggstat.Normalize{X: \"branch\", By: firstMasterIndex, Cols: []string{\"result\"}})\n\ty = \"normalized \" + y\n\tplot.SetData(table.Remove(plot.Data(), \"result\"))\n\tplot.SetData(table.Ungroup(table.Ungroup(plot.Data())))\n\n\t// Compute geomean for each metric at each commit if there's\n\t// more than one benchmark.\n\tif len(table.GroupBy(t, \"name\").Tables()) > 1 {\n\t\tgt := removeNaNs(plot.Data(), y)\n\t\tgt = ggstat.Agg(\"commit\", \"metric\")(ggstat.AggGeoMean(y)).F(gt)\n\t\tgt = table.MapTables(gt, func(_ table.GroupID, t *table.Table) *table.Table {\n\t\t\treturn table.NewBuilder(t).AddConst(\"name\", \" geomean\").Done()\n\t\t})\n\t\tgt = table.Rename(gt, \"geomean \"+y, y)\n\t\tplot.SetData(table.Concat(plot.Data(), gt))\n\t\tnrows++\n\t}\n\n\t// Facet by name and metric.\n\tplot.Add(gg.FacetY{Col: \"name\"}, gg.FacetX{Col: \"metric\"})\n\n\t// Filter the data to reduce noise.\n\tplot.Stat(kza{y, 15, 3})\n\ty = \"filtered \" + y\n\n\t// Always show Y=0.\n\tplot.SetScale(\"y\", gg.NewLinearScaler().Include(0))\n\n\tplot.Add(gg.LayerLines{\n\t\tX: \"commit index\",\n\t\tY: y,\n\t\t//Color: \"branch\",\n\t})\n\t// plot.Add(gg.LayerTags{X: \"commit index\", Y: y, Label: \"branch\"})\n\n\t// Interactive tooltip with short hash.\n\tplot.Stat(tooltip{y})\n\tplot.Add(gg.LayerTooltips{X: \"commit index\", Y: y, Label: \"tooltip\"})\n\n\treturn plot, nrows, ncols\n}\n\nfunc firstMasterIndex(bs []string) int {\n\treturn slice.Index(bs, \"master\")\n}\n\ntype commitIndex struct{}\n\nfunc (commitIndex) F(g table.Grouping) table.Grouping {\n\treturn table.MapTables(g, func(_ table.GroupID, t *table.Table) *table.Table {\n\t\tidxs := make([]int, t.Len())\n\t\tlast, idx := \"\", -1\n\t\tfor i, hash := range t.MustColumn(\"commit\").([]string) {\n\t\t\tif hash != last {\n\t\t\t\tidx++\n\t\t\t\tlast = hash\n\t\t\t}\n\t\t\tidxs[i] = idx\n\t\t}\n\t\tt = table.NewBuilder(t).Add(\"commit index\", idxs).Done()\n\n\t\treturn t\n\t})\n}\n\ntype convertFloat struct {\n\tcols []string\n}\n\nfunc (c convertFloat) F(g table.Grouping) table.Grouping {\n\treturn table.MapTables(g, func(_ table.GroupID, t *table.Table) *table.Table {\n\t\tb := table.NewBuilder(t)\n\t\tfor _, col := range c.cols {\n\t\t\tvar ncol []float64\n\t\t\tslice.Convert(&ncol, t.MustColumn(col))\n\t\t\tb.Add(col, ncol)\n\t\t}\n\t\treturn b.Done()\n\t})\n}\n\nfunc removeNaNs(g table.Grouping, col string) table.Grouping {\n\treturn table.Filter(g, func(result float64) bool {\n\t\treturn !math.IsNaN(result)\n\t}, col)\n}\n\ntype kza struct {\n\tX string\n\tM, K int\n}\n\nfunc (k kza) F(g table.Grouping) table.Grouping {\n\treturn table.MapTables(g, func(_ table.GroupID, t *table.Table) *table.Table {\n\t\tvar xs []float64\n\t\tslice.Convert(&xs, t.MustColumn(k.X))\n\t\tnxs := AdaptiveKolmogorovZurbenko(xs, k.M, k.K)\n\t\treturn table.NewBuilder(t).Add(\"filtered \"+k.X, nxs).Done()\n\t})\n}\n\ntype tooltip struct {\n\tY string\n}\n\nfunc (t tooltip) F(g table.Grouping) table.Grouping {\n\treturn table.MapCols(g,\n\t\tfunc(commit []string, result []float64, tooltip []string) {\n\t\t\tfor i, c := range commit {\n\t\t\t\ttooltip[i] = fmt.Sprintf(\"%s %.2fX\", c[:7], result[i])\n\t\t\t}\n\t\t}, \"commit\", t.Y)(\"tooltip\")\n}\n" }, { "path": "benchplot/table.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage main\n\nimport (\n\t\"math\"\n\t\"reflect\"\n\t\"sort\"\n\t\"strings\"\n\t\"time\"\n\n\t\"github.com/aclements/go-gg/table\"\n\t\"github.com/aclements/go-misc/bench\"\n)\n\nfunc benchmarksToTable(bs []*bench.Benchmark) (t *table.Table, configCols, resultCols []string) {\n\t// Gather name, config, and result columns.\n\tnan := math.NaN()\n\tnames := make([]string, len(bs))\n\tconfigs, results := map[string]reflect.Value{}, map[string][]float64{}\n\tfor i, b := range bs {\n\t\tnames[i] = b.Name\n\n\t\tfor k, c := range b.Config {\n\t\t\tseq, ok := configs[k]\n\t\t\tif !ok {\n\t\t\t\tt := reflect.SliceOf(reflect.TypeOf(c.Value))\n\t\t\t\tseq = reflect.MakeSlice(t, len(bs), len(bs))\n\t\t\t\tconfigs[k] = seq\n\t\t\t}\n\t\t\tseq.Index(i).Set(reflect.ValueOf(c.Value))\n\t\t}\n\n\t\tfor k, v := range b.Result {\n\t\t\tseq, ok := results[k]\n\t\t\tif !ok {\n\t\t\t\tseq = make([]float64, len(bs))\n\t\t\t\tfor i := range seq {\n\t\t\t\t\tseq[i] = nan\n\t\t\t\t}\n\t\t\t\tresults[k] = seq\n\t\t\t}\n\t\t\tseq[i] = v\n\t\t}\n\t}\n\n\t// Build table.\n\ttab := new(table.Builder).Add(\"name\", names)\n\n\tkeys := make([]string, 0, len(configs))\n\tfor k := range configs {\n\t\tkeys = append(keys, k)\n\t}\n\tsort.Strings(keys)\n\tfor _, key := range keys {\n\t\tnicekey := strings.Replace(key, \"-\", \" \", -1)\n\t\tniceval := configs[key].Interface()\n\t\tif n, ok := niceval.([]time.Time); ok {\n\t\t\tniceval = byTime(n)\n\t\t}\n\n\t\ttab.Add(nicekey, niceval)\n\t\tconfigCols = append(configCols, nicekey)\n\t}\n\n\tkeys = make([]string, 0, len(results))\n\tfor k := range results {\n\t\tkeys = append(keys, k)\n\t}\n\tsort.Strings(keys)\n\tfor _, key := range keys {\n\t\tnicekey := strings.Replace(key, \"-\", \" \", -1)\n\t\tif nicekey == \"ns/op\" {\n\t\t\t// TODO: Use the unit parser from benchstat.\n\t\t\tnicekey = \"time/op\"\n\t\t\tdurations := make([]time.Duration, len(results[key]))\n\t\t\tfor i, x := range results[key] {\n\t\t\t\tdurations[i] = time.Duration(x)\n\t\t\t}\n\t\t\ttab.Add(nicekey, durations)\n\t\t} else {\n\t\t\ttab.Add(nicekey, results[key])\n\t\t}\n\t\tresultCols = append(resultCols, nicekey)\n\t}\n\n\treturn tab.Done(), configCols, resultCols\n}\n\nfunc commitsToTable(commits []CommitInfo) *table.Table {\n\thashCol := make([]string, len(commits))\n\tauthorDateCol := make(byTime, len(commits))\n\tcommitDateCol := make(byTime, len(commits))\n\tbranchCol := make([]string, len(commits))\n\tj := 0\n\tfor i := range commits {\n\t\tci := &commits[i]\n\n\t\thashCol[j] = ci.Hash\n\t\tauthorDateCol[j] = ci.AuthorDate\n\t\tcommitDateCol[j] = ci.CommitDate\n\t\tbranchCol[j] = ci.Branch\n\t\tj++\n\t}\n\n\treturn new(table.Builder).\n\t\tAdd(\"commit\", hashCol).\n\t\tAdd(\"author date\", authorDateCol).\n\t\tAdd(\"commit date\", commitDateCol).\n\t\tAdd(\"branch\", branchCol).\n\t\tDone()\n}\n\ntype byTime []time.Time\n\nfunc (s byTime) Len() int {\n\treturn len(s)\n}\n\nfunc (s byTime) Less(i, j int) bool {\n\treturn s[i].Before(s[j])\n}\n\nfunc (s byTime) Swap(i, j int) {\n\ts[i], s[j] = s[j], s[i]\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/LICENSE", "content": "Copyright (c) 2016 The Go Authors. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are\nmet:\n\n * Redistributions of source code must retain the above copyright\nnotice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above\ncopyright notice, this list of conditions and the following disclaimer\nin the documentation and/or other materials provided with the\ndistribution.\n * Neither the name of Google Inc. nor the names of its\ncontributors may be used to endorse or promote products derived from\nthis software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\nLIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\nA PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\nOWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\nSPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\nLIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\nDATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\nTHEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/README.md", "content": "# gg [![](https://godoc.org/github.com/aclements/go-gg?status.svg)](https://godoc.org/github.com/aclements/go-gg)\n\ngg is a plotting package for Go inspired by the Grammar of Graphics.\n\nNote that gg is currently very experimental and the API is still in\nflux. Please vendor this package before using it.\n\nTo fetch gg, run\n\n go get github.com/aclements/go-gg\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/generic/doc.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// Package generic provides type-generic functions.\npackage generic\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/generic/error.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage generic\n\nimport \"reflect\"\n\ntype TypeError struct {\n\tType1, Type2 reflect.Type\n\tExtra string\n}\n\nfunc (e TypeError) Error() string {\n\tmsg := e.Type1.String()\n\tif e.Type2 != nil {\n\t\tmsg += \" and \" + e.Type2.String()\n\t}\n\tmsg += \" \" + e.Extra\n\treturn msg\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/generic/order.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage generic\n\nimport \"reflect\"\n\n// CanOrder returns whether the values a and b are orderable according\n// to the Go language specification.\nfunc CanOrder(a, b interface{}) bool {\n\tak, bk := reflect.ValueOf(a).Kind(), reflect.ValueOf(b).Kind()\n\tif ak != bk {\n\t\treturn false\n\t}\n\treturn CanOrderR(ak)\n}\n\nvar orderable = map[reflect.Kind]bool{\n\treflect.Int: true,\n\treflect.Int8: true,\n\treflect.Int16: true,\n\treflect.Int32: true,\n\treflect.Int64: true,\n\treflect.Uint: true,\n\treflect.Uintptr: true,\n\treflect.Uint8: true,\n\treflect.Uint16: true,\n\treflect.Uint32: true,\n\treflect.Uint64: true,\n\treflect.Float32: true,\n\treflect.Float64: true,\n\treflect.String: true,\n}\n\n// CanOrderR returns whether two values of kind k are orderable\n// according to the Go language specification.\nfunc CanOrderR(k reflect.Kind) bool {\n\treturn orderable[k]\n}\n\n// Order returns the order of values a and b: -1 if a < b, 0 if a ==\n// b, 1 if a > b. The results are undefined if either a or b is NaN.\n//\n// Order panics if a and b are not orderable according to the Go\n// language specification.\nfunc Order(a, b interface{}) int {\n\treturn OrderR(reflect.ValueOf(a), reflect.ValueOf(b))\n}\n\n// OrderR is equivalent to Order, but operates on reflect.Values.\nfunc OrderR(a, b reflect.Value) int {\n\tif a.Kind() != b.Kind() {\n\t\tpanic(&TypeError{a.Type(), b.Type(), \"are not orderable because they are different kinds\"})\n\t}\n\n\tswitch a.Kind() {\n\tcase reflect.Float32, reflect.Float64:\n\t\ta, b := a.Float(), b.Float()\n\t\tif a < b {\n\t\t\treturn -1\n\t\t} else if a > b {\n\t\t\treturn 1\n\t\t}\n\t\treturn 0\n\n\tcase reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:\n\t\ta, b := a.Int(), b.Int()\n\t\tif a < b {\n\t\t\treturn -1\n\t\t} else if a > b {\n\t\t\treturn 1\n\t\t}\n\t\treturn 0\n\n\tcase reflect.Uint, reflect.Uintptr, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:\n\t\ta, b := a.Uint(), b.Uint()\n\t\tif a < b {\n\t\t\treturn -1\n\t\t} else if a > b {\n\t\t\treturn 1\n\t\t}\n\t\treturn 0\n\n\tcase reflect.String:\n\t\ta, b := a.String(), b.String()\n\t\tif a < b {\n\t\t\treturn -1\n\t\t} else if a > b {\n\t\t\treturn 1\n\t\t}\n\t\treturn 0\n\t}\n\n\tpanic(&TypeError{a.Type(), nil, \"is not orderable\"})\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/generic/slice/concat.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage slice\n\nimport (\n\t\"reflect\"\n\n\t\"github.com/aclements/go-gg/generic\"\n)\n\n// Concat returns the concatenation of all of ss. The types of all of\n// the arguments must be identical or Concat will panic with a\n// *generic.TypeError. The returned slice will have the same type as the\n// inputs. If there are 0 arguments, Concat returns nil. Concat does\n// not modify any of the input slices.\nfunc Concat(ss ...T) T {\n\tif len(ss) == 0 {\n\t\treturn nil\n\t}\n\n\trvs := make([]reflect.Value, len(ss))\n\ttotal := 0\n\tvar typ reflect.Type\n\tfor i, s := range ss {\n\t\trvs[i] = reflectSlice(s)\n\t\ttotal += rvs[i].Len()\n\t\tif i == 0 {\n\t\t\ttyp = rvs[i].Type()\n\t\t} else if rvs[i].Type() != typ {\n\t\t\tpanic(&generic.TypeError{typ, rvs[i].Type(), \"have different types\"})\n\t\t}\n\t}\n\n\tout := reflect.MakeSlice(typ, 0, total)\n\tfor _, rv := range rvs {\n\t\tout = reflect.AppendSlice(out, rv)\n\t}\n\treturn out.Interface()\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/generic/slice/concat_test.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage slice\n\nimport \"testing\"\n\nfunc TestConcat(t *testing.T) {\n\tif g := Concat(); g != nil {\n\t\tt.Errorf(\"Concat() should be nil; got %v\", g)\n\t}\n\n\tif g, w := Concat([]int{}), []int{}; !de(w, g) {\n\t\tt.Errorf(\"want %v; got %v\", w, g)\n\t}\n\n\tif g, w := Concat([]int(nil)), []int{}; !de(w, g) {\n\t\tt.Errorf(\"want %v; got %v\", w, g)\n\t}\n\n\tif g, w := Concat([]int{1, 2}, []int{3, 4}), []int{1, 2, 3, 4}; !de(w, g) {\n\t\tt.Errorf(\"want %v; got %v\", w, g)\n\t}\n\n\tshouldPanic(t, \"have different types\", func() {\n\t\tConcat([]int{}, []string{})\n\t})\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/generic/slice/convert.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage slice\n\nimport (\n\t\"reflect\"\n\n\t\"github.com/aclements/go-gg/generic\"\n)\n\n// Convert converts each element in from and assigns it to *to. to\n// must be a pointer to a slice. Convert slices or extends *to to\n// len(from) and then assigns to[i] = T(from[i]) where T is the type\n// of *to's elements. If from and *to have the same element type, it\n// simply assigns *to = from.\nfunc Convert(to interface{}, from T) {\n\tfv := reflectSlice(from)\n\ttv := reflect.ValueOf(to)\n\tif tv.Kind() != reflect.Ptr {\n\t\tpanic(&generic.TypeError{tv.Type(), nil, \"is not a *[]T\"})\n\t}\n\ttst := tv.Type().Elem()\n\tif tst.Kind() != reflect.Slice {\n\t\tpanic(&generic.TypeError{tv.Type(), nil, \"is not a *[]T\"})\n\t}\n\n\tif fv.Type().AssignableTo(tst) {\n\t\ttv.Elem().Set(fv)\n\t\treturn\n\t}\n\n\teltt := tst.Elem()\n\tif !fv.Type().Elem().ConvertibleTo(eltt) {\n\t\tpanic(&generic.TypeError{fv.Type(), tst, \"cannot be converted\"})\n\t}\n\n\tswitch to := to.(type) {\n\tcase *[]float64:\n\t\t// This is extremely common.\n\t\t*to = (*to)[:0]\n\t\tfor i, len := 0, fv.Len(); i < len; i++ {\n\t\t\t*to = append(*to, fv.Index(i).Convert(eltt).Float())\n\t\t}\n\n\tdefault:\n\t\ttsv := tv.Elem()\n\t\ttsv.SetLen(0)\n\t\tfor i, len := 0, fv.Len(); i < len; i++ {\n\t\t\ttsv = reflect.Append(tsv, fv.Index(i).Convert(eltt))\n\t\t}\n\t\ttv.Elem().Set(tsv)\n\t}\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/generic/slice/convert_test.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage slice\n\nimport \"testing\"\n\nfunc TestConvert(t *testing.T) {\n\tvar is []int\n\tConvert(&is, []int{1, 2, 3})\n\tif w := []int{1, 2, 3}; !de(w, is) {\n\t\tt.Errorf(\"want %v; got %v\", w, is)\n\t}\n\tConvert(&is, []float64{1, 2, 3})\n\tif w := []int{1, 2, 3}; !de(w, is) {\n\t\tt.Errorf(\"want %v; got %v\", w, is)\n\t}\n\n\tvar fs []float64\n\tConvert(&fs, []int{1, 2, 3})\n\tif w := []float64{1, 2, 3}; !de(w, fs) {\n\t\tt.Errorf(\"want %v; got %v\", w, fs)\n\t}\n\tConvert(&fs, []float64{1, 2, 3})\n\tif w := []float64{1, 2, 3}; !de(w, fs) {\n\t\tt.Errorf(\"want %v; got %v\", w, fs)\n\t}\n\n\tshouldPanic(t, \"cannot be converted\", func() {\n\t\tConvert(&is, []string{\"1\", \"2\", \"3\"})\n\t})\n\tshouldPanic(t, `is not a \\*\\[\\]T`, func() {\n\t\tConvert(is, []int{1, 2, 3})\n\t})\n\tshouldPanic(t, `is not a \\*\\[\\]T`, func() {\n\t\tx := 1\n\t\tConvert(&x, []int{1, 2, 3})\n\t})\n\tshouldPanic(t, \"is not a slice\", func() {\n\t\tConvert(&is, 1)\n\t})\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/generic/slice/cycle.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage slice\n\nimport \"reflect\"\n\n// Cycle constructs a slice of length length by repeatedly\n// concatenating s to itself. If len(s) >= length, it returns\n// s[:length]. Otherwise, it allocates a new slice. If len(s) == 0 and\n// length != 0, Cycle panics.\nfunc Cycle(s T, length int) T {\n\trv := reflectSlice(s)\n\tif rv.Len() >= length {\n\t\treturn rv.Slice(0, length).Interface()\n\t}\n\n\tif rv.Len() == 0 {\n\t\tpanic(\"empty slice\")\n\t}\n\n\t// Allocate a new slice of the appropriate length.\n\tout := reflect.MakeSlice(rv.Type(), length, length)\n\n\t// Copy elements to out.\n\tfor pos := 0; pos < length; {\n\t\tpos += reflect.Copy(out.Slice(pos, length), rv)\n\t}\n\n\treturn out.Interface()\n}\n\n// Repeat returns a slice consisting of length copies of v.\nfunc Repeat(v interface{}, length int) T {\n\tif length < 0 {\n\t\tlength = 0\n\t}\n\trv := reflect.ValueOf(v)\n\tout := reflect.MakeSlice(reflect.SliceOf(rv.Type()), length, length)\n\tfor i := 0; i < length; i++ {\n\t\tout.Index(i).Set(rv)\n\t}\n\treturn out.Interface()\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/generic/slice/doc.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// Package slice provides generic slice functions.\npackage slice\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/generic/slice/find.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage slice\n\nimport (\n\t\"reflect\"\n\n\t\"github.com/aclements/go-gg/generic\"\n)\n\n// Index returns the index of the first instance of val in s, or -1 if\n// val is not present in s. val's type must be s's element type.\nfunc Index(s T, val interface{}) int {\n\trs := reflectSlice(s)\n\tif vt := reflect.TypeOf(val); rs.Type().Elem() != vt {\n\t\t// TODO: Better \" is not a sequence of \".\n\t\tpanic(&generic.TypeError{rs.Type(), vt, \"cannot find\"})\n\t}\n\n\tfor i, l := 0, rs.Len(); i < l; i++ {\n\t\tif rs.Index(i).Interface() == val {\n\t\t\treturn i\n\t\t}\n\t}\n\treturn -1\n}\n\n// LastIndex returns the index of the last instance of val in s, or -1\n// if val is not present in s. val's type must be s's element type.\nfunc LastIndex(s T, val interface{}) int {\n\trs := reflectSlice(s)\n\tif vt := reflect.TypeOf(val); rs.Type().Elem() != vt {\n\t\t// TODO: Better \" is not a sequence of \".\n\t\tpanic(&generic.TypeError{rs.Type(), vt, \"cannot find\"})\n\t}\n\n\tfor i := rs.Len() - 1; i >= 0; i-- {\n\t\tif rs.Index(i).Interface() == val {\n\t\t\treturn i\n\t\t}\n\t}\n\treturn -1\n}\n\n// Contains reports whether val is within s. val's type must be s's\n// element type.\nfunc Contains(s T, val interface{}) bool {\n\treturn Index(s, val) >= 0\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/generic/slice/index.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage slice\n\nimport (\n\t\"reflect\"\n\n\t\"github.com/aclements/go-gg/generic\"\n)\n\n// Select returns a slice w such that w[i] = v[indexes[i]].\nfunc Select(v T, indexes []int) T {\n\tswitch v := v.(type) {\n\tcase []int:\n\t\tres := make([]int, len(indexes))\n\t\tfor i, x := range indexes {\n\t\t\tres[i] = v[x]\n\t\t}\n\t\treturn res\n\n\tcase []float64:\n\t\tres := make([]float64, len(indexes))\n\t\tfor i, x := range indexes {\n\t\t\tres[i] = v[x]\n\t\t}\n\t\treturn res\n\n\tcase []string:\n\t\tres := make([]string, len(indexes))\n\t\tfor i, x := range indexes {\n\t\t\tres[i] = v[x]\n\t\t}\n\t\treturn res\n\t}\n\n\trv := reflectSlice(v)\n\tres := reflect.MakeSlice(rv.Type(), len(indexes), len(indexes))\n\tfor i, x := range indexes {\n\t\tres.Index(i).Set(rv.Index(x))\n\t}\n\treturn res.Interface()\n}\n\n// SelectInto assigns out[i] = in[indexes[i]]. in and out must have\n// the same types and len(out) must be >= len(indexes). If in and out\n// overlap, the results are undefined.\nfunc SelectInto(out, in T, indexes []int) {\n\t// TODO: Maybe they should only have to be assignable?\n\tif it, ot := reflect.TypeOf(in), reflect.TypeOf(out); it != ot {\n\t\tpanic(&generic.TypeError{it, ot, \"must be the same type\"})\n\t}\n\n\tswitch in := in.(type) {\n\tcase []int:\n\t\tout := out.([]int)\n\t\tfor i, x := range indexes {\n\t\t\tout[i] = in[x]\n\t\t}\n\t\treturn\n\n\tcase []float64:\n\t\tout := out.([]float64)\n\t\tfor i, x := range indexes {\n\t\t\tout[i] = in[x]\n\t\t}\n\t\treturn\n\n\tcase []string:\n\t\tout := out.([]string)\n\t\tfor i, x := range indexes {\n\t\t\tout[i] = in[x]\n\t\t}\n\t\treturn\n\t}\n\n\tinv, outv := reflectSlice(in), reflectSlice(out)\n\tfor i, x := range indexes {\n\t\toutv.Index(i).Set(inv.Index(x))\n\t}\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/generic/slice/min.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage slice\n\nimport (\n\t\"reflect\"\n\t\"sort\"\n\n\t\"github.com/aclements/go-gg/generic\"\n)\n\n// Min returns the minimum value in v. v must either implement\n// sort.Interface or its elements must be orderable. Min panics if v\n// is empty.\nfunc Min(v T) interface{} {\n\tx, _ := minmax(v, -1, true)\n\treturn x.Interface()\n}\n\n// ArgMin returns the index of the minimum value in v. If there are\n// multiple indexes equal to the minimum value, ArgMin returns the\n// lowest of them. v must be a slice whose elements are orderable, or\n// must implement sort.Interface. ArgMin panics if v is empty.\nfunc ArgMin(v interface{}) int {\n\t_, i := minmax(v, -1, false)\n\treturn i\n}\n\n// Max returns the maximum value in v. v must either implement\n// sort.Interface or its elements must be orderable. Max panics if v\n// is empty.\nfunc Max(v T) interface{} {\n\tx, _ := minmax(v, 1, true)\n\treturn x.Interface()\n}\n\n// ArgMax returns the index of the maximum value in v. If there are\n// multiple indexes equal to the maximum value, ArgMax returns the\n// lowest of them. v must be a slice whose elements are orderable, or\n// must implement sort.Interface. ArgMax panics if v is empty.\nfunc ArgMax(v interface{}) int {\n\t_, i := minmax(v, 1, false)\n\treturn i\n}\n\nfunc minmax(v interface{}, keep int, val bool) (reflect.Value, int) {\n\tswitch v := v.(type) {\n\tcase sort.Interface:\n\t\tif v.Len() == 0 {\n\t\t\tif keep < 0 {\n\t\t\t\tpanic(\"zero-length sequence has no minimum\")\n\t\t\t} else {\n\t\t\t\tpanic(\"zero-length sequence has no maximum\")\n\t\t\t}\n\t\t}\n\t\tmaxi := 0\n\t\tif keep < 0 {\n\t\t\tfor i, len := 0, v.Len(); i < len; i++ {\n\t\t\t\tif v.Less(i, maxi) {\n\t\t\t\t\tmaxi = i\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tfor i, len := 0, v.Len(); i < len; i++ {\n\t\t\t\tif v.Less(maxi, i) {\n\t\t\t\t\tmaxi = i\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif !val {\n\t\t\treturn reflect.Value{}, maxi\n\t\t}\n\n\t\trv := reflectSlice(v)\n\t\treturn rv.Index(maxi), maxi\n\t}\n\n\trv := reflectSlice(v)\n\tif !generic.CanOrderR(rv.Type().Elem().Kind()) {\n\t\tpanic(&generic.TypeError{rv.Type().Elem(), nil, \"is not orderable\"})\n\t}\n\tif rv.Len() == 0 {\n\t\tif keep < 0 {\n\t\t\tpanic(\"zero-length slice has no minimum\")\n\t\t} else {\n\t\t\tpanic(\"zero-length slice has no maximum\")\n\t\t}\n\t}\n\tmax, maxi := rv.Index(0), 0\n\tfor i, len := 1, rv.Len(); i < len; i++ {\n\t\tif elt := rv.Index(i); generic.OrderR(elt, max) == keep {\n\t\t\tmax, maxi = elt, i\n\t\t}\n\t}\n\treturn max, maxi\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/generic/slice/min_test.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage slice\n\nimport (\n\t\"math\"\n\t\"testing\"\n\t\"time\"\n)\n\nfunc TestMin(t *testing.T) {\n\tshouldPanic(t, \"no min\", func() { Min([]float64{}) })\n\tshouldPanic(t, \"no min\", func() { ArgMin([]float64{}) })\n\tshouldPanic(t, \"no max\", func() { Max([]float64{}) })\n\tshouldPanic(t, \"no max\", func() { ArgMax([]float64{}) })\n\n\txs := []float64{5, 1, 8, 1, 8, 3}\n\tif x := Min(xs); x != 1.0 {\n\t\tt.Errorf(\"Min should be 1, got %v\", x)\n\t}\n\tif x := ArgMin(xs); x != 1 {\n\t\tt.Errorf(\"ArgMin should be 1, got %v\", x)\n\t}\n\tif x := Max(xs); x != 8.0 {\n\t\tt.Errorf(\"Max should be 8, got %v\", x)\n\t}\n\tif x := ArgMax(xs); x != 2 {\n\t\tt.Errorf(\"ArgMax should be 2, got %v\", x)\n\t}\n\n\txs = []float64{1, 5, math.NaN()}\n\tif x := Min(xs); x != 1.0 {\n\t\tt.Errorf(\"Min should be 1, got %v\", x)\n\t}\n\tif x := Max(xs); x != 5.0 {\n\t\tt.Errorf(\"Max should be 5, got %v\", x)\n\t}\n}\n\ntype fakeSortInterface struct {\n\tlen int\n}\n\nfunc (f fakeSortInterface) Len() int {\n\treturn f.len\n}\n\nfunc (f fakeSortInterface) Swap(i, j int) {\n\tpanic(\"can't\")\n}\n\nfunc (f fakeSortInterface) Less(i, j int) bool {\n\treturn i < j\n}\n\ntype timeSlice []time.Time\n\nfunc (s timeSlice) Len() int {\n\treturn len(s)\n}\n\nfunc (s timeSlice) Less(i, j int) bool {\n\treturn s[i].Before(s[j])\n}\n\nfunc (s timeSlice) Swap(i, j int) {\n\ts[i], s[j] = s[j], s[i]\n}\n\nfunc TestMinSort(t *testing.T) {\n\tshouldPanic(t, \"no min\", func() { Min(fakeSortInterface{0}) })\n\tshouldPanic(t, \"no min\", func() { ArgMin(fakeSortInterface{0}) })\n\tshouldPanic(t, \"no max\", func() { Max(fakeSortInterface{0}) })\n\tshouldPanic(t, \"no max\", func() { ArgMax(fakeSortInterface{0}) })\n\n\tf := fakeSortInterface{5}\n\tif x := ArgMin(f); x != 0 {\n\t\tt.Errorf(\"ArgMin should be 0, got %v\", x)\n\t}\n\tif x := ArgMax(f); x != 4 {\n\t\tt.Errorf(\"ArgMax should be 4, got %v\", x)\n\t}\n\n\tz := time.Unix(0, 0)\n\tts := timeSlice{z.Add(time.Hour), z, z.Add(2 * time.Hour), z.Add(time.Hour)}\n\tif x := Min(ts); x != ts[1] {\n\t\tt.Errorf(\"Min should be %v, got %v\", ts[1], x)\n\t}\n\tif x := ArgMin(ts); x != 1 {\n\t\tt.Errorf(\"ArgMin should be 1, got %v\", x)\n\t}\n\tif x := Max(ts); x != ts[2] {\n\t\tt.Errorf(\"Max should be %v, got %v\", ts[2], x)\n\t}\n\tif x := ArgMax(ts); x != 2 {\n\t\tt.Errorf(\"ArgMax should be 2, got %v\", x)\n\t}\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/generic/slice/nub.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage slice\n\nimport \"reflect\"\n\nvar trueVal = reflect.ValueOf(true)\n\n// Nub returns v with duplicates removed. It keeps the first instance\n// of each distinct value and preserves their order.\nfunc Nub(v T) T {\n\trv := reflectSlice(v)\n\tindexes := make([]int, 0)\n\tset := reflect.MakeMap(reflect.MapOf(rv.Type().Elem(), trueVal.Type()))\n\tfor i, l := 0, rv.Len(); i < l; i++ {\n\t\tx := rv.Index(i)\n\t\tif set.MapIndex(x).IsValid() {\n\t\t\tcontinue\n\t\t}\n\t\tset.SetMapIndex(x, trueVal)\n\t\tindexes = append(indexes, i)\n\t}\n\treturn Select(v, indexes)\n}\n\n// NubAppend is equivalent to appending all of the slices in vs and\n// then calling Nub on the result, but more efficient.\nfunc NubAppend(vs ...T) T {\n\tif len(vs) == 0 {\n\t\treturn nil\n\t}\n\n\trv := reflectSlice(vs[0])\n\tset := reflect.MakeMap(reflect.MapOf(rv.Type().Elem(), trueVal.Type()))\n\tout := reflect.MakeSlice(rv.Type(), 0, 0)\n\n\tfor _, v := range vs {\n\t\trv := reflectSlice(v)\n\t\tfor i, l := 0, rv.Len(); i < l; i++ {\n\t\t\tx := rv.Index(i)\n\t\t\tif set.MapIndex(x).IsValid() {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tset.SetMapIndex(x, trueVal)\n\t\t\tout = reflect.Append(out, x)\n\t\t}\n\t}\n\n\treturn out.Interface()\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/generic/slice/select_test.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage slice\n\nimport (\n\t\"reflect\"\n\t\"testing\"\n)\n\nfunc TestSelect(t *testing.T) {\n\tx1 := []int{1, 2, 3}\n\tgot := Select(x1, []int{2, 1, 0})\n\tif want := []int{3, 2, 1}; !reflect.DeepEqual(got, want) {\n\t\tt.Fatalf(\"expected %v, got %v\", want, got)\n\t}\n\tgot = Select(x1, []int{1, 1, 1, 1})\n\tif want := []int{2, 2, 2, 2}; !reflect.DeepEqual(got, want) {\n\t\tt.Fatalf(\"expected %v, got %v\", want, got)\n\t}\n\n\ttype T struct{ x int }\n\tx2 := []T{{1}, {2}, {3}}\n\tgot = Select(x2, []int{2, 1, 0})\n\tif want := []T{{3}, {2}, {1}}; !reflect.DeepEqual(got, want) {\n\t\tt.Fatalf(\"expected %v, got %v\", want, got)\n\t}\n}\n\nfunc TestSelectType(t *testing.T) {\n\ttype T []float64\n\tx1 := T{1, 2, 3}\n\ty1 := Select(x1, []int{})\n\tif _, ok := y1.(T); !ok {\n\t\tt.Fatalf(\"result has wrong type; expected T, got %T\", y1)\n\t}\n\n\ttype U int\n\tx2 := []U{1, 2, 3}\n\ty2 := Select(x2, []int{})\n\tif _, ok := y2.([]U); !ok {\n\t\tt.Fatalf(\"result has wrong type; expected []U, got %T\", y2)\n\t}\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/generic/slice/seq.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage slice\n\nimport (\n\t\"reflect\"\n\n\t\"github.com/aclements/go-gg/generic\"\n)\n\n// T is a Go slice value of type []U.\n//\n// This is primarily for documentation. There is no way to statically\n// enforce this in Go; however, functions that expect a slice will\n// panic with a *generic.TypeError if passed a non-slice value.\ntype T interface{}\n\n// reflectSlice checks that s is a slice and returns its\n// reflect.Value. It panics with a *generic.TypeError if s is not a slice.\nfunc reflectSlice(s T) reflect.Value {\n\trv := reflect.ValueOf(s)\n\tif rv.Kind() != reflect.Slice {\n\t\tpanic(&generic.TypeError{rv.Type(), nil, \"is not a slice\"})\n\t}\n\treturn rv\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/generic/slice/sort.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage slice\n\nimport (\n\t\"reflect\"\n\t\"sort\"\n\t\"time\"\n\n\t\"github.com/aclements/go-gg/generic\"\n)\n\n// CanSort returns whether the value v can be sorted.\nfunc CanSort(v interface{}) bool {\n\tswitch v.(type) {\n\tcase sort.Interface, []time.Time:\n\t\treturn true\n\t}\n\treturn generic.CanOrderR(reflect.TypeOf(v).Elem().Kind())\n}\n\n// Sort sorts v in increasing order. v must implement sort.Interface,\n// be a slice whose elements are orderable, or be a []time.Time.\nfunc Sort(v interface{}) {\n\tsort.Sort(Sorter(v))\n}\n\n// Sorter returns a sort.Interface for sorting v. v must implement\n// sort.Interface, be a slice whose elements are orderable, or be a\n// []time.Time.\nfunc Sorter(v interface{}) sort.Interface {\n\tswitch v := v.(type) {\n\tcase []int:\n\t\treturn sort.IntSlice(v)\n\tcase []float64:\n\t\treturn sort.Float64Slice(v)\n\tcase []string:\n\t\treturn sort.StringSlice(v)\n\tcase []time.Time:\n\t\treturn sortTimeSlice(v)\n\tcase sort.Interface:\n\t\treturn v\n\t}\n\n\trv := reflectSlice(v)\n\tswitch rv.Type().Elem().Kind() {\n\tcase reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:\n\t\treturn sortIntSlice{rv}\n\tcase reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:\n\t\treturn sortUintSlice{rv}\n\tcase reflect.Float32, reflect.Float64:\n\t\treturn sortFloatSlice{rv}\n\tcase reflect.String:\n\t\treturn sortStringSlice{rv}\n\t}\n\tpanic(&generic.TypeError{rv.Type().Elem(), nil, \"is not orderable\"})\n}\n\ntype sortIntSlice struct {\n\treflect.Value\n}\n\nfunc (s sortIntSlice) Len() int {\n\treturn s.Value.Len()\n}\n\nfunc (s sortIntSlice) Less(i, j int) bool {\n\treturn s.Index(i).Int() < s.Index(j).Int()\n}\n\nfunc (s sortIntSlice) Swap(i, j int) {\n\ta, b := s.Index(i).Int(), s.Index(j).Int()\n\ts.Index(i).SetInt(b)\n\ts.Index(j).SetInt(a)\n}\n\ntype sortUintSlice struct {\n\treflect.Value\n}\n\nfunc (s sortUintSlice) Len() int {\n\treturn s.Value.Len()\n}\n\nfunc (s sortUintSlice) Less(i, j int) bool {\n\treturn s.Index(i).Uint() < s.Index(j).Uint()\n}\n\nfunc (s sortUintSlice) Swap(i, j int) {\n\ta, b := s.Index(i).Uint(), s.Index(j).Uint()\n\ts.Index(i).SetUint(b)\n\ts.Index(j).SetUint(a)\n}\n\ntype sortFloatSlice struct {\n\treflect.Value\n}\n\nfunc (s sortFloatSlice) Len() int {\n\treturn s.Value.Len()\n}\n\nfunc (s sortFloatSlice) Less(i, j int) bool {\n\treturn s.Index(i).Float() < s.Index(j).Float()\n}\n\nfunc (s sortFloatSlice) Swap(i, j int) {\n\ta, b := s.Index(i).Float(), s.Index(j).Float()\n\ts.Index(i).SetFloat(b)\n\ts.Index(j).SetFloat(a)\n}\n\ntype sortStringSlice struct {\n\treflect.Value\n}\n\nfunc (s sortStringSlice) Len() int {\n\treturn s.Value.Len()\n}\n\nfunc (s sortStringSlice) Less(i, j int) bool {\n\treturn s.Index(i).String() < s.Index(j).String()\n}\n\nfunc (s sortStringSlice) Swap(i, j int) {\n\ta, b := s.Index(i).String(), s.Index(j).String()\n\ts.Index(i).SetString(b)\n\ts.Index(j).SetString(a)\n}\n\ntype sortTimeSlice []time.Time\n\nfunc (s sortTimeSlice) Len() int { return len(s) }\nfunc (s sortTimeSlice) Less(i, j int) bool { return s[i].Before(s[j]) }\nfunc (s sortTimeSlice) Swap(i, j int) { s[i], s[j] = s[j], s[i] }\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/generic/slice/util_test.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage slice\n\nimport (\n\t\"fmt\"\n\t\"reflect\"\n\t\"regexp\"\n\t\"testing\"\n)\n\nfunc de(x, y interface{}) bool {\n\treturn reflect.DeepEqual(x, y)\n}\n\nfunc shouldPanic(t *testing.T, re string, f func()) {\n\tr := regexp.MustCompile(re)\n\tdefer func() {\n\t\terr := recover()\n\t\tif err == nil {\n\t\t\tt.Fatalf(\"want panic matching %q; got no panic\", re)\n\t\t} else if !r.MatchString(fmt.Sprintf(\"%s\", err)) {\n\t\t\tt.Fatalf(\"want panic matching %q; got %s\", re, err)\n\t\t}\n\t}()\n\tf()\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/gg/example_scale_test.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage gg\n\nimport (\n\t\"fmt\"\n\t\"math/rand\"\n\t\"os\"\n\t\"time\"\n\n\t\"github.com/aclements/go-gg/table\"\n)\n\nfunc ExampleNewTimeScaler() {\n\tvar x []time.Time\n\tvar y []float64\n\tvar steps []time.Duration\n\tfor _, step := range []time.Duration{\n\t\t1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,\n\t\ttime.Minute, time.Hour, 24 * time.Hour, 7 * 24 * time.Hour,\n\t} {\n\t\tt := time.Now()\n\t\tfor i := 0; i < 100; i++ {\n\t\t\tx = append(x, t)\n\t\t\ty = append(y, rand.Float64()-.5)\n\t\t\tsteps = append(steps, 100*step)\n\t\t\tt = t.Add(-step)\n\t\t}\n\t}\n\n\ttb := table.NewBuilder(nil)\n\ttb.Add(\"x\", x).Add(\"y\", y).Add(\"steps\", steps)\n\n\tplot := NewPlot(tb.Done())\n\n\tplot.SetScale(\"x\", NewTimeScaler())\n\n\tplot.Add(FacetY{\n\t\tCol: \"steps\",\n\t\tSplitXScales: true,\n\t})\n\n\tplot.Add(LayerLines{\n\t\tX: \"x\",\n\t\tY: \"y\",\n\t})\n\n\tf, err := os.Create(\"scale_time.svg\")\n\tif err != nil {\n\t\tpanic(\"unable to create scale_time.svg\")\n\t}\n\tdefer f.Close()\n\tplot.WriteSVG(f, 800, 1000)\n\tfmt.Println(\"ok\")\n\t// output:\n\t// ok\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/gg/facet.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage gg\n\nimport (\n\t\"fmt\"\n\t\"math\"\n\t\"reflect\"\n\n\t\"github.com/aclements/go-gg/generic\"\n\t\"github.com/aclements/go-gg/generic/slice\"\n\t\"github.com/aclements/go-gg/table\"\n)\n\n// TODO: What if there are already layers? Maybe they should be\n// repeated in all facets. ggplot2 apparently does this when the\n// faceting variable isn't in one of the data frames.\n\n// TODO: Subplot is getting rather complicated. If I want to make\n// facets only use public APIs, perhaps gg itself should only know\n// about some interface for table group labels that provides a layout\n// manager and the layout logic should live with the facets.\n\n// TODO: This is very nearly flexible enough to make pairwise plots.\n\n// TODO: Is this flexible enough to make marginal distribution plots?\n\n// TODO: There's logical overlap between how a facet chooses to\n// position and label a subplot and a discrete-ranged scalar. Perhaps\n// facets should use scalars to chose positions and labels?\n\n// FacetCommon is the base type for plot faceting operations. Faceting\n// is a grouping operation that subdivides a plot into subplots based\n// on the values in data column. Faceting operations may be composed:\n// if a faceting operation has already divided the plot into subplots,\n// a further faceting operation will subdivide each of those subplots.\ntype FacetCommon struct {\n\t// Col names the column to facet by. Each distinct value of\n\t// this column will become a separate plot. If Col is\n\t// orderable, the facets will be in value order; otherwise,\n\t// they will be in index order.\n\tCol string\n\n\t// SplitXScales indicates that each band (column for FacetX;\n\t// row for FacetY) created by this faceting operation should\n\t// have separate X axis scales. The default, false, indicates\n\t// that subplots should continue to share X scales.\n\t//\n\t// SplitXScales and SplitYScales, combined with facet\n\t// composition, give a great deal of control over how scales\n\t// are shared. Suppose you want to create an X/Y facet grid by\n\t// first performing a FacetX and then a FacetY. Here are some\n\t// common ways to share or split the scales:\n\t//\n\t// * To share the same scales between all subplots, set both\n\t// flags to false in both facet operations.\n\t//\n\t// * To have independent scales in all subplots, set both\n\t// flags to true in the FacetY (and it doesn't matter what\n\t// they are in the FacetX).\n\t//\n\t// * To share the X scale within each column and the Y scale\n\t// within each row, set SplitXScales in the FacetX and\n\t// SplitYScales in the FacetY.\n\tSplitXScales bool\n\n\t// SplitYScales is the equivalent of SplitXScales for Y axis\n\t// scales.\n\tSplitYScales bool\n\n\t// Labeler is a function that constructs facet labels from\n\t// data values. If this is nil, the default is fmt.Sprint.\n\t//\n\t// TODO: Call this through reflect to get the argument type\n\t// right?\n\tLabeler func(interface{}) string\n\n\t// Rows and Cols specify the number of rows or columns for\n\t// FacetWrap. If both are zero, FacetWrap chooses reasonable\n\t// defaults. Otherwise, one or the other should be zero.\n\tRows, Cols int\n\n\t// TODO: Wrap order and label side for FacetWrap.\n}\n\n// FacetX splits a plot into columns.\ntype FacetX FacetCommon\n\n// FacetY splits a plot into rows.\ntype FacetY FacetCommon\n\n// FacetWrap splits a plot into a grid of rows and columns.\ntype FacetWrap FacetCommon\n\nfunc (f FacetX) Apply(p *Plot) {\n\t(*FacetCommon)(&f).apply(p, \"x\")\n}\n\nfunc (f FacetY) Apply(p *Plot) {\n\t(*FacetCommon)(&f).apply(p, \"y\")\n}\n\nfunc (f FacetWrap) Apply(p *Plot) {\n\t(*FacetCommon)(&f).apply(p, \"-\")\n}\n\nfunc (f *FacetCommon) apply(p *Plot, dir string) {\n\tif f.Labeler == nil {\n\t\tf.Labeler = func(x interface{}) string { return fmt.Sprint(x) }\n\t}\n\n\tgrouped := table.GroupBy(p.Data(), f.Col)\n\n\t// TODO: What should this do if there are multiple faceting\n\t// operations and the results aren't a complete cross-product?\n\t// Using GroupBy to form the initial faceting groups will\n\t// leave out subplots with no data. Alternatively, I could\n\t// base this on the total set of values and force there to be\n\t// a complete cross-product.\n\n\t// TODO: If this is, say, and X faceting and different\n\t// existing columns have different sets of values, should I\n\t// only split a column on the values it has? Doing that right\n\t// would require grouping existing subplots in potentially\n\t// complex ways (for example, if I do a FacetWrap and then a\n\t// FacetX, grouping subplots by column alone will be wrong.)\n\n\t// Collect grouped values. If there was already grouping\n\t// structure, it's possible we'll have multiple groups with\n\t// the same value for Col.\n\ttype valInfo struct {\n\t\tindex int\n\t\tlabel string\n\t}\n\tvar valType reflect.Type\n\tvals := make(map[interface{}]*valInfo)\n\tfor i, gid := range grouped.Tables() {\n\t\tval := gid.Label()\n\t\tif _, ok := vals[val]; !ok {\n\t\t\tvals[val] = &valInfo{len(vals), f.Labeler(val)}\n\t\t}\n\t\tif i == 0 {\n\t\t\tvalType = reflect.TypeOf(val)\n\t\t}\n\t}\n\n\t// If f.Col is orderable, order and re-index values.\n\tif generic.CanOrderR(valType.Kind()) {\n\t\tvalSeq := reflect.MakeSlice(reflect.SliceOf(valType), 0, len(vals))\n\t\tfor val := range vals {\n\t\t\tvalSeq = reflect.Append(valSeq, reflect.ValueOf(val))\n\t\t}\n\t\tslice.Sort(valSeq.Interface())\n\t\tfor i := 0; i < valSeq.Len(); i++ {\n\t\t\tvals[valSeq.Index(i).Interface()].index = i\n\t\t}\n\t}\n\n\t// Compute FacetWrap rows and cols.\n\tif dir == \"-\" {\n\t\tcells := float64(len(vals))\n\t\tif f.Cols == 0 {\n\t\t\tif f.Rows == 0 {\n\t\t\t\t// Chose default Rows and Cols.\n\t\t\t\tf.Rows = int(math.Ceil(math.Sqrt(cells)))\n\t\t\t}\n\t\t\t// Compute Cols from Rows.\n\t\t\tf.Cols = int(math.Ceil(cells / float64(f.Rows)))\n\t\t} else {\n\t\t\t// Compute Rows from Cols.\n\t\t\tf.Rows = int(math.Ceil(cells / float64(f.Cols)))\n\t\t}\n\t}\n\n\t// Find existing subplots, split existing subplots and bands\n\t// into len(vals) new subplots and bands, and transform each\n\t// GroupBy group into its new subplot.\n\ttype bandKey struct {\n\t\t// band1 is the primary band. band2 is only used by\n\t\t// FacetWrap.\n\t\tband1, band2 *subplotBand\n\n\t\t// X and Y of band. This is a necessary part of the\n\t\t// key because FacetWrap creates rows but does not\n\t\t// create distant horizontal bands for them.\n\t\tx, y int\n\t}\n\ttype bandScale struct {\n\t\tband *subplotBand\n\t\tscale Scaler\n\t}\n\tsubplots := make(map[*subplot][]*subplot)\n\tbands := make(map[bandKey][]*subplotBand)\n\tscales := make(map[bandScale]Scaler)\n\tvar ndata table.GroupingBuilder\n\tfor _, gid := range grouped.Tables() {\n\t\t// Find subplot by walking up group hierarchy.\n\t\tsub := subplotOf(gid)\n\n\t\t// Split old band into len(vals) new bands in the\n\t\t// orthogonal axis.\n\t\tvar obandKey bandKey\n\t\tif dir == \"x\" {\n\t\t\tobandKey = bandKey{band1: sub.vBand, x: sub.x}\n\t\t} else if dir == \"y\" {\n\t\t\tobandKey = bandKey{band1: sub.hBand, y: sub.y}\n\t\t} else {\n\t\t\tobandKey = bandKey{sub.vBand, sub.hBand, sub.x, sub.y}\n\t\t}\n\t\tnbands := bands[obandKey]\n\t\tif nbands == nil {\n\t\t\tnbands = make([]*subplotBand, len(vals))\n\t\t\tfor _, val := range vals {\n\t\t\t\tnb := &subplotBand{parent: obandKey.band1, label: val.label}\n\t\t\t\tnbands[val.index] = nb\n\t\t\t}\n\t\t\tbands[obandKey] = nbands\n\t\t}\n\n\t\t// Split old subplot into len(vals) new subplots.\n\t\tnsubplots := subplots[sub]\n\t\tif nsubplots == nil {\n\t\t\tnsubplots = make([]*subplot, len(vals))\n\t\t\tfor _, val := range vals {\n\t\t\t\tns := &subplot{parent: sub, x: sub.x, y: sub.y,\n\t\t\t\t\tvBand: sub.vBand, hBand: sub.hBand}\n\t\t\t\tif dir == \"x\" {\n\t\t\t\t\tns.x = sub.x*len(vals) + val.index\n\t\t\t\t\tns.vBand = nbands[val.index]\n\t\t\t\t} else if dir == \"y\" {\n\t\t\t\t\tns.y = sub.y*len(vals) + val.index\n\t\t\t\t\tns.hBand = nbands[val.index]\n\t\t\t\t} else {\n\t\t\t\t\tns.x = sub.x*f.Cols + val.index%f.Cols\n\t\t\t\t\tns.y = sub.y*f.Rows + val.index/f.Cols\n\t\t\t\t\tns.vBand = nbands[val.index]\n\t\t\t\t}\n\t\t\t\tnsubplots[val.index] = ns\n\t\t\t}\n\t\t\tsubplots[sub] = nsubplots\n\t\t}\n\n\t\t// Map this group to its new subplot.\n\t\tnsubplot := nsubplots[vals[gid.Label()].index]\n\t\tngid := gid.Parent().Extend(nsubplot)\n\t\tndata.Add(ngid, grouped.Table(gid))\n\n\t\t// Split scales if requested. At a high level, we want\n\t\t// to give each band a new scale, but there may\n\t\t// already be multiple scales within a band, so we\n\t\t// find the set of scales within a band and split each\n\t\t// distinct scale up.\n\t\tvar nband *subplotBand\n\t\tif dir == \"x\" {\n\t\t\tnband = nsubplot.vBand\n\t\t} else if dir == \"y\" {\n\t\t\tnband = nsubplot.hBand\n\t\t} else {\n\t\t\tif f.SplitXScales || f.SplitYScales {\n\t\t\t\t// TODO: I probably need to rephrase\n\t\t\t\t// this whole scale splitting\n\t\t\t\t// operation in terms of subplot X and\n\t\t\t\t// Y and possibly do it as a second\n\t\t\t\t// pass once all of the subplots are\n\t\t\t\t// created.\n\t\t\t\tpanic(\"not implemented: scale splitting for FacetWrap\")\n\t\t\t}\n\t\t}\n\t\tif f.SplitXScales {\n\t\t\tscaler := p.GetScaleAt(\"x\", gid)\n\t\t\tnscaler := scales[bandScale{nband, scaler}]\n\t\t\tif nscaler == nil {\n\t\t\t\tnscaler = scaler.CloneScaler()\n\t\t\t\tscales[bandScale{nband, scaler}] = nscaler\n\t\t\t}\n\t\t\tp.SetScaleAt(\"x\", nscaler, ngid)\n\t\t}\n\t\tif f.SplitYScales {\n\t\t\tscaler := p.GetScaleAt(\"y\", gid)\n\t\t\tnscaler := scales[bandScale{nband, scaler}]\n\t\t\tif nscaler == nil {\n\t\t\t\tnscaler = scaler.CloneScaler()\n\t\t\t\tscales[bandScale{nband, scaler}] = nscaler\n\t\t\t}\n\t\t\tp.SetScaleAt(\"y\", nscaler, ngid)\n\t\t}\n\t}\n\n\tp.SetData(ndata.Done())\n}\n\n// subplotBand represents a rectangular group of subplots in either a\n// vertical group (with a label on top) or a horizontal group (with a\n// label to the right).\ntype subplotBand struct {\n\tparent *subplotBand\n\tlabel string\n}\n\ntype subplot struct {\n\tparent *subplot\n\n\t// x and y are the position of this subplot, where 0, 0 is the\n\t// top left.\n\tx, y int\n\n\tvBand, hBand *subplotBand\n}\n\nvar rootSubplot = &subplot{}\n\nfunc subplotOf(gid table.GroupID) *subplot {\n\tfor ; gid != table.RootGroupID; gid = gid.Parent() {\n\t\tsub, ok := gid.Label().(*subplot)\n\t\tif ok {\n\t\t\treturn sub\n\t\t}\n\t}\n\treturn rootSubplot\n}\n\nfunc (s subplot) String() string {\n\treturn fmt.Sprintf(\"[%d %d]\", s.x, s.y)\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/gg/group.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage gg\n\nimport \"github.com/aclements/go-gg/table\"\n\n// TODO: GroupByKey? Would the key function only work on one binding?\n// With a first-class row representation we could pass that.\n\n// GroupBy sub-divides all groups such that all of the rows in each\n// group have equal values for all of the named columns.\nfunc (p *Plot) GroupBy(cols ...string) *Plot {\n\t// TODO: Should this accept column expressions, like layers?\n\treturn p.SetData(table.GroupBy(p.Data(), cols...))\n}\n\n// GroupAuto groups p's data table on all columns that are comparable\n// but are not numeric (that is, all categorical columns).\n//\n// TODO: Maybe there should be a CategoricalBindings that returns the\n// set of categorical bindings, which callers could just pass to\n// GroupBy, possibly after manipulating.\n//\n// TODO: Does implementing sort.Interface make an otherwise cardinal\n// column ordinal?\nfunc (p *Plot) GroupAuto() *Plot {\n\t// Find the categorical columns.\n\tcategorical := []string{}\n\tg := p.Data()\n\tfor _, col := range g.Columns() {\n\t\tet := table.ColType(g, col).Elem()\n\t\tif et.Comparable() && !isCardinal(et.Kind()) {\n\t\t\tcategorical = append(categorical, col)\n\t\t}\n\t}\n\n\treturn p.GroupBy(categorical...)\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/gg/layer.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage gg\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/aclements/go-gg/table\"\n)\n\nfunc defaultCols(p *Plot, cols ...*string) {\n\tdcols := p.Data().Columns()\n\tfor i, colp := range cols {\n\t\tif *colp == \"\" {\n\t\t\tif i >= len(dcols) {\n\t\t\t\tpanic(fmt.Sprintf(\"cannot get default column %d; table has only %d columns\", i, len(dcols)))\n\t\t\t}\n\t\t\t*colp = dcols[i]\n\t\t}\n\t}\n}\n\n// LayerLines is like LayerPaths, but connects data points in order by\n// the \"x\" property.\ntype LayerLines LayerPaths\n\nfunc (l LayerLines) Apply(p *Plot) {\n\tLayerPaths(l).apply(p, true)\n}\n\n//go:generate stringer -type StepMode\n\n// StepMode controls how LayerSteps connects subsequent points.\ntype StepMode int\n\nconst (\n\t// StepHV makes LayerSteps connect subsequent points with a\n\t// horizontal segment and then a vertical segment.\n\tStepHV StepMode = iota\n\n\t// StepVH makes LayerSteps connect subsequent points with a\n\t// vertical segment and then a horizontal segment.\n\tStepVH\n\n\t// StepHMid makes LayerSteps connect subsequent points A and B\n\t// with three segments: a horizontal segment from A to the\n\t// midpoint between A and B, followed by vertical segment,\n\t// followed by a horizontal segment from the midpoint to B.\n\tStepHMid\n\n\t// StepVMid makes LayerSteps connect subsequent points A and B\n\t// with three segments: a vertical segment from A to the\n\t// midpoint between A and B, followed by horizontal segment,\n\t// followed by a vertical segment from the midpoint to B.\n\tStepVMid\n)\n\n// LayerSteps is like LayerPaths, but connects data points with a path\n// consisting only of horizontal and vertical segments.\ntype LayerSteps struct {\n\tLayerPaths\n\n\tStep StepMode\n}\n\nfunc (l LayerSteps) Apply(p *Plot) {\n\t// TODO: Should this also support only showing horizontal or\n\t// vertical segments?\n\t//\n\t// TODO: This could be a data transform instead of a layer.\n\t// Then it could be used in conjunction with, for example,\n\t// ribbons.\n\n\tdefaultCols(p, &l.X, &l.Y)\n\tp.marks = append(p.marks, plotMark{&markSteps{\n\t\tl.Step,\n\t\tp.use(\"x\", l.X),\n\t\tp.use(\"y\", l.Y),\n\t\tp.use(\"stroke\", l.Color),\n\t\tp.use(\"fill\", l.Fill),\n\t}, p.Data().Tables()})\n}\n\n// LayerPaths groups by Color and Fill, and then connects successive\n// data points in each group with a path and/or a filled polygon.\ntype LayerPaths struct {\n\t// X and Y name columns that define the input and response of\n\t// each point on the path. If these are empty, they default to\n\t// the first and second columns, respectively.\n\tX, Y string\n\n\t// Color names a column that defines the stroke color of each\n\t// path. If Color is \"\", it defaults to constant black.\n\t// Otherwise, the data is grouped by Color.\n\tColor string\n\n\t// Fill names a column that defines the fill color of each\n\t// path. If Fill is \"\", it defaults to none. Otherwise, the\n\t// data is grouped by Fill.\n\tFill string\n\n\t// XXX Perhaps the theme should provide default values for\n\t// things like \"color\". That would suggest we need to resolve\n\t// defaults like that at render time. Possibly a special scale\n\t// that gets values from the theme could be used to resolve\n\t// them.\n\t//\n\t// XXX strokeOpacity, fillOpacity, strokeWidth, what other\n\t// properties do SVG strokes have?\n\t//\n\t// XXX Should the set of known styling bindings be fixed, and\n\t// all possible rendering targets have to know what to do with\n\t// them, or should the rendering target be able to have\n\t// different styling bindings they understand (presumably with\n\t// some reasonable base set)? If the renderer can determine\n\t// the known bindings, we would probably just capture the\n\t// environment here (and make it so a captured environment\n\t// does not change) and hand that to the renderer later.\n}\n\nfunc (l LayerPaths) Apply(p *Plot) {\n\tl.apply(p, false)\n}\n\nfunc (l LayerPaths) apply(p *Plot, sort bool) {\n\tdefaultCols(p, &l.X, &l.Y)\n\tif l.Color != \"\" {\n\t\tp.GroupBy(l.Color)\n\t}\n\tif l.Fill != \"\" {\n\t\tp.GroupBy(l.Fill)\n\t}\n\tif sort {\n\t\tdefer p.Save().Restore()\n\t\tp = p.SortBy(l.X)\n\t}\n\n\tp.marks = append(p.marks, plotMark{&markPath{\n\t\tp.use(\"x\", l.X),\n\t\tp.use(\"y\", l.Y),\n\t\tp.use(\"stroke\", l.Color),\n\t\tp.use(\"fill\", l.Fill),\n\t}, p.Data().Tables()})\n}\n\n// LayerArea shades the area between two columns with a polygon. It is\n// useful in conjunction with ggstat.AggMax and ggstat.AggMin for\n// drawing the extents of data.\ntype LayerArea struct {\n\t// X names the column that defines the input of each point. If\n\t// this is empty, it defaults to the first column.\n\tX string\n\n\t// Upper and Lower name columns that define the range of\n\t// response to shade. If either is \"\", it defaults to a\n\t// constant 0 value.\n\tUpper, Lower string\n\n\t// Fill names a column that defines the fill color of each\n\t// area. If Fill is \"\", it defaults to black. Otherwise, the\n\t// data is grouped by Fill.\n\tFill string\n\n\t// FillOpacity names a column that defines the fill opacity of\n\t// each area. If FillOpacity is \"\", it defaults to 0.5.\n\t// Otherwise, the data is grouped by FillOpacity.\n\tFillOpacity string\n}\n\nfunc (l LayerArea) Apply(p *Plot) {\n\tdefaultCols(p, &l.X)\n\tif l.Fill != \"\" {\n\t\tp.GroupBy(l.Fill)\n\t}\n\tif l.FillOpacity != \"\" {\n\t\tp.GroupBy(l.FillOpacity)\n\t}\n\tdefer p.Save().Restore()\n\tp = p.SortBy(l.X)\n\tupper, lower := l.Upper, l.Lower\n\tif upper == \"\" {\n\t\tupper = p.Const(0)\n\t}\n\tif lower == \"\" {\n\t\tlower = p.Const(0)\n\t}\n\tp.marks = append(p.marks, plotMark{&markArea{\n\t\tp.use(\"x\", l.X),\n\t\tp.use(\"y\", upper),\n\t\tp.use(\"y\", lower),\n\t\tp.use(\"fill\", l.Fill),\n\t\tp.use(\"opacity\", l.FillOpacity),\n\t}, p.Data().Tables()})\n}\n\n// LayerPoints layers a point mark at each data point.\ntype LayerPoints struct {\n\t// X and Y name columns that define input and response of each\n\t// point. If these are empty, they default to the first and\n\t// second columns, respectively.\n\tX, Y string\n\n\t// Color names the column that defines the fill color of each\n\t// point. If Color is \"\", it defaults to constant black.\n\tColor string\n\n\t// Opacity names the column that defines the opacity of each\n\t// point. If Opacity is \"\", it defaults to fully opaque. This\n\t// is multiplied by any alpha value specified by Color.\n\tOpacity string\n\n\t// Size names the column that defines the size of each point.\n\t// If Size is \"\", it defaults to 1% of the smallest plot\n\t// dimension.\n\tSize string\n\n\t// XXX fill vs stroke, shape\n}\n\nfunc (l LayerPoints) Apply(p *Plot) {\n\tdefaultCols(p, &l.X, &l.Y)\n\tp.marks = append(p.marks, plotMark{&markPoint{\n\t\tp.use(\"x\", l.X),\n\t\tp.use(\"y\", l.Y),\n\t\t// TODO: It's actually the fill color, but I generally\n\t\t// want it to match things that are stroke colors.\n\t\t// Maybe I should have a \"color\" aesthetic for the\n\t\t// \"primary\" color? Or I could have a hierarchy of\n\t\t// aesthetics, in which this uses \"stroke\" if it has a\n\t\t// scale, but otherwise uses \"color\".\n\t\tp.use(\"stroke\", l.Color),\n\t\t// TODO: What scale for opacity? Or should I assume\n\t\t// callers will use PreScaled values if they want\n\t\t// specific opacities? What's the physical type?\n\t\tp.use(\"opacity\", l.Opacity),\n\t\tp.use(\"size\", l.Size),\n\t}, p.Data().Tables()})\n}\n\n// LayerTiles layers a rectangle at each data point. The rectangle is\n// specified by its center, width, and height.\ntype LayerTiles struct {\n\t// X and Y name columns that define the input and response at\n\t// the center of each rectangle. If they are \"\", they default\n\t// to the first and second columns, respectively.\n\tX, Y string\n\n\t// Width and Height name columns that define the width and\n\t// height of each rectangle. If they are \"\", the width and/or\n\t// height are automatically determined from the smallest\n\t// spacing between distinct X and Y points.\n\tWidth, Height string\n\n\t// Fill names a column that defines the fill color of each\n\t// rectangle. If it is \"\", the default fill is black.\n\tFill string\n\n\t// XXX Stroke color/width, opacity, center adjustment.\n}\n\nfunc (l LayerTiles) Apply(p *Plot) {\n\tdefaultCols(p, &l.X, &l.Y)\n\tif l.Width != \"\" || l.Height != \"\" {\n\t\t// TODO: What scale are these in? (x+width) is in the\n\t\t// X scale, but width itself is not. It doesn't make\n\t\t// sense to train the X scale on width, and if there's\n\t\t// a scale transform, (x+width) has to happen before\n\t\t// the transform. OTOH, if x is discrete, I can't do\n\t\t// (x+width); maybe in that case you just can't\n\t\t// specify a width. OTOOH, if width is specified and\n\t\t// the value is unscaled, I could still do something\n\t\t// reasonable with that if x is discrete.\n\t\tpanic(\"not implemented: non-default width/height\")\n\t}\n\tp.marks = append(p.marks, plotMark{&markTiles{\n\t\tp.use(\"x\", l.X),\n\t\tp.use(\"y\", l.Y),\n\t\tp.use(\"fill\", l.Fill),\n\t}, p.Data().Tables()})\n}\n\n// LayerTags attaches text annotations to data points.\n//\n// TODO: Currently this groups by label and makes one annotation per\n// group. This should be a controllable.\ntype LayerTags struct {\n\t// X and Y name columns that define the input and response\n\t// each tag is attached to. If they are \"\", they default to\n\t// the first and second columns, respectively.\n\tX, Y string\n\n\t// Label names the column that gives the text to put in the\n\t// tag at X, Y. Label is required.\n\tLabel string\n\n\t// HPos controls the horizontal position of the tag if\n\t// multiple points have the same Label. The label will be\n\t// attached to the point closest to HPos between the left-most\n\t// (HPos == 0) and the right-most (HPos == 1) points on this\n\t// curve.\n\tHPos float64\n\n\t// Offset controls the pixel offset of the tag from the point\n\t// it is attached to. If these are both zero, they are treated\n\t// as -20, -20.\n\tOffsetX, OffsetY int\n}\n\nfunc (l LayerTags) Apply(p *Plot) {\n\t// TODO: Should there be special \"annotation marks\" that are\n\t// always on top and can perhaps extend outside the plot area?\n\n\tdefaultCols(p, &l.X, &l.Y)\n\tif l.OffsetX == 0 && l.OffsetY == 0 {\n\t\tl.OffsetX, l.OffsetY = -20, -20\n\t}\n\tdefer p.Save().Restore()\n\tp.GroupBy(l.Label)\n\t// TODO: I keep wanting an abstraction for a column across\n\t// groups like this.\n\tlabels := make(map[table.GroupID]table.Slice)\n\tfor _, gid := range p.Data().Tables() {\n\t\tlabels[gid] = p.Data().Table(gid).MustColumn(l.Label)\n\t}\n\n\tp.marks = append(p.marks, plotMark{&markTags{\n\t\tp.use(\"x\", l.X),\n\t\tp.use(\"y\", l.Y),\n\t\tlabels,\n\t\tl.HPos,\n\t\tl.OffsetX,\n\t\tl.OffsetY,\n\t}, p.Data().Tables()})\n}\n\n// LayerTooltips attaches hover tooltips to data points.\ntype LayerTooltips struct {\n\t// X and Y name columns that define locations of tooltips. If\n\t// they are \"\", they default to the first and second columns,\n\t// respectively.\n\tX, Y string\n\n\t// Label names the column that gives the text of the tooltip.\n\tLabel string\n\n\t// TODO: Text styling, closest X or closest point, multiple\n\t// tooltips if there are multiple points at the same X with\n\t// different Ys?\n}\n\nfunc (l LayerTooltips) Apply(p *Plot) {\n\tdefer p.Save().Restore()\n\n\tdefaultCols(p, &l.X, &l.Y)\n\n\t// Split up by subplot and flatten each subplot.\n\ttables := map[*subplot][]*table.Table{}\n\tgids := map[*subplot]table.GroupID{}\n\tfor _, gid := range p.Data().Tables() {\n\t\ts := subplotOf(gid)\n\t\ttables[s] = append(tables[s], p.Data().Table(gid))\n\t\tgids[s] = gid\n\t}\n\tvar ng table.GroupingBuilder\n\tfor k, ts := range tables {\n\t\tvar subg table.GroupingBuilder\n\t\tfor i, t := range ts {\n\t\t\tsubg.Add(table.RootGroupID.Extend(i), t)\n\t\t}\n\t\tngid := table.RootGroupID.Extend(k)\n\t\tng.Add(ngid, table.Flatten(subg.Done()))\n\t\tp.copyScales(gids[k], ngid)\n\t}\n\tp.SetData(ng.Done())\n\n\tlabels := make(map[table.GroupID]table.Slice)\n\tfor _, gid := range p.Data().Tables() {\n\t\tlabels[gid] = p.Data().Table(gid).MustColumn(l.Label)\n\t}\n\tp.marks = append(p.marks, plotMark{&markTooltips{\n\t\tp.use(\"x\", l.X),\n\t\tp.use(\"y\", l.Y),\n\t\tlabels,\n\t}, p.Data().Tables()})\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/gg/layout/grid.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage layout\n\nimport \"sort\"\n\n// Grid lays out elements in a two dimensional table. Each child is\n// assigned to a cell in the table and may optionally span multiple\n// rows and/or columns.\ntype Grid struct {\n\telts []*gridElement\n\tcols, rows int\n\tx, y, w, h float64\n}\n\ntype gridElement struct {\n\te Element\n\tx, y, colSpan, rowSpan int\n}\n\n// Add adds Element e to Grid g, spanning cells (x,y) up to but not\n// including (x+colSpan, y+colSpan).\nfunc (g *Grid) Add(e Element, x, y, colSpan, rowSpan int) {\n\tif x+colSpan > g.cols {\n\t\tg.cols = x + colSpan\n\t}\n\tif y+rowSpan > g.rows {\n\t\tg.rows = y + rowSpan\n\t}\n\tg.elts = append(g.elts, &gridElement{e, x, y, colSpan, rowSpan})\n}\n\nfunc (g *Grid) Children() []Element {\n\tres := make([]Element, len(g.elts))\n\tfor i, elt := range g.elts {\n\t\tres[i] = elt.e\n\t}\n\treturn res\n}\n\nfunc (g *Grid) doLayout(byRow bool, allocated float64) (dims []float64, flexes []bool) {\n\tseq := func(n int) []int {\n\t\tres := make([]int, n)\n\t\tfor i := range res {\n\t\t\tres[i] = i\n\t\t}\n\t\treturn res\n\t}\n\tmax := func(x, y float64) float64 {\n\t\tif x > y {\n\t\t\treturn x\n\t\t}\n\t\treturn y\n\t}\n\n\tif byRow {\n\t\tdims = make([]float64, g.rows)\n\t\tflexes = make([]bool, g.rows)\n\t} else {\n\t\tdims = make([]float64, g.cols)\n\t\tflexes = make([]bool, g.cols)\n\t}\n\tfor i := range flexes {\n\t\t// TODO: Should empty columns be set to false?\n\t\tflexes[i] = true\n\t}\n\n\t// Sort elements by colSpan or rowSpan.\n\teltOrder := seq(len(g.elts))\n\tsort.Sort(&gridElementSorter{g.elts, eltOrder, byRow})\n\n\t// Add a fake element that spans everything and uses the\n\t// allocated space.\n\tif allocated > 0 {\n\t\teltOrder = append(eltOrder, -1)\n\t}\n\n\t// Process elements by increasing span.\n\tfor _, i := range eltOrder {\n\t\tvar (\n\t\t\tedim float64\n\t\t\teflex bool\n\t\t\tepos int\n\t\t\tespan int\n\t\t)\n\t\tif i == -1 {\n\t\t\t// Fake element for final space allocation.\n\t\t\tedim, eflex, epos, espan = allocated, true, 0, len(dims)\n\t\t} else {\n\t\t\te := g.elts[i]\n\t\t\t// TODO: We need to make one pass and get both size\n\t\t\t// hints or this will be exponential.\n\t\t\tif byRow {\n\t\t\t\t_, edim, _, eflex = e.e.SizeHint()\n\t\t\t\tepos, espan = e.y, e.rowSpan\n\t\t\t} else {\n\t\t\t\tedim, _, eflex, _ = e.e.SizeHint()\n\t\t\t\tepos, espan = e.x, e.colSpan\n\t\t\t}\n\t\t}\n\n\t\tif espan == 1 {\n\t\t\tdims[epos] = max(dims[epos], edim)\n\t\t\tif !eflex {\n\t\t\t\tflexes[epos] = false\n\t\t\t}\n\t\t} else if espan > 1 {\n\t\t\ttotal := edim\n\n\t\t\t// Expand flexible columns so that the total\n\t\t\t// dim is >= e's dim, and so the rows/columns\n\t\t\t// we do expand get equal dims. We don't\n\t\t\t// shrink any row/column. If all rows/columns\n\t\t\t// are fixed, we treat them all as flexible.\n\t\t\tvar subdims []float64\n\t\t\tforceFlex := false\n\t\t\tfor i := epos; i < epos+espan; i++ {\n\t\t\t\tif flexes[i] {\n\t\t\t\t\tsubdims = append(subdims, dims[i])\n\t\t\t\t} else {\n\t\t\t\t\t// This space is accounted for.\n\t\t\t\t\ttotal -= dims[i]\n\t\t\t\t}\n\t\t\t}\n\t\t\tif len(subdims) == 0 {\n\t\t\t\t// All rows/columns are fixed, so treat\n\t\t\t\t// them all as flexible.\n\t\t\t\tforceFlex = true\n\t\t\t\tsubdims = append(subdims, dims[epos:epos+espan]...)\n\t\t\t\ttotal = edim\n\t\t\t}\n\n\t\t\tif total <= 0 {\n\t\t\t\t// Fixed columns already take e's space.\n\t\t\t\tcontinue\n\t\t\t}\n\n\t\t\t// Remove flex columns already wider than\n\t\t\t// total/count from consideration.\n\t\t\tcount := len(subdims)\n\t\t\tsort.Sort(sort.Reverse(sort.Float64Slice(subdims)))\n\t\t\tfor _, dim := range dims {\n\t\t\t\tif dim > total/float64(count) {\n\t\t\t\t\ttotal -= dim\n\t\t\t\t\tcount--\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Expand remaining rows/columns to total/count.\n\t\t\tif count <= 0 {\n\t\t\t\t// Flex columns already take e's space.\n\t\t\t\tcontinue\n\t\t\t}\n\n\t\t\tdim := total / float64(count)\n\t\t\tfor i := epos; i < epos+espan; i++ {\n\t\t\t\tif flexes[i] || forceFlex {\n\t\t\t\t\tdims[i] = max(dims[i], dim)\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// TODO: What do I do with e's flex? Clearly\n\t\t\t// if a fixed element spans the whole grid,\n\t\t\t// the grid should be fixed, so I shouldn't\n\t\t\t// ignore it.\n\t\t}\n\t}\n\treturn\n}\n\nfunc (g *Grid) SizeHint() (w, h float64, flexw, flexh bool) {\n\tsum := func(xs []float64) float64 {\n\t\ts := 0.0\n\t\tfor _, x := range xs {\n\t\t\ts += x\n\t\t}\n\t\treturn s\n\t}\n\tany := func(xs []bool) bool {\n\t\tfor _, x := range xs {\n\t\t\tif x {\n\t\t\t\treturn true\n\t\t\t}\n\t\t}\n\t\treturn false\n\t}\n\n\txdims, xflexes := g.doLayout(false, 0)\n\tydims, yflexes := g.doLayout(true, 0)\n\treturn sum(xdims), sum(ydims), any(xflexes), any(yflexes)\n}\n\nfunc (g *Grid) SetLayout(x, y, w, h float64) {\n\t// Record layout.\n\tg.x, g.y, g.w, g.h = x, y, w, h\n\n\t// Layout children.\n\tcsum := func(xs []float64) []float64 {\n\t\tres, csum := make([]float64, len(xs)+1), 0.0\n\t\tfor i, x := range xs {\n\t\t\tres[i+1] = csum + x\n\t\t\tcsum += x\n\t\t}\n\t\treturn res\n\t}\n\txdims, _ := g.doLayout(false, w)\n\tydims, _ := g.doLayout(true, h)\n\txpos := csum(xdims)\n\typos := csum(ydims)\n\tfor _, elt := range g.elts {\n\t\telt.e.SetLayout(xpos[elt.x], ypos[elt.y], xpos[elt.x+elt.colSpan]-xpos[elt.x], ypos[elt.y+elt.rowSpan]-ypos[elt.y])\n\t}\n}\n\nfunc (g *Grid) Layout() (x, y, w, h float64) {\n\treturn g.x, g.y, g.w, g.h\n}\n\ntype gridElementSorter struct {\n\telts []*gridElement\n\tseq []int\n\tbyRowSpan bool\n}\n\nfunc (g *gridElementSorter) Len() int {\n\treturn len(g.seq)\n}\n\nfunc (g *gridElementSorter) Less(i, j int) bool {\n\te1, e2 := g.elts[g.seq[i]], g.elts[g.seq[j]]\n\tif g.byRowSpan {\n\t\treturn e1.rowSpan < e2.rowSpan\n\t}\n\treturn e1.colSpan < e2.colSpan\n}\n\nfunc (g *gridElementSorter) Swap(i, j int) {\n\tg.seq[i], g.seq[j] = g.seq[j], g.seq[i]\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/gg/layout/layout.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// Package layout provides helpers for laying out hierarchies of\n// rectangular elements in two dimensional space.\npackage layout\n\n// TODO: If I want to handle wrapped text, this API is insufficient.\n// In that case, I may need something more like Android where the\n// parent can pass in Unspecified, (Exactly x), or (AtMost x) for both\n// dimensions and make multiple calls. I would probably start out with\n// AtMost the allocated dimension for everything and if the total came\n// back too large, I would cut back space (possibly causing the other\n// dimension to grow if text wraps).\n\n// An Element is a rectangular feature in a layout.\ntype Element interface {\n\t// SizeHint returns this Element's desired size and whether it\n\t// can expand from that size in either direction.\n\tSizeHint() (w, h float64, flexw, flexh bool)\n\n\t// SetLayout sets this Element's layout relative to its parent\n\t// and, if this Element is a container, recursively lays out\n\t// this Element's children.\n\t//\n\t// w and h may be smaller than SizeHint() if the space is\n\t// constrained. They may also be larger, even if the element\n\t// isn't flexible, in which case the Element will position\n\t// itself within the assigned size using some gravity.\n\t//\n\t// TODO: Or should the parent be responsible for gravity if it\n\t// allocates too much space to a fixed element?\n\t//\n\t// TODO: Since an Element doesn't know its parent, it's\n\t// difficult to turn local coordinates into absolute\n\t// coordinates. These should either be absolute coordinates,\n\t// or Element should have a parent and it should be easy to\n\t// get absolute coordinates.\n\tSetLayout(x, y, w, h float64)\n\n\t// Layout returns this Element's layout.\n\tLayout() (x, y, w, h float64)\n}\n\n// A Group is an Element that manages the layout of child Elements.\ntype Group interface {\n\tElement\n\n\t// Children returns the child Elements laid out by this Group.\n\tChildren() []Element\n}\n\n// Leaf is a leaf in a layout hierarchy. It is meant for embedding: it\n// partially implements Element, leaving SizeHint to the embedding\n// type.\ntype Leaf struct {\n\tx, y, w, h float64\n}\n\nfunc (l *Leaf) SetLayout(x, y, w, h float64) {\n\tl.x, l.y, l.w, l.h = x, y, w, h\n}\n\nfunc (l *Leaf) Layout() (x, y, w, h float64) {\n\treturn l.x, l.y, l.w, l.h\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/gg/layout.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage gg\n\nimport (\n\t\"fmt\"\n\t\"math\"\n\t\"sort\"\n\n\t\"github.com/aclements/go-gg/gg/layout\"\n\t\"github.com/aclements/go-gg/table\"\n\t\"github.com/ajstarks/svgo\"\n)\n\n// A plotElt is a high-level element of a plot layout.\n//\n// plotElts are arranged in a 2D grid. Coordinates in the grid are\n// specified by a pair of \"paths\" rather than a simple pair of\n// indexes. For example, element A is to the left of element B if A's\n// X path is less than B's X path, where paths are compared as tuples\n// with an infinite number of trailing 0's. This makes it easy to, for\n// example, place an element to the right of another element without\n// having to renumber all of the elements that are already to its\n// right.\n//\n// The first level of the hierarchy is simply the coordinate of the\n// plot in the grid. Within this, we layout plot elements as follows:\n//\n// +----------------------+\n// | Label (x, y/-3/-1) |\n// +----------------------+\n// | Label (x, y/-3/0) |\n// +----------------------+\n// | Padding (x, y/-2) |\n// +-----------+----------+----------------------+----------+------------+\n// | Padding | YTicks | | Padding | Label |\n// | (x/-2, y) | (x/-1,y) | Subplot (x, y) | (x/2, y) | (x/3/0, y) |\n// | | | | | |\n// +-----------+----------+----------------------+----------+------------+\n// | XTicks (x, y/1) |\n// +----------------------+\n// | Padding (x, y/2) |\n// +----------------------+\n//\n// TODO: Should I instead think of this as specifying the edges rather\n// than the cells?\ntype plotElt interface {\n\tlayout.Element\n\n\t// paths returns the top-left and bottom-right cells of this\n\t// element. x2Path and y2Path may be nil, indicating that they\n\t// are the same as xPath and yPath.\n\tpaths() (xPath, yPath, x2Path, y2Path eltPath)\n\n\t// render draws this plot element to r.svg.\n\trender(r *eltRender)\n}\n\ntype eltRender struct {\n\tsvg *svg.SVG\n\tid int\n}\n\nfunc (r *eltRender) genid(prefix string) (id, ref string) {\n\tid = fmt.Sprintf(\"%s%d\", prefix, r.id)\n\tref = \"url(#\" + id + \")\"\n\tr.id++\n\treturn\n}\n\ntype eltCommon struct {\n\txPath, yPath, x2Path, y2Path eltPath\n}\n\nfunc (c *eltCommon) paths() (xPath, yPath, x2Path, y2Path eltPath) {\n\treturn c.xPath, c.yPath, c.x2Path, c.y2Path\n}\n\ntype eltSubplot struct {\n\teltCommon\n\tlayout.Leaf\n\n\tsubplot *subplot\n\tmarks []plotMark\n\tscales map[string]map[Scaler]bool\n\n\txTicks, yTicks *eltTicks\n\n\tplotMargins struct {\n\t\tt, r, b, l float64\n\t}\n}\n\nfunc newEltSubplot(s *subplot) *eltSubplot {\n\treturn &eltSubplot{\n\t\teltCommon: eltCommon{xPath: eltPath{s.x}, yPath: eltPath{s.y}},\n\t\tsubplot: s,\n\t\tscales: make(map[string]map[Scaler]bool),\n\t}\n}\n\nfunc (e *eltSubplot) SizeHint() (w, h float64, flexw, flexh bool) {\n\treturn 0, 0, true, true\n}\n\nfunc (e *eltSubplot) SetLayout(x, y, w, h float64) {\n\te.Leaf.SetLayout(x, y, w, h)\n\tm := &e.plotMargins\n\tm.t, m.r, m.b, m.l = plotMargins(w, h)\n}\n\ntype eltTicks struct {\n\teltCommon\n\tlayout.Leaf\n\n\taxis rune // 'x' or 'y'\n\tticksFor *eltSubplot // Subplot to which this is directly attached\n\tticks map[Scaler]plotEltTicks\n}\n\ntype plotEltTicks struct {\n\tmajor table.Slice\n\tminor table.Slice\n\tlabels []string\n}\n\nfunc newEltTicks(axis rune, s *eltSubplot) *eltTicks {\n\telt := &eltTicks{\n\t\teltCommon: s.eltCommon,\n\t\taxis: axis,\n\t\tticksFor: s,\n\t}\n\tswitch axis {\n\tcase 'x':\n\t\telt.yPath = eltPath{s.subplot.y, 1}\n\tcase 'y':\n\t\telt.xPath = eltPath{s.subplot.x, -1}\n\tdefault:\n\t\tpanic(\"bad axis\")\n\t}\n\treturn elt\n}\n\nfunc (e *eltTicks) scales() map[Scaler]bool {\n\tswitch e.axis {\n\tcase 'x':\n\t\treturn e.ticksFor.scales[\"x\"]\n\tcase 'y':\n\t\treturn e.ticksFor.scales[\"y\"]\n\tdefault:\n\t\tpanic(\"bad axis\")\n\t}\n}\n\nfunc (e *eltTicks) mapTicks(s Scaler, ticks table.Slice) (pixels []float64) {\n\tx, y, w, h := e.Layout()\n\t// TODO: This doesn't show ticks in the margin area. This may\n\t// be fine with niced tick labels, but it tends to look bad\n\t// with un-niced ticks. Ideally we would expand the input\n\t// domain instead, but this isn't well-defined for discrete\n\t// scales. We could use Unmap to try to find the expanded\n\t// input domain on both sides, but fall back to expanding the\n\t// ranger if Unmap fails (which it would for a discrete\n\t// scale).\n\tm := e.ticksFor.plotMargins\n\tswitch e.axis {\n\tcase 'x':\n\t\ts.Ranger(NewFloatRanger(x+m.l, x+w-m.r))\n\tcase 'y':\n\t\ts.Ranger(NewFloatRanger(y+h-m.b, y+m.t))\n\t}\n\treturn mapMany(s, ticks).([]float64)\n}\n\n// computeTicks computes the location and labels of the ticks in\n// element e based on the dimensions of e.ticksFor (which must have\n// been laid out prior to calling this).\nfunc (e *eltTicks) computeTicks() {\n\tconst tickDistance = 30 // TODO: Theme. Min pixels between tick labels.\n\n\t_, _, w, h := e.ticksFor.Layout()\n\tvar dim float64\n\tswitch e.axis {\n\tcase 'x':\n\t\tdim = w\n\tcase 'y':\n\t\tdim = h\n\t}\n\n\t// Compute max ticks assuming the labels are zero sized.\n\tmaxTicks := int(dim / tickDistance)\n\n\t// Optimize ticks, keeping labels at least tickDistance apart.\n\te.ticks = make(map[Scaler]plotEltTicks)\n\tfor s := range e.scales() {\n\t\tpred := func(ticks, _ table.Slice, labels []string) bool {\n\t\t\tif len(labels) <= 1 {\n\t\t\t\treturn true\n\t\t\t}\n\t\t\t// Check distance between labels.\n\t\t\tpos := e.mapTicks(s, ticks)\n\t\t\t// Ticks are in value order, but we need them\n\t\t\t// in position order.\n\t\t\tsort.Float64s(pos)\n\t\t\tvar last float64\n\t\t\tfor i, p := range pos {\n\t\t\t\tif i > 0 && p-last < tickDistance {\n\t\t\t\t\t// Labels i-1 and i are too close.\n\t\t\t\t\treturn false\n\t\t\t\t}\n\t\t\t\tmetrics := measureString(fontSize, labels[i])\n\t\t\t\tswitch e.axis {\n\t\t\t\tcase 'x':\n\t\t\t\t\tlast = p + metrics.width\n\t\t\t\tcase 'y':\n\t\t\t\t\tlast = p + metrics.leading\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn true\n\t\t}\n\t\tmajor, minor, labels := s.Ticks(maxTicks, pred)\n\t\te.ticks[s] = plotEltTicks{major, minor, labels}\n\t}\n}\n\nfunc (e *eltTicks) SizeHint() (w, h float64, flexw, flexh bool) {\n\tif len(e.ticks) == 0 {\n\t\t// Ticks haven't been computed yet or there are none.\n\t\t// Assume this takes up no space.\n\t\tswitch e.axis {\n\t\tcase 'x':\n\t\t\treturn 0, 0, true, false\n\t\tcase 'y':\n\t\t\treturn 0, 0, false, true\n\t\tdefault:\n\t\t\tpanic(\"bad axis\")\n\t\t}\n\t}\n\n\tvar maxWidth, maxHeight float64\n\tfor s := range e.scales() {\n\t\tfor _, label := range e.ticks[s].labels {\n\t\t\tmetrics := measureString(fontSize, label)\n\t\t\tmaxHeight = math.Max(maxHeight, metrics.leading)\n\t\t\tmaxWidth = math.Max(maxWidth, metrics.width)\n\t\t}\n\t}\n\tswitch e.axis {\n\tcase 'x':\n\t\tmaxHeight += xTickSep\n\tcase 'y':\n\t\tmaxWidth += yTickSep\n\t}\n\treturn maxWidth, maxHeight, e.axis == 'x', e.axis == 'y'\n}\n\ntype eltLabel struct {\n\teltCommon\n\tlayout.Leaf\n\n\tside rune // 't', 'b', 'l', 'r'\n\tlabel string\n\tfill string\n}\n\nfunc newEltLabelFacet(side rune, label string, x1, y1, x2, y2 int, level int) *eltLabel {\n\telt := &eltLabel{\n\t\tside: side,\n\t\tlabel: label,\n\t\tfill: \"#ccc\", // TODO: Theme.\n\t}\n\tswitch side {\n\tcase 't':\n\t\telt.eltCommon = eltCommon{\n\t\t\txPath: eltPath{x1},\n\t\t\tyPath: eltPath{y1, -3, -level},\n\t\t\tx2Path: eltPath{x2},\n\t\t}\n\tcase 'r':\n\t\telt.eltCommon = eltCommon{\n\t\t\txPath: eltPath{x2, 3, level},\n\t\t\tyPath: eltPath{y1},\n\t\t\ty2Path: eltPath{y2},\n\t\t}\n\tdefault:\n\t\tpanic(\"bad side\")\n\t}\n\treturn elt\n}\n\nfunc newEltLabelAxis(side rune, label string, x, y, span int) *eltLabel {\n\telt := &eltLabel{\n\t\teltCommon: eltCommon{xPath: eltPath{x}, yPath: eltPath{y}},\n\t\tside: side,\n\t\tlabel: label,\n\t\tfill: \"none\",\n\t}\n\tswitch side {\n\tcase 'T', 'b':\n\t\telt.x2Path = eltPath{x + span}\n\tcase 'l':\n\t\telt.y2Path = eltPath{y + span}\n\tdefault:\n\t\tpanic(\"bad side\")\n\t}\n\treturn elt\n}\n\nfunc (e *eltLabel) SizeHint() (w, h float64, flexw, flexh bool) {\n\t// TODO: We actually want the height of the text, which could\n\t// be N*leading if there are multiple lines.\n\tdim := measureString(fontSize, e.label).leading * facetLabelHeight\n\tswitch e.side {\n\tcase 't', 'b':\n\t\treturn 0, dim, true, false\n\tcase 'T': // Titles\n\t\treturn 0, 1.5 * dim, true, false\n\tcase 'l', 'r':\n\t\treturn dim, 0, false, true\n\tdefault:\n\t\tpanic(\"bad side\")\n\t}\n}\n\ntype eltPadding struct {\n\teltCommon\n\tlayout.Leaf\n\n\tside rune // 't', 'b', 'l', 'r'\n}\n\nfunc newEltPadding(side rune, x, y int) *eltPadding {\n\telt := &eltPadding{\n\t\teltCommon: eltCommon{xPath: eltPath{x}, yPath: eltPath{y}},\n\t\tside: side,\n\t}\n\tswitch side {\n\tcase 't':\n\t\telt.yPath = eltPath{y, -2}\n\tcase 'r':\n\t\telt.xPath = eltPath{x, 2}\n\tcase 'b':\n\t\telt.yPath = eltPath{y, 2}\n\tcase 'l':\n\t\telt.xPath = eltPath{x, -2}\n\tdefault:\n\t\tpanic(\"bad side\")\n\t}\n\treturn elt\n}\n\nfunc (e *eltPadding) SizeHint() (w, h float64, flexw, flexh bool) {\n\tconst padding = 4 // TODO: Theme.\n\n\tswitch e.side {\n\tcase 't', 'b':\n\t\treturn 0, padding, true, false\n\tcase 'l', 'r':\n\t\treturn padding, 0, false, true\n\tdefault:\n\t\tpanic(\"bad side\")\n\t}\n}\n\nfunc addSubplotLabels(elts []plotElt) []plotElt {\n\t// Find the regions covered by each subplot band.\n\tvBands := make(map[*subplotBand]subplotRegion)\n\thBands := make(map[*subplotBand]subplotRegion)\n\tfor _, elt := range elts {\n\t\telt, ok := elt.(*eltSubplot)\n\t\tif !ok {\n\t\t\tcontinue\n\t\t}\n\t\ts := elt.subplot\n\n\t\tlevel := 0\n\t\tfor vBand := s.vBand; vBand != nil; vBand = vBand.parent {\n\t\t\tr := vBands[vBand]\n\t\t\tr.update(s, level)\n\t\t\tvBands[vBand] = r\n\t\t\tlevel++\n\t\t}\n\n\t\tlevel = 0\n\t\tfor hBand := s.hBand; hBand != nil; hBand = hBand.parent {\n\t\t\tr := hBands[hBand]\n\t\t\tr.update(s, level)\n\t\t\thBands[hBand] = r\n\t\t\tlevel++\n\t\t}\n\t}\n\n\t// Create ticks.\n\t//\n\t// TODO: If the facet grid isn't total, this can add ticks to\n\t// the side of a plot that's in the middle of the grid and\n\t// that creates a gap between all of the plots. This seems\n\t// like a fundamental limitation of treating this as a grid.\n\t// We could either abandon the grid and instead use a\n\t// hierarchy of left-of/right-of/above/below relations, or we\n\t// could make facets produce a total grid.\n\tvar prev *eltSubplot\n\tvar curTicks *eltTicks\n\tsorter := newSubplotSorter(elts, 'x')\n\tsort.Sort(sorter)\n\tfor _, elt := range sorter.elts {\n\t\tif prev == nil || prev.subplot.y != elt.subplot.y || !eqScales(prev, elt, \"y\") {\n\t\t\t// Show Y axis ticks.\n\t\t\tcurTicks = newEltTicks('y', elt)\n\t\t\telts = append(elts, curTicks)\n\t\t}\n\t\telt.yTicks = curTicks\n\t\tprev = elt\n\t}\n\tsorter.dir = 'y'\n\tsort.Sort(sorter)\n\tprev, curTicks = nil, nil\n\tfor _, elt := range sorter.elts {\n\t\tif prev == nil || prev.subplot.x != elt.subplot.x || !eqScales(prev, elt, \"x\") {\n\t\t\t// Show X axis ticks.\n\t\t\tcurTicks = newEltTicks('x', elt)\n\t\t\telts = append(elts, curTicks)\n\t\t}\n\t\telt.xTicks = curTicks\n\t\tprev = elt\n\t}\n\n\t// Create labels.\n\tfor vBand, r := range vBands {\n\t\telts = append(elts, newEltLabelFacet('t', vBand.label, r.x1, r.y1, r.x2, r.y2, r.level))\n\t}\n\tfor hBand, r := range hBands {\n\t\telts = append(elts, newEltLabelFacet('r', hBand.label, r.x1, r.y1, r.x2, r.y2, r.level))\n\t}\n\treturn elts\n}\n\nfunc addAxisLabels(elts []plotElt, title, xlabel, ylabel string) []plotElt {\n\t// Find the region covered by subplots.\n\tvar r subplotRegion\n\tfor _, elt := range elts {\n\t\telt, ok := elt.(*eltSubplot)\n\t\tif !ok {\n\t\t\tcontinue\n\t\t}\n\t\tr.update(elt.subplot, 0)\n\t}\n\tif !r.valid {\n\t\treturn elts\n\t}\n\n\t// Add title.\n\t// TODO: Make this larger.\n\tif title != \"\" {\n\t\telts = append(elts,\n\t\t\tnewEltLabelAxis('T', title, r.x1, r.y1-1, r.x2-r.x1))\n\t}\n\n\t// Add labels.\n\telts = append(elts,\n\t\tnewEltLabelAxis('b', xlabel, r.x1, r.y2+1, r.x2-r.x1),\n\t\tnewEltLabelAxis('l', ylabel, r.x1-1, r.y1, r.y2-r.y1))\n\treturn elts\n}\n\ntype subplotRegion struct {\n\tvalid bool\n\tx1, x2, y1, y2, level int\n}\n\nfunc (r *subplotRegion) update(s *subplot, level int) {\n\tif !r.valid {\n\t\tr.x1, r.x2, r.y1, r.y2, r.level = s.x, s.x, s.y, s.y, level\n\t\tr.valid = true\n\t\treturn\n\t}\n\tif s.x < r.x1 {\n\t\tr.x1 = s.x\n\t} else if s.x > r.x2 {\n\t\tr.x2 = s.x\n\t}\n\tif s.y < r.y1 {\n\t\tr.y1 = s.y\n\t} else if s.y > r.y2 {\n\t\tr.y2 = s.y\n\t}\n\tif level > r.level {\n\t\tr.level = level\n\t}\n}\n\n// subplotSorter sorts eltSubplots by subplot (x, y) position.\ntype subplotSorter struct {\n\telts []*eltSubplot\n\n\t// dir indicates primary sorting direction: 'x' means to sort\n\t// left-to-right, top-to-bottom; 'y' means to sort\n\t// bottom-to-top, left-to-right.\n\tdir rune\n}\n\nfunc newSubplotSorter(elts []plotElt, dir rune) *subplotSorter {\n\tselts := []*eltSubplot{}\n\tfor _, elt := range elts {\n\t\tif s, ok := elt.(*eltSubplot); ok {\n\t\t\tselts = append(selts, s)\n\t\t}\n\t}\n\treturn &subplotSorter{selts, dir}\n}\n\nfunc (s subplotSorter) Len() int {\n\treturn len(s.elts)\n}\n\nfunc (s subplotSorter) Less(i, j int) bool {\n\ta, b := s.elts[i], s.elts[j]\n\tif s.dir == 'x' {\n\t\tif a.subplot.y != b.subplot.y {\n\t\t\treturn a.subplot.y < b.subplot.y\n\t\t}\n\t\treturn a.subplot.x < b.subplot.x\n\t} else {\n\t\tif a.subplot.x != b.subplot.x {\n\t\t\treturn a.subplot.x < b.subplot.x\n\t\t}\n\t\treturn a.subplot.y > b.subplot.y\n\t}\n}\n\nfunc (s subplotSorter) Swap(i, j int) {\n\ts.elts[i], s.elts[j] = s.elts[j], s.elts[i]\n}\n\nfunc eqScales(a, b *eltSubplot, aes string) bool {\n\tsa, sb := a.scales[aes], b.scales[aes]\n\tif len(sa) != len(sb) {\n\t\treturn false\n\t}\n\tfor k, v := range sa {\n\t\tif sb[k] != v {\n\t\t\treturn false\n\t\t}\n\t}\n\treturn true\n}\n\ntype eltPath []int\n\nfunc (a eltPath) cmp(b eltPath) int {\n\tfor len(a) > 0 || len(b) > 0 {\n\t\tvar ax, bx int\n\t\tif len(a) > 0 {\n\t\t\tax, a = a[0], a[1:]\n\t\t}\n\t\tif len(b) > 0 {\n\t\t\tbx, b = b[0], b[1:]\n\t\t}\n\t\tif ax != bx {\n\t\t\tif ax < bx {\n\t\t\t\treturn -1\n\t\t\t} else {\n\t\t\t\treturn 1\n\t\t\t}\n\t\t}\n\t}\n\treturn 0\n}\n\ntype eltPaths []eltPath\n\nfunc (s eltPaths) Len() int {\n\treturn len(s)\n}\n\nfunc (s eltPaths) Less(i, j int) bool {\n\treturn s[i].cmp(s[j]) < 0\n}\n\nfunc (s eltPaths) Swap(i, j int) {\n\ts[i], s[j] = s[j], s[i]\n}\n\nfunc (s eltPaths) nub() eltPaths {\n\tvar i, o int\n\tfor i, o = 1, 1; i < len(s); i++ {\n\t\tif s[i].cmp(s[i-1]) != 0 {\n\t\t\ts[o] = s[i]\n\t\t\to++\n\t\t}\n\t}\n\treturn s[:o]\n}\n\nfunc (s eltPaths) find(p eltPath) int {\n\treturn sort.Search(len(s), func(i int) bool {\n\t\treturn s[i].cmp(p) >= 0\n\t})\n}\n\n// layoutPlotElts returns a layout containing all of the elements in\n// elts.\n//\n// layoutPlotElts flattens the X and Y paths of elts into simple\n// coordinate indexes and constructs a layout.Grid.\nfunc layoutPlotElts(elts []plotElt) layout.Element {\n\t// Add padding elements to each subplot.\n\t//\n\t// TODO: Should there be padding between labels and the plot?\n\tfor _, elt := range elts {\n\t\telt, ok := elt.(*eltSubplot)\n\t\tif !ok {\n\t\t\tcontinue\n\t\t}\n\t\tx, y := elt.xPath[0], elt.yPath[0]\n\t\telts = append(elts,\n\t\t\tnewEltPadding('t', x, y),\n\t\t\tnewEltPadding('r', x, y),\n\t\t\tnewEltPadding('b', x, y),\n\t\t\tnewEltPadding('l', x, y),\n\t\t)\n\t}\n\n\t// Construct the global element grid from coordinate paths by\n\t// sorting the sets of X paths and Y paths to each leaf and\n\t// computing a global (x,y) for each leaf from these orders.\n\ttype eltPos struct {\n\t\tx, y, xSpan, ySpan int\n\t}\n\tflat := map[plotElt]eltPos{}\n\tdir := func(get func(plotElt) (p, p2 eltPath), set func(p *eltPos, pos, span int)) {\n\t\tvar paths eltPaths\n\t\tfor _, elt := range elts {\n\t\t\tp, p2 := get(elt)\n\t\t\tpaths = append(paths, p)\n\t\t\tif p2 != nil {\n\t\t\t\tpaths = append(paths, p2)\n\t\t\t}\n\t\t}\n\t\tsort.Sort(paths)\n\t\tpaths = paths.nub()\n\t\tfor _, elt := range elts {\n\t\t\tp, p2 := get(elt)\n\t\t\tpos, span := paths.find(p), 1\n\t\t\tif p2 != nil {\n\t\t\t\tspan = paths.find(p2) - pos + 1\n\t\t\t}\n\t\t\teltPos := flat[elt]\n\t\t\tset(&eltPos, pos, span)\n\t\t\tflat[elt] = eltPos\n\t\t}\n\t}\n\tdir(func(e plotElt) (p, p2 eltPath) {\n\t\tp, _, p2, _ = e.paths()\n\t\treturn\n\t}, func(p *eltPos, pos, span int) {\n\t\tp.x, p.xSpan = pos, span\n\t})\n\tdir(func(e plotElt) (p, p2 eltPath) {\n\t\t_, p, _, p2 = e.paths()\n\t\treturn\n\t}, func(p *eltPos, pos, span int) {\n\t\tp.y, p.ySpan = pos, span\n\t})\n\n\t// Construct the grid layout.\n\tl := new(layout.Grid)\n\tfor elt, pos := range flat {\n\t\tl.Add(elt, pos.x, pos.y, pos.xSpan, pos.ySpan)\n\t}\n\treturn l\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/gg/mark.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage gg\n\nimport (\n\t\"bytes\"\n\t\"encoding/base64\"\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"image\"\n\t\"image/color\"\n\t\"image/png\"\n\t\"math\"\n\t\"reflect\"\n\t\"sort\"\n\t\"strconv\"\n\n\t\"github.com/aclements/go-gg/generic/slice\"\n\t\"github.com/aclements/go-gg/table\"\n\t\"github.com/aclements/go-moremath/stats\"\n\t\"github.com/ajstarks/svgo\"\n)\n\n// TODO: Audit all of this for inf and NaN.\n\ntype marker interface {\n\tmark(env *renderEnv, canvas *svg.SVG)\n}\n\nfunc isFinite(x float64) bool {\n\treturn !(math.IsNaN(x) || math.IsInf(x, 0))\n}\n\ntype plotMark struct {\n\tm marker\n\tgroups []table.GroupID\n}\n\ntype markPath struct {\n\tx, y, stroke, fill *scaledData\n}\n\nfunc (m *markPath) mark(env *renderEnv, canvas *svg.SVG) {\n\t// XXX What ensures these type assertions will succeed,\n\t// especially if it's an identity scale? Maybe identity scales\n\t// still need to coerce their results to the right type.\n\txs, ys := env.get(m.x).([]float64), env.get(m.y).([]float64)\n\tvar stroke color.Color = color.Black\n\tif m.stroke != nil {\n\t\tstroke = env.getFirst(m.stroke).(color.Color)\n\t}\n\tvar fill color.Color = color.Transparent\n\tif m.fill != nil {\n\t\tfill = env.getFirst(m.fill).(color.Color)\n\t}\n\n\tdrawPath(canvas, xs, ys, stroke, fill)\n}\n\ntype markArea struct {\n\tx, upper, lower, fill, fillOpacity *scaledData\n}\n\nfunc reversed(data []float64) []float64 {\n\tvar rev []float64\n\tfor i := len(data) - 1; i >= 0; i-- {\n\t\trev = append(rev, data[i])\n\t}\n\treturn rev\n}\n\nfunc (m *markArea) mark(env *renderEnv, canvas *svg.SVG) {\n\txs := env.get(m.x).([]float64)\n\tupper := env.get(m.upper).([]float64)\n\tlower := env.get(m.lower).([]float64)\n\tvar fill color.Color = color.Black\n\tif m.fill != nil {\n\t\tfill = env.getFirst(m.fill).(color.Color)\n\t}\n\tfillOpacity := 0.5\n\tif m.fillOpacity != nil {\n\t\tfillOpacity = env.getFirst(m.fillOpacity).(float64)\n\t}\n\tr, g, b, a := fill.RGBA()\n\tfill = color.RGBA64{\n\t\tuint16(float64(r) * fillOpacity),\n\t\tuint16(float64(g) * fillOpacity),\n\t\tuint16(float64(b) * fillOpacity),\n\t\tuint16(float64(a) * fillOpacity)}\n\n\txs = append(xs, reversed(xs)...)\n\tys := append(upper, reversed(lower)...)\n\n\tdrawPath(canvas, xs, ys, color.Transparent, fill)\n}\n\ntype markSteps struct {\n\tdir StepMode\n\n\tx, y, stroke, fill *scaledData\n}\n\nfunc (m *markSteps) mark(env *renderEnv, canvas *svg.SVG) {\n\txs, ys := env.get(m.x).([]float64), env.get(m.y).([]float64)\n\tvar stroke color.Color = color.Black\n\tif m.stroke != nil {\n\t\tstroke = env.getFirst(m.stroke).(color.Color)\n\t}\n\tvar fill color.Color = color.Transparent\n\tif m.fill != nil {\n\t\tfill = env.getFirst(m.fill).(color.Color)\n\t}\n\n\tif len(xs) == 0 {\n\t\treturn\n\t}\n\n\t// Create intermediate points.\n\txs2, ys2 := make([]float64, 2*len(xs)), make([]float64, 2*len(ys))\n\tfor i := range xs2 {\n\t\tswitch m.dir {\n\t\tcase StepHV, StepVH:\n\t\t\txs2[i], ys2[i] = xs[i/2], ys[i/2]\n\t\tcase StepHMid, StepVMid:\n\t\t\tif i == 0 || i == len(xs2)-1 {\n\t\t\t\txs2[i], ys2[i] = xs[i/2], ys[i/2]\n\t\t\t\tbreak\n\t\t\t}\n\t\t\tvar p1, p2 int\n\t\t\tif i%2 == 0 {\n\t\t\t\t// Interpolate i/2-1 and i/2.\n\t\t\t\tp1, p2 = i/2-1, i/2\n\t\t\t} else {\n\t\t\t\t// Interpolate i/2 and i/2+1.\n\t\t\t\tp1, p2 = i/2, i/2+1\n\t\t\t}\n\t\t\tif m.dir == StepHMid {\n\t\t\t\txs2[i], ys2[i] = (xs[p1]+xs[p2])/2, ys[i/2]\n\t\t\t} else {\n\t\t\t\txs2[i], ys2[i] = xs[i/2], (ys[p1]+ys[p2])/2\n\t\t\t}\n\t\t}\n\t}\n\tif m.dir == StepHV {\n\t\txs2 = xs2[1:]\n\t} else if m.dir == StepVH {\n\t\tys2 = ys2[1:]\n\t}\n\n\tdrawPath(canvas, xs2, ys2, stroke, fill)\n}\n\nfunc drawPath(canvas *svg.SVG, xs, ys []float64, stroke color.Color, fill color.Color) {\n\tswitch len(xs) {\n\tcase 0:\n\t\treturn\n\tcase 1:\n\t\t// TODO: Depending on the stroke cap, this *could* be\n\t\t// well-defined.\n\t\tWarning.Print(\"cannot draw path through 1 point; ignoring\")\n\t\treturn\n\t}\n\n\t// Build path.\n\tvar path []byte\n\tinLine := false\n\tfor i := range xs {\n\t\tif !isFinite(xs[i]) || !isFinite(ys[i]) {\n\t\t\tinLine = false\n\t\t\tcontinue\n\t\t}\n\t\tif !inLine {\n\t\t\tpath = append(path, 'M')\n\t\t\tinLine = true\n\t\t}\n\t\tpath = append(path, ' ')\n\t\tpath = strconv.AppendFloat(path, xs[i], 'g', 6, 64)\n\t\tpath = append(path, ' ')\n\t\tpath = strconv.AppendFloat(path, ys[i], 'g', 6, 64)\n\t}\n\tif len(path) == 0 {\n\t\treturn\n\t}\n\n\t// XXX Stroke width\n\n\tstyle := cssPaint(\"stroke\", stroke) + \";\" + cssPaint(\"fill\", fill) + \";stroke-width:3\"\n\tcanvas.Path(wrapPath(string(path)), style)\n}\n\ntype markPoint struct {\n\tx, y, color, opacity, size *scaledData\n}\n\nfunc (m *markPoint) mark(env *renderEnv, canvas *svg.SVG) {\n\txs, ys := env.get(m.x).([]float64), env.get(m.y).([]float64)\n\tvar colors []color.Color\n\tif m.color != nil {\n\t\tslice.Convert(&colors, env.get(m.color))\n\t}\n\tvar opacities []float64\n\tif m.opacity != nil {\n\t\topacities = env.get(m.opacity).([]float64)\n\t}\n\tvar sizes []float64\n\tif m.size != nil {\n\t\tsizes = env.get(m.size).([]float64)\n\t}\n\tmindim := math.Min(env.Size())\n\n\tfor i := range xs {\n\t\tif !isFinite(xs[i]) || !isFinite(ys[i]) {\n\t\t\tcontinue\n\t\t}\n\n\t\tvar style string\n\t\tif colors != nil {\n\t\t\tstyle = cssPaint(\"fill\", colors[i])\n\t\t}\n\t\tif opacities != nil {\n\t\t\tif style != \"\" {\n\t\t\t\tstyle += \";\"\n\t\t\t}\n\t\t\tstyle += fmt.Sprintf(\"opacity:%.6g\", opacities[i])\n\t\t}\n\t\tr := mindim * 0.01\n\t\tif sizes != nil {\n\t\t\tr = mindim * sizes[i]\n\t\t}\n\t\tcanvas.Circle(int(xs[i]), int(ys[i]), int(r), style)\n\t}\n}\n\ntype markTiles struct {\n\tx, y, fill *scaledData\n}\n\nfunc (m *markTiles) mark(env *renderEnv, canvas *svg.SVG) {\n\txs, ys := env.get(m.x).([]float64), env.get(m.y).([]float64)\n\t// TODO: Should the Scaler (or Ranger) ensure that the values\n\t// are color.Color? How would this work with an identity\n\t// scaler?\n\tvar fills []color.Color\n\tif m.fill != nil {\n\t\tslice.Convert(&fills, env.get(m.fill))\n\t}\n\n\t// TODO: We can't use an this if the width and height\n\t// are specified, or if there is a stroke.\n\t// minx, maxx := stats.Bounds(xs)\n\t// miny, maxy := stats.Bounds(ys)\n\n\t// Compute image bounds.\n\timageBounds := func(vals []float64) (float64, float64, float64, bool) {\n\t\t// Reduce to unique values.\n\t\tunique := []float64{}\n\t\tuset := map[float64]bool{}\n\t\tfor _, v := range vals {\n\t\t\tif !uset[v] {\n\t\t\t\tif !isFinite(v) {\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\t\t\t\tunique = append(unique, v)\n\t\t\t\tuset[v] = true\n\t\t\t}\n\t\t}\n\n\t\tvar minGap float64\n\t\tregular := true\n\t\tswitch len(unique) {\n\t\tcase 0:\n\t\t\treturn 0, 0, -1, false\n\t\tcase 1:\n\t\t\t// TODO: In this case we'll produce a 1 pixel\n\t\t\t// wide/high line. That's probably not what's\n\t\t\t// desired. Maybe we want it to be the\n\t\t\t// width/height of the plot area?\n\t\t\tminGap = 1.0\n\t\tdefault:\n\t\t\tsort.Float64s(unique)\n\t\t\tminGap = unique[1] - unique[0]\n\t\t\tfor i, u := range unique[1:] {\n\t\t\t\tminGap = math.Min(minGap, u-unique[i])\n\t\t\t}\n\t\t\t// Consider the spacing \"regular\" if every\n\t\t\t// point is within a 1000th of a multiple of\n\t\t\t// minGap.\n\t\t\tfor _, u := range unique {\n\t\t\t\t_, error := math.Modf((u - unique[0]) / minGap)\n\t\t\t\tif 0.001 <= error && error <= 0.999 {\n\t\t\t\t\tregular = false\n\t\t\t\t\tbreak\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn unique[0], unique[len(unique)-1], minGap, regular\n\t}\n\txmin, xmax, xgap, xreg := imageBounds(xs)\n\tymin, ymax, ygap, yreg := imageBounds(ys)\n\tif xgap == -1 || ygap == -1 {\n\t\treturn\n\t}\n\tif !xreg || !yreg {\n\t\t// TODO: Can't use an image.\n\t\tpanic(\"not implemented: irregular tile spacing\")\n\t}\n\n\t// TODO: If there are a small number of cells, just make the\n\t// rectangles since it's hard to reliably disable\n\t// interpolation (e.g., the below doesn't work in rsvg).\n\n\t// Create the image.\n\tiw, ih := round((xmax-xmin+xgap)/xgap), round((ymax-ymin+ygap)/ygap)\n\timg := image.NewRGBA(image.Rect(0, 0, iw, ih))\n\tfill := color.Color(color.Black)\n\tfor i := range xs {\n\t\tif !isFinite(xs[i]) || !isFinite(ys[i]) {\n\t\t\tcontinue\n\t\t}\n\t\tif fills != nil {\n\t\t\tfill = fills[i]\n\t\t}\n\t\timg.Set(round((xs[i]-xmin)/xgap), round((ys[i]-ymin)/ygap), fill)\n\t}\n\n\t// Encode the image.\n\turi := bytes.NewBufferString(\"data:image/png;base64,\")\n\tw := base64.NewEncoder(base64.StdEncoding, uri)\n\tif err := png.Encode(w, img); err != nil {\n\t\tWarning.Println(\"error encoding image:\", err)\n\t\treturn\n\t}\n\tw.Close()\n\tcanvas.Image(round(xmin-xgap/2), round(ymin-ygap/2),\n\t\tround(xmax-xmin+xgap), int(ymax-ymin+ygap),\n\t\turi.String(), `preserveAspectRatio=\"none\" style=\"image-rendering:optimizeSpeed;image-rendering:-moz-crisp-edges;image-rendering:-webkit-optimize-contrast;image-rendering:pixelated\"`)\n}\n\ntype markTags struct {\n\tx, y *scaledData\n\tlabels map[table.GroupID]table.Slice\n\thpos float64\n\n\toffsetX, offsetY int\n}\n\nfunc (m *markTags) mark(env *renderEnv, canvas *svg.SVG) {\n\tconst padX = 5\n\n\txs, ys := env.get(m.x).([]float64), env.get(m.y).([]float64)\n\tif len(xs) == 0 {\n\t\treturn\n\t}\n\n\t// Find the point closest to hpos between the min and max.\n\t//\n\t// TODO: Give the user control over this.\n\tminx, maxx := stats.Bounds(xs)\n\ttargetx := minx + (maxx-minx)*m.hpos\n\tmidi, middelta := 0, math.Abs(xs[0]-targetx)\n\tfor i, x := range xs {\n\t\tdelta := math.Abs(x - targetx)\n\t\tif delta < middelta {\n\t\t\tmidi, middelta = i, delta\n\t\t}\n\t}\n\n\t// Get label.\n\tlabel := fmt.Sprint(reflect.ValueOf(m.labels[env.gid]).Index(midi).Interface())\n\n\t// Attach tag to this point.\n\t//\n\t// TODO: More user control.\n\t//\n\t// TODO: Make automatic positioning account for bounds of plot.\n\t//\n\t// TODO: Adjust positions to avoid overlap. Unfortunately,\n\t// this requires some global optimization, but mark only sees\n\t// one tag at a time.\n\t//\n\t// TODO: Re-enable the tag box when I have decent text metrics.\n\t//t := measureString(fontSize, label)\n\t//canvas.Rect(int(xs[midi]+offsetX-t.width), int(ys[midi]+offsetY-0.75*t.leading), int(t.width), int(1.5*t.leading), `rx=\"4\"`, `fill=\"white\"`, `stroke=\"black\"`)\n\tif m.offsetX > 0 {\n\t\t// To the right, left-aligned.\n\t\tcanvas.Text(int(xs[midi])+m.offsetX+padX, int(ys[midi])+m.offsetY, label, `dy=\".3em\"`)\n\t} else {\n\t\tcanvas.Text(int(xs[midi])+m.offsetX-padX, int(ys[midi])+m.offsetY, label, `dy=\".3em\"`, `text-anchor=\"end\"`)\n\t}\n\tcanvas.Path(fmt.Sprintf(\"M%.6g %.6gc%.6g %.6g,%.6g %.6g,%.6g %.6g\", xs[midi], ys[midi], 0.8*float64(m.offsetX), 0.0, 0.2*float64(m.offsetX), float64(m.offsetY), float64(m.offsetX), float64(m.offsetY)), `fill=\"none\"`, `stroke=\"black\"`, `stroke-dasharray=\"2, 3\"`, `stroke-width=\"2\"`)\n}\n\ntype markTooltips struct {\n\tx, y *scaledData\n\tlabels map[table.GroupID]table.Slice\n}\n\nfunc (m *markTooltips) mark(env *renderEnv, canvas *svg.SVG) {\n\t// Construct JSON for data.\n\txs, ys := env.get(m.x).([]float64), env.get(m.y).([]float64)\n\tif len(xs) == 0 {\n\t\treturn\n\t}\n\tvar labels []string\n\tswitch l2 := m.labels[env.gid].(type) {\n\tcase []string:\n\t\tlabels = l2\n\tdefault:\n\t\tl2v := reflect.ValueOf(l2)\n\t\tlabels = make([]string, l2v.Len())\n\t\tfor i := range labels {\n\t\t\tlabels[i] = fmt.Sprint(l2v.Index(i).Interface())\n\t\t}\n\t}\n\n\t// TODO: Make env able to generate IDs.\n\t//\n\t// TODO: Sort by x and use binary search in Javascript.\n\t//\n\t// TODO: Remove points that round to the same coordinate.\n\t//\n\t// TODO: Put on the left if we're close to the right edge.\n\tid := fmt.Sprintf(\"tooltips%p\", env)\n\tvar buf bytes.Buffer\n\tfmt.Fprintf(&buf, \"var %s = \", id)\n\tdata := struct {\n\t\tX []int `json:\"x\"`\n\t\tY []int `json:\"y\"`\n\t\tL []string `json:\"l\"`\n\t}{make([]int, 0, len(xs)), make([]int, 0, len(ys)), labels}\n\tfor i := range xs {\n\t\tif !isFinite(xs[i]) || !isFinite(ys[i]) {\n\t\t\tcontinue\n\t\t}\n\t\t// Round data to an int to save space.\n\t\tdata.X = append(data.X, int(xs[i]+0.5))\n\t\tdata.Y = append(data.Y, int(ys[i]+0.5))\n\t}\n\tif len(data.X) == 0 {\n\t\treturn\n\t}\n\tjson.NewEncoder(&buf).Encode(data)\n\tcanvas.Script(\"text/javascript\", buf.String())\n\n\tcanvas.Path(\"\", `display=\"none\"`, `fill=\"white\"`, `stroke=\"black\"`, fmt.Sprintf(`id=\"%s-p\"`, id))\n\tcanvas.Text(0, 0, \"\", `display=\"none\"`, fmt.Sprintf(`id=\"%s-t\"`, id))\n\n\tpx, _, pw, _ := env.Area()\n\tcanvas.Rect(int(env.area[0]), int(env.area[1]), int(env.area[2]), int(env.area[3]), `fill-opacity=\"0\"`, fmt.Sprintf(`onmousemove=\"tooltipMove(evt,%s,"%s",%v,%v)\"`, id, id, px, px+pw), fmt.Sprintf(`onmouseout=\"tooltipOut(evt,%s,"%s")\"`, id, id))\n\n\t// TODO: Only write this once per SVG.\n\tcanvas.Script(\"text/javascript\", `\nfunction tooltipMove(evt, data, tid, minx, maxx) {\n\t// Convert evt.x to an SVG coordinate.\n\tvar svg = document.rootElement;\n\tvar pt = svg.createSVGPoint();\n\tpt.x = evt.clientX;\n\tpt.y = evt.clientY;\n\tvar epos = pt.matrixTransform(svg.getScreenCTM().inverse());\n\n\t// Find data point closest to event coordinate.\n\tvar cd = Math.sqrt(Math.pow(epos.x-data.x[0], 2) + Math.pow(epos.y-data.y[0], 2)), ci = 0;\n\tfor (var i = 1; i < data.x.length; i++) {\n\t\tvar d = Math.sqrt(Math.pow(epos.x-data.x[i], 2) + Math.pow(epos.y-data.y[i], 2));\n\t\tif (d < cd) { cd = d; ci = i; }\n\t}\n\n\t// Update text content and position.\n\tvar text = document.getElementById(tid+\"-t\");\n\ttext.textContent = data.l[ci];\n\ttext.style.display = \"block\";\n\ttext.setAttribute(\"x\", 0);\n\ttext.setAttribute(\"y\", 0);\n\tvar bb = text.getBBox();\n\tvar hm = 2, r = 3;\n\tvar tx = data.x[ci] + bb.height/4 + hm;\n\tvar flip = false;\n\tif (tx + bb.width + 2*hm + r > maxx) {\n\t\tvar tx2 = data.x[ci] - bb.height/4 - hm - bb.width;\n\t\tif (tx2 - 2*hm - r >= minx) {\n\t\t\t// Position left of point.\n\t\t\ttx = tx2;\n\t\t\tflip = true;\n\t\t}\n\t}\n\ttext.setAttribute(\"x\", tx);\n\ttext.setAttribute(\"y\", data.y[ci] - (bb.y + bb.height/2));\n\n\t// Update marker.\n\tvar p = document.getElementById(tid+\"-p\");\n\tif (flip) {\n\t\tp.setAttribute(\"transform\", \"translate(\"+2*data.x[ci]+\",0) scale(-1,1)\")\n\t} else {\n\t\tp.setAttribute(\"transform\", \"\")\n\t}\n\tp.setAttribute(\"d\", \"M\"+data.x[ci]+\",\"+data.y[ci]+\n\t\t\"l\"+(bb.height/4)+\",\"+(-bb.height/2)+\n\t\t\"h\"+(bb.width+2*hm)+\n\t\t\"a\"+r+\",\"+r+\",90,0,1,\"+r+\",\"+r+\n\t\t\"v\"+(bb.height-2*r)+\n\t\t\"a\"+r+\",\"+r+\",90,0,1,\"+(-r)+\",\"+r+\n\t\t\"h\"+(-bb.width-2*hm)+\"z\");\n\tp.style.display = \"block\";\n}\nfunction tooltipOut(evt, data, tid) {\n\tvar text = document.getElementById(tid+\"-t\");\n\ttext.style.display = \"none\";\n\tvar p = document.getElementById(tid+\"-p\");\n\tp.style.display = \"none\";\n}\n`)\n}\n\n// cssPaint returns a CSS fragment for setting CSS property prop to\n// color c.\nfunc cssPaint(prop string, c color.Color) string {\n\tr, g, b, a := c.RGBA()\n\tif a == 0 {\n\t\t// No paint.\n\t\treturn prop + \":none\"\n\t}\n\n\tif a != 0xffff {\n\t\t// Undo alpha pre-multiplication.\n\t\tr = r * 0xffff / a\n\t\tg = g * 0xffff / a\n\t\tb = b * 0xffff / a\n\t}\n\tr, g, b = r>>8, g>>8, b>>8\n\n\tcss := prop\n\tif r>>4 == r&0xF && g>>4 == g&0xF && b>>4 == b&0xF {\n\t\t// Use #rgb form.\n\t\tcss += fmt.Sprintf(\":#%x%x%x\", r>>4, g>>4, b>>4)\n\t} else {\n\t\t// Use #rrggbb form.\n\t\tcss += fmt.Sprintf(\":#%02x%02x%02x\", r, g, b)\n\t}\n\n\tif a != 0xffff {\n\t\t// SVG 1.1 only supports CSS2 color formats, which\n\t\t// unfortunately does not include rgba, so we have to\n\t\t// use a separate CSS property.\n\t\tcss += \";\" + prop + \"-opacity:\" + strconv.FormatFloat(float64(a)/0xffff, 'g', 0, 64)\n\t}\n\treturn css\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/gg/package.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// Package gg creates plots using the Grammar of Graphics.\n//\n// WARNING: This API is highly unstable. For now, please vendor this\n// package.\n//\n// gg creates statistical visualizations. It's designed to help users\n// quickly navigate and explore complex data in different ways, both\n// in terms of what they're plotting and how they're plotting it. This\n// focus on rapid exploration of complex data leads to a very\n// different design than typical plotting packages.\n//\n// gg is heavily inspired by Wilkinson's Grammar of Graphics [1]. A\n// key observation of the Grammar of Graphics is that there are many\n// motifs across different types of plots. The Grammar of Graphics\n// separates these motifs into orthogonal concerns that can be\n// manipulated and extended independently, enabling the creation of\n// traditional plot types from their fundamental components as well as\n// the creation of entirely new plot types.\n//\n// Data model\n//\n// Central to gg is its data model. At the most basic level, the input\n// data consists of a table with a set of named columns, with the rows\n// organized into one or more groups. At a higher level, because gg\n// makes it easy to restructure data before plotting it, it expects to\n// start with regularized input data, where each column represents a\n// distinct independent or dependent variable. In other words, any two\n// values that make sense to plot on the same axis should be in the\n// same column.\n//\n// For example, to express a line graph with several series of\n// different colors in gg, you would say \"plot column A against column\n// B, grouped into series and colored according to column C\". In\n// contrast, typical plotting packages use a \"spreadsheet\" model,\n// where each data series is a separate column, so expressing the same\n// graph requires saying \"plot column A against column B in color 1\n// and plot column A against column C in color 2\" and so on.\n//\n// gg's approach is suited to exploratory data analysis because you\n// don't have to restructure the data to see it in a different way. In\n// the traditional spreadsheet model, you have to structure the data\n// to match the plot. In gg, you tell the plot what structure to\n// extract from the data.\n//\n// Layers and scales\n//\n// To visualize data, gg provides a set of composable plot building\n// blocks. There are no fixed \"plot types\" in gg. The main building\n// block is a \"layer\", which transforms a data set into a set of\n// visual marks, such as lines, points, or rectangles. Each layer is\n// configured by mapping columns of the data set to different\n// \"aesthetics\". An aesthetic is a generalization of a dimension: X\n// and Y are aesthetics, but so are color and stroke width and point\n// shape. Unlike typical plotting packages, these various aesthetics\n// are treated symmetrically and any aesthetic can be fed from any\n// column of the data.\n//\n// Layers work in close concert with \"scales\", which map from values\n// in the data space to values in the visual space. Scales can map\n// from continuous or discrete data values (such as numbers or\n// strings) to continuous or discrete visual values (such as pixel\n// offsets or point shapes). Each aesthetic has an associated scale.\n// If the user hasn't provided a specific scale for an aesthetic, gg\n// uses a default scale that guesses what to do based on the data type\n// and aesthetic.\n//\n// Stats\n//\n// Data can be pre-processed prior to rendering it with a layer using\n// a \"stat\". A stat can be an arbitrary data transformation, but it's\n// typically used to compute statistical summaries, such as the\n// five-number summary (e.g., for a box plot), a linear regression, or\n// a density estimate.\n//\n// TODO: \"Compound\" layers?\n//\n// Facets\n//\n// TODO.\n//\n// Aesthetics\n//\n// gg understands the following aesthetics.\n//\n// \"x\" and \"y\" give the offset from the lower-left corner of a plot.\n// Their ranges are always set to the pixel coordinates of the X and Y\n// axes, respectively, and cannot be overridden.\n//\n// \"stroke\" and \"fill\" give the stroke and fill colors of paths and\n// points. Their ranger must have type color.Color. The default ranger\n// returns a single-hue gradient for continuous data, or a categorical\n// palette for discrete data.\n//\n// \"opacity\" gives the overall opacity of a mark. Its ranger must have\n// type float64 and give values between 0 and 1, inclusive. The\n// default ranger ranges from 10% opaque (0.1) to fully opaque (1.0).\n//\n// \"size\" gives the size of marks. Its ranger must have type float64\n// and yields values that are relative to the smallest dimension of\n// the plot area (e.g., a value of 0.5 creates a point that cover half\n// of the plot width or height, whichever is smaller). The default\n// ranger ranges from 1% (0.01) to 10% (0.1).\n//\n// Related work\n//\n// gg draws ideas and inspiration from many sources. The core\n// principle of a Grammar of Graphics was introduced by Wiklinson [1].\n// There have been many implementations in many languages. The most\n// popular is certainly Wickham's ggplot2 for R [2]. gg draws most\n// heavily on Wickham's follow-up work on ggvis for R [3].\n//\n// [1] Leland Wilkinson, The Grammar of Graphics, Springer, 1999.\n//\n// [2] Hadley Wickham, ggplot2: Elegant Graphics for Data Analysis,\n// Springer, 2009.\n//\n// [3] Hadley Wickham, ggvis, http://ggvis.rstudio.com/.\n//\n// TODO: Scale transforms, coordinate spaces.\npackage gg\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/gg/plot.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage gg\n\nimport (\n\t\"fmt\"\n\t\"log\"\n\t\"os\"\n\n\t\"github.com/aclements/go-gg/table\"\n)\n\n// TODO: Split transforms, scalers, and layers into their own packages\n// to clean up the name spaces and un-prefix their names?\n\n// Warning is a logger for reporting conditions that don't prevent the\n// production of a plot, but may lead to unexpected results.\nvar Warning = log.New(os.Stderr, \"[gg] \", log.Lshortfile)\n\n// Plot represents a single (potentially faceted) plot.\ntype Plot struct {\n\tenv *plotEnv\n\tscales map[string]scalerTree\n\n\tscaledData map[scaledDataKey]*scaledData\n\tscaleSet map[scaleKey]bool\n\tmarks []plotMark\n\n\taxisLabels map[string]string\n\tautoAxisLabels map[string][]string\n\n\ttitle string\n\n\tconstNonce int\n}\n\n// NewPlot returns a new Plot backed by data. It has no layers, one\n// facet, and all scales are default.\nfunc NewPlot(data table.Grouping) *Plot {\n\tp := &Plot{\n\t\tenv: &plotEnv{\n\t\t\tdata: data,\n\t\t},\n\t\tscales: make(map[string]scalerTree),\n\t\tscaledData: make(map[scaledDataKey]*scaledData),\n\t\tscaleSet: make(map[scaleKey]bool),\n\t\taxisLabels: make(map[string]string),\n\t\tautoAxisLabels: make(map[string][]string),\n\t}\n\treturn p\n}\n\ntype plotEnv struct {\n\tparent *plotEnv\n\tdata table.Grouping\n}\n\ntype scaleKey struct {\n\tgid table.GroupID\n\taes string\n\tscale Scaler\n}\n\n// SetData sets p's current data table. The caller must not modify\n// data in this table after this point.\nfunc (p *Plot) SetData(data table.Grouping) *Plot {\n\tp.env.data = data\n\treturn p\n}\n\n// Data returns p's current data table.\nfunc (p *Plot) Data() table.Grouping {\n\treturn p.env.data\n}\n\n// Const creates a new constant column bound to val in all groups and\n// returns the generated column name. This is a convenient way to pass\n// constant values to layers as columns.\n//\n// TODO: Typically this should be used with PreScaled or physical types.\nfunc (p *Plot) Const(val interface{}) string {\n\ttab := p.Data()\n\nretry:\n\tcol := fmt.Sprintf(\"[gg-const-%d]\", p.constNonce)\n\tp.constNonce++\n\tfor _, col2 := range tab.Columns() {\n\t\tif col == col2 {\n\t\t\tgoto retry\n\t\t}\n\t}\n\n\tp.SetData(table.MapTables(tab, func(_ table.GroupID, t *table.Table) *table.Table {\n\t\treturn table.NewBuilder(t).AddConst(col, val).Done()\n\t}))\n\n\treturn col\n}\n\ntype scalerTree struct {\n\tscales map[table.GroupID]Scaler\n}\n\nfunc newScalerTree() scalerTree {\n\treturn scalerTree{map[table.GroupID]Scaler{\n\t\ttable.RootGroupID: &defaultScale{},\n\t}}\n}\n\nfunc (t scalerTree) bind(gid table.GroupID, s Scaler) {\n\t// Unbind scales under gid.\n\tfor ogid := range t.scales {\n\t\tif gid == table.RootGroupID {\n\t\t\t// Optimize binding the root GID.\n\t\t\tdelete(t.scales, ogid)\n\t\t\tcontinue\n\t\t}\n\n\t\tfor p := ogid; ; p = p.Parent() {\n\t\t\tif p == gid {\n\t\t\t\tdelete(t.scales, ogid)\n\t\t\t\tbreak\n\t\t\t}\n\t\t\tif p == table.RootGroupID {\n\t\t\t\tbreak\n\t\t\t}\n\t\t}\n\t}\n\tt.scales[gid] = s\n}\n\nfunc (t scalerTree) find(gid table.GroupID) Scaler {\n\tfor {\n\t\tif s, ok := t.scales[gid]; ok {\n\t\t\treturn s\n\t\t}\n\t\tif gid == table.RootGroupID {\n\t\t\t// This should never happen.\n\t\t\tpanic(\"no scale for group \" + gid.String())\n\t\t}\n\t\tgid = gid.Parent()\n\t}\n}\n\nfunc (p *Plot) getScales(aes string) scalerTree {\n\tst, ok := p.scales[aes]\n\tif !ok {\n\t\tst = newScalerTree()\n\t\tp.scales[aes] = st\n\t}\n\treturn st\n}\n\nfunc (p *Plot) copyScales(old, new table.GroupID) {\n\tfor _, st := range p.scales {\n\t\tst.scales[new] = st.find(old)\n\t}\n}\n\n// SetScale binds a scale to the given visual aesthetic. SetScale is\n// shorthand for SetScaleAt(aes, s, table.RootGroupID). SetScale must\n// be called before Add.\n//\n// SetScale returns p for ease of chaining.\nfunc (p *Plot) SetScale(aes string, s Scaler) *Plot {\n\treturn p.SetScaleAt(aes, s, table.RootGroupID)\n}\n\n// SetScaleAt binds a scale to the given visual aesthetic for all data\n// in group gid or descendants of gid. SetScaleAt must be called\n// before Add.\nfunc (p *Plot) SetScaleAt(aes string, s Scaler, gid table.GroupID) *Plot {\n\t// TODO: Should aes be an enum so you can't mix up aesthetics\n\t// and column names?\n\tp.getScales(aes).bind(gid, s)\n\treturn p\n}\n\n// GetScale returns the scale for the given visual aesthetic used for\n// data in the root group.\nfunc (p *Plot) GetScale(aes string) Scaler {\n\treturn p.GetScaleAt(aes, table.RootGroupID)\n}\n\n// GetScaleAt returns the scale for the given visual aesthetic used\n// for data in group gid.\nfunc (p *Plot) GetScaleAt(aes string, gid table.GroupID) Scaler {\n\treturn p.getScales(aes).find(gid)\n}\n\ntype scaledDataKey struct {\n\taes string\n\tdata table.Grouping\n\tcol string\n}\n\n// use binds a column of data to an aesthetic. It expands the domain\n// of the aesthetic's scale to include the data in col, and returns\n// the scaled data.\n//\n// col may be \"\", in which case it simply returns nil.\n//\n// TODO: Should aes be an enum?\nfunc (p *Plot) use(aes string, col string) *scaledData {\n\tif col == \"\" {\n\t\treturn nil\n\t}\n\n\t// TODO: This is wrong. If the scale tree for aes changes,\n\t// this may return a stale scaledData bound to the wrong\n\t// scalers. If I got rid of scale trees, I could just put the\n\t// scaler in the key. Or I could clean up the cache when the\n\t// scale tree changes.\n\n\tsd := p.scaledData[scaledDataKey{aes, p.Data(), col}]\n\tif sd == nil {\n\t\t// Construct the scaledData.\n\t\tsd = &scaledData{\n\t\t\tseqs: make(map[table.GroupID]scaledSeq),\n\t\t}\n\n\t\t// Get the scale tree.\n\t\tst := p.getScales(aes)\n\n\t\tfor _, gid := range p.Data().Tables() {\n\t\t\ttable := p.Data().Table(gid)\n\n\t\t\t// Get the data.\n\t\t\tseq := table.MustColumn(col)\n\n\t\t\t// Find the scale.\n\t\t\tscaler := st.find(gid)\n\n\t\t\t// Add the scale to the scale set.\n\t\t\tp.scaleSet[scaleKey{gid, aes, scaler}] = true\n\n\t\t\t// Train the scale.\n\t\t\tif _, ok := seq.([]Unscaled); !ok {\n\t\t\t\tscaler.ExpandDomain(seq)\n\t\t\t}\n\n\t\t\t// Add it to the scaledData.\n\t\t\tsd.seqs[gid] = scaledSeq{seq, scaler}\n\t\t}\n\n\t\tp.scaledData[scaledDataKey{aes, p.Data(), col}] = sd\n\t}\n\n\t// Update axis labels.\n\tif aes == \"x\" || aes == \"y\" {\n\t\tp.autoAxisLabels[aes] = append(p.autoAxisLabels[aes], col)\n\t}\n\n\treturn sd\n}\n\n// Save saves the current data table of p to a stack.\nfunc (p *Plot) Save() *Plot {\n\tp.env = &plotEnv{\n\t\tparent: p.env,\n\t\tdata: p.env.data,\n\t}\n\treturn p\n}\n\n// Restore restores the data table of p from the save stack.\nfunc (p *Plot) Restore() *Plot {\n\tif p.env.parent == nil {\n\t\tpanic(\"unbalanced Save/Restore\")\n\t}\n\tp.env = p.env.parent\n\treturn p\n}\n\n// A Plotter is an operation that can modify a Plot.\ntype Plotter interface {\n\tApply(*Plot)\n}\n\n// Add applies each of plotters to Plot in order.\nfunc (p *Plot) Add(plotters ...Plotter) *Plot {\n\tfor _, plotter := range plotters {\n\t\tplotter.Apply(p)\n\t}\n\treturn p\n}\n\n// AxisLabel returns a Plotter that sets the label of an axis on a\n// Plot. By default, Plot constructs automatic axis labels from column\n// names, but AxisLabel lets callers override these.\n//\n// TODO: Should labels be attached to aesthetics, generally?\n//\n// TODO: Should this really be a Plotter or just a method of Plot?\nfunc AxisLabel(axis, label string) Plotter {\n\treturn axisLabel{axis, label}\n}\n\ntype axisLabel struct {\n\taxis, label string\n}\n\nfunc (a axisLabel) Apply(p *Plot) {\n\tp.axisLabels[a.axis] = a.label\n}\n\n// Title returns a Plotter that sets the title of a Plot.\nfunc Title(label string) Plotter {\n\treturn titlePlotter{label}\n}\n\ntype titlePlotter struct {\n\tlabel string\n}\n\nfunc (t titlePlotter) Apply(p *Plot) {\n\tp.title = t.label\n}\n\n// A Stat transforms a table.Grouping.\ntype Stat interface {\n\tF(table.Grouping) table.Grouping\n}\n\n// Stat applies each of stats in order to p's data.\n//\n// TODO: Perform scale transforms before applying stats.\nfunc (p *Plot) Stat(stats ...Stat) *Plot {\n\tdata := p.Data()\n\tfor _, stat := range stats {\n\t\tdata = stat.F(data)\n\t}\n\treturn p.SetData(data)\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/gg/render.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage gg\n\nimport (\n\t\"bytes\"\n\t\"fmt\"\n\t\"io\"\n\t\"math\"\n\t\"reflect\"\n\t\"strings\"\n\n\t\"github.com/aclements/go-gg/generic/slice\"\n\t\"github.com/aclements/go-gg/table\"\n\t\"github.com/ajstarks/svgo\"\n)\n\n// fontSize is the font size in pixels.\n//\n// TODO: Theme.\nconst fontSize float64 = 14\n\n// facetLabelHeight is the height of facet labels, as a multiple of\n// the font height.\n//\n// TODO: Should this be a multiple of fontSize, em height, leading?\n// Currently it's leading.\n//\n// TODO: Theme.\nconst facetLabelHeight = 1.3\n\nconst xTickSep = 5 // TODO: Theme.\n\nconst yTickSep = 5 // TODO: Theme.\n\n// plotMargins returns the top, right, bottom, and left margins for a\n// plot of the given width and height.\n//\n// By default, this adds a 5% margin based on the smaller of width and\n// height. This ensures that (with automatic scales), the extremes of\n// the data and its tick labels don't appear right at the edge of the\n// plot area.\n//\n// TODO: Theme.\nvar plotMargins = func(w, h float64) (t, r, b, l float64) {\n\tmargin := 0.05 * math.Min(w, h)\n\treturn margin, margin, margin, margin\n}\n\nfunc (p *Plot) WriteSVG(w io.Writer, width, height int) error {\n\t// TODO: Legend, title.\n\n\t// TODO: Check if the same scaler is used for multiple\n\t// aesthetics with conflicting rangers. Alternatively, if we\n\t// just computed the scaled data eagerly here, it wouldn't\n\t// matter if the same Scaler was used for multiple things\n\t// because we would just change its Ranger between scaling\n\t// different data. We could still optimize for get/get1 by\n\t// specifying whether we care about all of the values or just\n\t// the first when fetching the scaledData (arguably this\n\t// should also affect scale training, so this is necessary\n\t// anyway).\n\n\t// TODO: Rather than finding these scales here and giving them\n\t// Ratners, we could use special \"Width\"/\"Height\" Rangers and\n\t// assign them much earlier (e.g., when they are Used). We\n\t// could then either find all of the scales that have those\n\t// Rangers and configure them at this point, or we could pass\n\t// the renderEnv in when ranging.\n\n\t// TODO: Default ranges for other things like color.\n\n\t// TODO: Expose the layout so a package user can put together\n\t// multiple Plots.\n\t//\n\t// What if the user wants multiple aligned plots, but as\n\t// *different* images (e.g., flipping from one slide to\n\t// another)?\n\n\t// TODO: Let the user alternatively specify the width and\n\t// height of the subplots, rather than the whole plot.\n\n\t// TODO: Automatic aspect ratio by averaging slopes.\n\n\t// TODO: Custom tick breaks.\n\n\t// TODO: Make sure *all* Scalers have Rangers or the user will\n\t// get confusing panics.\n\n\t// TODO: If the user restricts, say, the X range, should that\n\t// only train the Y axis on what's in the X range?\n\n\t// Assign default Rangers to scales that don't have them.\n\t//\n\t// TODO: Do this on a clone of the scale so this doesn't\n\t// persist.\n\tfor aes, scales := range p.scales {\n\t\tif aes == \"x\" || aes == \"y\" {\n\t\t\t// We'll assign these when we render each\n\t\t\t// subplot.\n\t\t\tcontinue\n\t\t}\n\t\tfor _, scale := range scales.scales {\n\t\t\tif scale.Ranger(nil) == nil {\n\t\t\t\tscale.Ranger(defaultRanger(aes))\n\t\t\t}\n\t\t}\n\t}\n\n\t// Find all of the subplots and subdivide the marks.\n\t//\n\t// TODO: If a mark was done in a parent subplot, broadcast it\n\t// to all child leafs of that subplot.\n\tsubplots := make(map[*subplot]*eltSubplot)\n\tplotElts := []plotElt{}\n\tfor _, mark := range p.marks {\n\t\tsubmarks := make(map[*eltSubplot]plotMark)\n\t\tfor _, gid := range mark.groups {\n\t\t\tsubplot := subplotOf(gid)\n\t\t\telt := subplots[subplot]\n\t\t\tif elt == nil {\n\t\t\t\telt = newEltSubplot(subplot)\n\t\t\t\tplotElts = append(plotElts, elt)\n\t\t\t\tsubplots[subplot] = elt\n\t\t\t}\n\n\t\t\tsubmark := submarks[elt]\n\t\t\tsubmark.m = mark.m\n\t\t\tsubmark.groups = append(submark.groups, gid)\n\t\t\tsubmarks[elt] = submark\n\t\t}\n\t\tfor subplot, submark := range submarks {\n\t\t\tsubplot.marks = append(subplot.marks, submark)\n\t\t}\n\t}\n\t// Subdivide the scales.\n\tfor sk := range p.scaleSet {\n\t\tsubplot := subplotOf(sk.gid)\n\t\telt := subplots[subplot]\n\t\tif elt == nil {\n\t\t\tcontinue\n\t\t}\n\t\tss := elt.scales[sk.aes]\n\t\tif ss == nil {\n\t\t\tss = make(map[Scaler]bool)\n\t\t\telt.scales[sk.aes] = ss\n\t\t}\n\t\tss[sk.scale] = true\n\t}\n\n\t// Add ticks and facet labels.\n\tplotElts = addSubplotLabels(plotElts)\n\n\t// Add axis labels and title.\n\tvar xlabel, ylabel string\n\tif l, ok := p.axisLabels[\"x\"]; ok {\n\t\txlabel = l\n\t} else {\n\t\txlabel = strings.Join(slice.Nub(p.autoAxisLabels[\"x\"]).([]string), \"\\n\")\n\t}\n\tif l, ok := p.axisLabels[\"y\"]; ok {\n\t\tylabel = l\n\t} else {\n\t\tylabel = strings.Join(slice.Nub(p.autoAxisLabels[\"y\"]).([]string), \"\\n\")\n\t}\n\tplotElts = addAxisLabels(plotElts, p.title, xlabel, ylabel)\n\n\t// Compute plot element layout.\n\tlayout := layoutPlotElts(plotElts)\n\n\t// Perform layout. There's a cyclic dependency involving tick\n\t// labels here: the tick labels depend on how many ticks there\n\t// are, how many ticks there are depends on the size of the\n\t// plot, the size of the plot depends on its surrounding\n\t// content, and the size of the surrounding content depends on\n\t// the tick labels. There may not be a fixed point here, so we\n\t// compromise around the number of ticks.\n\t//\n\t// 1) Lay out the graphs without ticks.\n\tlayout.SetLayout(0, 0, float64(width), float64(height))\n\t// 2) Compute the number of ticks and tick labels for each\n\t// tick element.\n\tfor _, elt := range plotElts {\n\t\tif elt, ok := elt.(*eltTicks); ok {\n\t\t\telt.computeTicks()\n\t\t}\n\t}\n\t// 3) Re-layout the plot and stick with the ticks we computed.\n\tlayout.SetLayout(0, 0, float64(width), float64(height))\n\n\t// Draw.\n\tsvg := svg.New(w)\n\tsvg.Start(width, height, fmt.Sprintf(`font-size=\"%.6gpx\" font-family=\"Roboto,"Helvetica Neue",Helvetica,Arial,sans-serif\"`, fontSize))\n\tdefer svg.End()\n\n\t// Render each plot element.\n\tr := &eltRender{svg, 0}\n\tfor _, elt := range plotElts {\n\t\telt.render(r)\n\t}\n\n\treturn nil\n}\n\nfunc (e *eltSubplot) render(r *eltRender) {\n\tsvg := r.svg\n\tx, y, w, h := e.Layout()\n\tm := e.plotMargins\n\n\t// Round the bounds rectangle in.\n\tx2i, y2i := int(x+w), int(y+h)\n\txi, yi := int(math.Ceil(x)), int(math.Ceil(y))\n\twi, hi := x2i-xi, y2i-yi\n\n\t// Create clip region for plot area.\n\tclipId, clipRef := r.genid(\"clip\")\n\tsvg.ClipPath(`id=\"` + clipId + `\"`)\n\tsvg.Rect(xi, yi, wi, hi)\n\tsvg.ClipEnd()\n\tsvg.Group(`clip-path=\"` + clipRef + `\"`)\n\n\t// Set scale ranges.\n\txRanger := NewFloatRanger(float64(xi)+m.l, float64(x2i)-m.r)\n\tyRanger := NewFloatRanger(float64(y2i)-m.b, float64(yi)+m.t)\n\tfor s := range e.scales[\"x\"] {\n\t\ts.Ranger(xRanger)\n\t}\n\tfor s := range e.scales[\"y\"] {\n\t\ts.Ranger(yRanger)\n\t}\n\n\t// Render grid.\n\trenderBackground(svg, xi, yi, wi, hi)\n\tfor s := range e.scales[\"x\"] {\n\t\trenderGrid(svg, 'x', s, e.xTicks.ticks[s], yi, y2i)\n\t}\n\tfor s := range e.scales[\"y\"] {\n\t\trenderGrid(svg, 'y', s, e.yTicks.ticks[s], xi, x2i)\n\t}\n\n\t// Create rendering environment.\n\tenv := &renderEnv{\n\t\tcache: make(map[renderCacheKey]table.Slice),\n\t\tarea: [4]float64{float64(xi), float64(yi), float64(wi), float64(hi)},\n\t}\n\n\t// Render marks.\n\tfor _, mark := range e.marks {\n\t\tfor _, gid := range mark.groups {\n\t\t\tenv.gid = gid\n\t\t\tmark.m.mark(env, svg)\n\t\t}\n\t}\n\n\t// End clip region.\n\tsvg.Gend()\n\n\t// Draw border and scale ticks.\n\t//\n\t// TODO: Theme.\n\n\t// Render border.\n\tsvg.Path(fmt.Sprintf(\"M%d %dV%dH%d\", xi, yi, y2i, x2i), \"stroke:#888; fill:none; stroke-width:2\") // TODO: Theme.\n\n\t// Render scale ticks.\n\tfor s := range e.scales[\"x\"] {\n\t\trenderScale(svg, 'x', s, e.xTicks.ticks[s], y2i)\n\t}\n\tfor s := range e.scales[\"y\"] {\n\t\trenderScale(svg, 'y', s, e.yTicks.ticks[s], xi)\n\t}\n}\n\n// TODO: Use shape-rendering: crispEdges?\n\nfunc renderBackground(svg *svg.SVG, x, y, w, h int) {\n\tsvg.Rect(x, y, w, h, \"fill:#eee\") // TODO: Theme.\n}\n\nfunc renderGrid(svg *svg.SVG, dir rune, scale Scaler, ticks plotEltTicks, start, end int) {\n\tmajor := mapMany(scale, ticks.major).([]float64)\n\n\tr := func(x float64) float64 {\n\t\t// Round to nearest N.\n\t\treturn math.Floor(x + 0.5)\n\t}\n\n\tvar path []string\n\tfor _, p := range major {\n\t\tif dir == 'x' {\n\t\t\tpath = append(path, fmt.Sprintf(\"M%.6g %dv%d\", r(p), start, end-start))\n\t\t} else {\n\t\t\tpath = append(path, fmt.Sprintf(\"M%d %.6gh%d\", start, r(p), end-start))\n\t\t}\n\t}\n\n\tsvg.Path(wrapPath(strings.Join(path, \"\")), \"stroke: #fff; stroke-width:2\") // TODO: Theme.\n}\n\nfunc renderScale(svg *svg.SVG, dir rune, scale Scaler, ticks plotEltTicks, pos int) {\n\tconst length float64 = 4 // TODO: Theme\n\n\tvar path bytes.Buffer\n\thave := map[float64]bool{}\n\tfor _, t := range []struct {\n\t\tlength float64\n\t\ts table.Slice\n\t}{\n\t\t{length * 2, ticks.major},\n\t\t{length, ticks.minor},\n\t} {\n\t\tticks := mapMany(scale, t.s).([]float64)\n\n\t\tr := func(x float64) float64 {\n\t\t\t// Round to nearest N.\n\t\t\treturn math.Floor(x + 0.5)\n\t\t}\n\t\tfor _, p := range ticks {\n\t\t\tp = r(p)\n\t\t\tif have[p] {\n\t\t\t\t// Avoid overplotting the same tick\n\t\t\t\t// marks.\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\thave[p] = true\n\t\t\tif dir == 'x' {\n\t\t\t\tfmt.Fprintf(&path, \"M%.6g %dv%.6g\", p, pos, -t.length)\n\t\t\t} else {\n\t\t\t\tfmt.Fprintf(&path, \"M%d %.6gh%.6g\", pos, p, t.length)\n\t\t\t}\n\t\t}\n\n\t}\n\tsvg.Path(wrapPath(path.String()), \"stroke:#888; stroke-width:2\") // TODO: Theme\n}\n\nfunc (e *eltTicks) render(r *eltRender) {\n\tsvg := r.svg\n\tx, y, w, _ := e.Layout()\n\tfor s := range e.scales() {\n\t\tpos := e.mapTicks(s, e.ticks[s].major)\n\t\tfor i, label := range e.ticks[s].labels {\n\t\t\ttick := pos[i]\n\t\t\tif e.axis == 'x' {\n\t\t\t\tsvg.Text(int(tick), int(y+xTickSep), label, `text-anchor=\"middle\" dy=\"1em\" fill=\"#666\"`) // TODO: Theme.\n\t\t\t} else {\n\t\t\t\tsvg.Text(int(x+w-yTickSep), int(tick), label, `text-anchor=\"end\" dy=\".3em\" fill=\"#666\"`)\n\t\t\t}\n\t\t}\n\t}\n}\n\nfunc (e *eltLabel) render(r *eltRender) {\n\tsvg := r.svg\n\tx, y, w, h := e.Layout()\n\n\t// Clip to label region.\n\tclipId, clipRef := r.genid(\"clip\")\n\tsvg.ClipPath(`id=\"` + clipId + `\"`)\n\tsvg.Rect(int(x), int(y), int(w), int(h))\n\tsvg.ClipEnd()\n\tsvg.Group(`clip-path=\"` + clipRef + `\"`)\n\tdefer svg.Gend()\n\n\tif e.fill != \"none\" {\n\t\tsvg.Rect(int(x), int(y), int(w), int(h), \"fill: \"+e.fill)\n\t}\n\t// Vertical centering is very poorly\n\t// supported. dy is the best chance.\n\tstyle := `text-anchor=\"middle\" dy=\".3em\"`\n\tswitch e.side {\n\tcase 'l':\n\t\tstyle += fmt.Sprintf(` transform=\"rotate(-90 %d %d)\"`, int(x+w/2), int(y+h/2))\n\tcase 'r':\n\t\tstyle += fmt.Sprintf(` transform=\"rotate(90 %d %d)\"`, int(x+w/2), int(y+h/2))\n\t}\n\tsvg.Text(int(x+w/2), int(y+h/2), e.label, style)\n}\n\nfunc (e *eltPadding) render(r *eltRender) {\n}\n\ntype renderEnv struct {\n\tgid table.GroupID\n\tcache map[renderCacheKey]table.Slice\n\tarea [4]float64\n}\n\ntype renderCacheKey struct {\n\tsd *scaledData\n\tgid table.GroupID\n}\n\n// scaledData is a key for retrieving scaled data from a renderEnv. It\n// is the result of using a binding and can be thought of as a lazy\n// representation of the visually-mapped data that becomes available\n// once all of the scales have been trained.\ntype scaledData struct {\n\tseqs map[table.GroupID]scaledSeq\n}\n\ntype scaledSeq struct {\n\tseq table.Slice\n\tscaler Scaler\n}\n\nfunc (env *renderEnv) get(sd *scaledData) table.Slice {\n\tcacheKey := renderCacheKey{sd, env.gid}\n\tif mapped := env.cache[cacheKey]; mapped != nil {\n\t\treturn mapped\n\t}\n\n\tv := sd.seqs[env.gid]\n\tmapped := mapMany(v.scaler, v.seq)\n\tenv.cache[cacheKey] = mapped\n\treturn mapped\n}\n\nfunc (env *renderEnv) getFirst(sd *scaledData) interface{} {\n\tif mapped := env.cache[renderCacheKey{sd, env.gid}]; mapped != nil {\n\t\tmv := reflect.ValueOf(mapped)\n\t\tif mv.Len() == 0 {\n\t\t\treturn nil\n\t\t}\n\t\treturn mv.Index(0).Interface()\n\t}\n\n\tv := sd.seqs[env.gid]\n\trv := reflect.ValueOf(v.seq)\n\tif rv.Len() == 0 {\n\t\treturn nil\n\t}\n\treturn v.scaler.Map(rv.Index(0).Interface())\n}\n\nfunc (env *renderEnv) Area() (x, y, w, h float64) {\n\treturn env.area[0], env.area[1], env.area[2], env.area[3]\n}\n\nfunc (env *renderEnv) Size() (w, h float64) {\n\treturn env.area[2], env.area[3]\n}\n\nfunc round(x float64) int {\n\treturn int(math.Floor(x + 0.5))\n}\n\n// wrapPath wraps path data p to avoid exceeding SVG's recommended\n// line length limit of 255 characters.\nfunc wrapPath(p string) string {\n\tconst width = 70\n\tif len(p) <= width {\n\t\treturn p\n\t}\n\t// Chop up p until we get below the width limit.\n\tparts := make([]string, 0, 16)\n\tfor len(p) > width {\n\t\t// Find the last command or space before exceeding width.\n\t\tlastCmd, lastSpace := 0, 0\n\t\tfor i, ch := range p {\n\t\t\tif i >= width && (lastCmd != 0 || lastSpace != 0) {\n\t\t\t\tbreak\n\t\t\t}\n\t\t\tif 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' {\n\t\t\t\tlastCmd = i\n\t\t\t} else if ch == ' ' {\n\t\t\t\tlastSpace = i\n\t\t\t}\n\t\t}\n\t\tsplit := len(p)\n\t\t// Prefer splitting at commands, but take spaces in\n\t\t// case it's a huge command.\n\t\tif lastCmd != 0 {\n\t\t\tsplit = lastCmd\n\t\t} else if lastSpace != 0 {\n\t\t\tsplit = lastSpace\n\t\t}\n\t\tparts, p = append(parts, p[:split]), p[split:]\n\t}\n\tif len(p) > 0 {\n\t\tparts = append(parts, p)\n\t}\n\treturn strings.Join(parts, \"\\n\")\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/gg/scale.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage gg\n\nimport (\n\t\"fmt\"\n\t\"image/color\"\n\t\"math\"\n\t\"reflect\"\n\t\"strings\"\n\t\"time\"\n\n\t\"github.com/aclements/go-gg/generic\"\n\t\"github.com/aclements/go-gg/generic/slice\"\n\t\"github.com/aclements/go-gg/palette\"\n\t\"github.com/aclements/go-gg/table\"\n\t\"github.com/aclements/go-moremath/scale\"\n)\n\n// Continuous -> Interpolatable? Definitely.\n//\n// Continuous -> Discrete? Can always discretize the input either in\n// value order or in index order. In this case the transform (linear,\n// log, etc) doesn't matter as long as it's order-preserving. OTOH, a\n// continuous input scale can be asked to map *any* value of its input\n// type, but if I do this I can only map values that were trained.\n// That suggests that I have to just bin the range to do this mapping.\n//\n// Discrete -> Interpolatable? Pick evenly spaced values on [0,1].\n//\n// Discrete -> Discrete? Definitely. Cycle the range if it's not long\n// enough. If the input range is a VarNominal, concatenate the\n// sequences and use index ordering.\n//\n// It's not really \"continuous\", it's more specifically cardinal.\n\n// TODO: time.Time and time.Duration scalers. For time.Duration,\n// handle sub-second as (10 seconds)^n (for n <= 0), handle seconds to\n// minutes at multiples of 10 seconds, and likewise minutes to hours\n// as multiples of 10 minutes, and handle hours as (10 hours)^n.\n\n// XXX\n//\n// A Scaler can be cardinal, discrete, or identity.\n//\n// A cardinal Scaler has a VarCardinal input domain. If its output\n// range is continuous, it maps an interval over the input to an\n// interval of the output (possibly through a transformation such as a\n// logarithm). If its output range is discrete, the input is\n// discretized in value order and it acts like a discrete scale.\n//\n// XXX The cardinal -> discrete rule means we need to keep all of the\n// input data, rather than just its bounds, just in case the range is\n// discrete. Maybe it should just be a bucketing rule?\n//\n// A discrete Scaler has a VarNominal input domain. If the input is\n// VarOrdinal, its order is used; otherwise, index order is imposed.\n// If the output range is continuous, a discrete Scaler maps its input\n// to the centers of equal sub-intervals of [0, 1] and then applies\n// the Ranger. If the output range is discrete, the Scaler maps the\n// Nth input level to the N%len(range)th output value.\n//\n// An identity Scaler ignores its input domain and output range and\n// uses an identity function for mapping input to output. This is\n// useful for specifying aesthetics directly, such as color or size,\n// and is especially useful for constant Vars.\n//\n// XXX Should identity Scalers map numeric types to float64? Maybe it\n// should depend on the range type of the ranger?\n//\n// XXX Arrange documentation as X -> Y?\ntype Scaler interface {\n\t// XXX\n\n\tExpandDomain(table.Slice)\n\n\t// Ranger sets this Scaler's output range if r is non-nil and\n\t// returns the previous range. If a scale's Ranger is nil, it\n\t// will be assigned a default Ranger based on its aesthetic\n\t// when the Plot is rendered.\n\tRanger(r Ranger) Ranger\n\n\t// XXX Should RangeType be implied by the aesthetic?\n\t//\n\t// XXX Should this be a method of Ranger instead?\n\tRangeType() reflect.Type\n\n\t// XXX\n\t//\n\t// x must be of the same type as the values in the domain Var.\n\t//\n\t// XXX Or should this take a slice? Or even a Var? That would\n\t// also eliminate RangeType(), though then Map would need to\n\t// know how to make the right type of return slice. Unless we\n\t// pushed slice mapping all the way to Ranger.\n\t//\n\t// XXX We could eliminate ExpandDomain if the caller was\n\t// required to pass everything to this at once and this did\n\t// the scale training. That would also make it easy to\n\t// implement the cardinal -> discrete by value order rule.\n\t// This would probably also make Map much faster.\n\t//\n\t// XXX If x is Unscaled, Map must only apply the ranger.\n\tMap(x interface{}) interface{}\n\n\t// Ticks returns a set of \"nice\" major and minor tick marks\n\t// spanning this Scaler's domain. The returned tick locations\n\t// are values in this Scaler's domain type in increasing\n\t// order. labels[i] gives the label of the major tick at\n\t// major[i]. The minor ticks are a superset of the major\n\t// ticks.\n\t//\n\t// max and pred constrain the ticks returned by Ticks. If\n\t// possible, Ticks returns the largest set of ticks such that\n\t// there are no more than max major ticks and the ticks\n\t// satisfy pred. Both are hints, since for some scale types\n\t// there's no clear way to reduce the number of ticks.\n\t//\n\t// pred should return true if the given set of ticks is\n\t// acceptable. pred must be \"monotonic\" in the following\n\t// sense: if pred is true for a given set of ticks, it must be\n\t// true for any subset of those ticks and if pred is false for\n\t// a given set of ticks, it must be false for any superset of\n\t// those ticks. In other words, pred should return false if\n\t// there are \"too many\" ticks or they are \"too close\n\t// together\". If pred is nil, it is assumed to always be\n\t// satisfied.\n\t//\n\t// If no tick marks can be produced (for example, there are no\n\t// values in this Scaler's domain or the predicate cannot be\n\t// satisfied), Ticks returns nil, nil, nil.\n\t//\n\t// TODO: Should this return ticks in the input space, the\n\t// intermediate space, or the output space? moremath returns\n\t// values in the input space. Input space values doesn't work\n\t// for discrete scales if I want the ticks between values.\n\t// Intermediate space works for continuous and discrete\n\t// inputs, but not for discrete ranges (maybe that's okay) and\n\t// it's awkward for a caller to do anything with an\n\t// intermediate space value. Output space doesn't work with\n\t// this API because I change the plot location in the course\n\t// of layout without recomputing ticks. However, output space\n\t// could work if Scaler exposed tick levels, since I could\n\t// save the computed tick level across a re-layout and\n\t// recompute the output space ticks from that.\n\tTicks(max int, pred func(major, minor table.Slice, labels []string) bool) (major, minor table.Slice, labels []string)\n\n\t// SetFormatter sets the formatter for values on this scale.\n\t//\n\t// f may be nil, which makes this Scaler use the default\n\t// formatting. Otherwise, f must be a func(T) string where T\n\t// is convertible from the Scaler's input type (note that this\n\t// is weaker than typical Go function calls, which require\n\t// that the argument be assignable; this makes it possible to\n\t// use general-purpose functions like func(float64) string\n\t// even for more specific input types).\n\tSetFormatter(f interface{})\n\n\tCloneScaler() Scaler\n}\n\ntype ContinuousScaler interface {\n\tScaler\n\n\t// TODO: There are two variations on min/max. 1) We can force\n\t// the min/max, even if there's data beyond it. 2) We can say\n\t// cap the scale to some min/max, but a smaller range is okay.\n\t// Currently we can't express 2.\n\n\t// SetMin and SetMax set the minimum and maximum values of\n\t// this Scalar's domain and return the Scalar. If v is nil, it\n\t// unsets the bound.\n\t//\n\t// v must be convertible to the Scaler's domain type. For\n\t// example, if this is a linear scale, v can be of any\n\t// numerical type. Unlike ExpandDomain, these do not set the\n\t// Scaler's domain type.\n\tSetMin(v interface{}) ContinuousScaler\n\tSetMax(v interface{}) ContinuousScaler\n\n\t// TODO: Should Include work on any Scaler?\n\n\t// Include requires that v be included in this Scaler's\n\t// domain. Like SetMin/SetMax, this can expand Scaler's\n\t// domain, but unlike SetMin/SetMax, this does not restrict\n\t// it. If v is nil, it does nothing.\n\t//\n\t// v must be convertible to the Scaler's domain type. Unlike\n\t// ExpandDomain, this does not set the Scaler's domain type.\n\tInclude(v interface{}) ContinuousScaler\n}\n\n// Unscaled represents a value that should not be scaled, but instead\n// mapped directly to the output range. For continuous scales, this\n// should be a value between 0 and 1. For discrete scales, this should\n// be an integral value.\n//\n// TODO: This is confusing for opacity and size because it *doesn't*\n// specify an exact opacity or size ratio since their default rangers\n// aren't [0,1]. Maybe Unscaled should bypass scaling altogether (and\n// only work if the range type is float64).\ntype Unscaled float64\n\nvar float64Type = reflect.TypeOf(float64(0))\nvar colorType = reflect.TypeOf((*color.Color)(nil)).Elem()\n\nvar canCardinal = map[reflect.Kind]bool{\n\treflect.Float32: true,\n\treflect.Float64: true,\n\treflect.Int: true,\n\treflect.Int8: true,\n\treflect.Int16: true,\n\treflect.Int32: true,\n\treflect.Int64: true,\n\treflect.Uint: true,\n\treflect.Uintptr: true,\n\treflect.Uint8: true,\n\treflect.Uint16: true,\n\treflect.Uint32: true,\n\treflect.Uint64: true,\n}\n\nfunc isCardinal(k reflect.Kind) bool {\n\t// XXX Move this to generic.IsCardinalR and rename CanOrderR\n\t// to IsOrderedR. Does complex count? It supports most\n\t// arithmetic operators. Maybe cardinal is a plot concept and\n\t// not a generic concept? If sort.Interface influences this,\n\t// this may need to be a question about a Slice, not a\n\t// reflect.Kind.\n\treturn canCardinal[k]\n}\n\ntype defaultScale struct {\n\tscale Scaler\n\n\t// Pre-instantiation state.\n\tr Ranger\n\tformatter interface{}\n}\n\nfunc (s *defaultScale) String() string {\n\treturn fmt.Sprintf(\"default (%s)\", s.scale)\n}\n\nfunc (s *defaultScale) ExpandDomain(v table.Slice) {\n\tif s.scale == nil {\n\t\tvar err error\n\t\ts.scale, err = DefaultScale(v)\n\t\tif err != nil {\n\t\t\tpanic(&generic.TypeError{reflect.TypeOf(v), nil, err.Error()})\n\t\t}\n\t\ts.instantiate()\n\t}\n\ts.scale.ExpandDomain(v)\n}\n\nfunc (s *defaultScale) ensure() Scaler {\n\tif s.scale == nil {\n\t\ts.scale = NewLinearScaler()\n\t\ts.instantiate()\n\t}\n\treturn s.scale\n}\n\n// instantiate applies the pre-instantiation state to the newly\n// instantiated s.scale and clears the state in s.\nfunc (s *defaultScale) instantiate() {\n\tif s.r != nil {\n\t\ts.scale.Ranger(s.r)\n\t\ts.r = nil\n\t}\n\tif s.formatter != nil {\n\t\ts.scale.SetFormatter(s.formatter)\n\t\ts.formatter = nil\n\t}\n}\n\nfunc (s *defaultScale) Ranger(r Ranger) Ranger {\n\t// If there's no underlying scale yet, record the Ranger\n\t// locally rather than trying to guess a scale. This way users\n\t// can easily set Rangers before training any data.\n\tif s.scale == nil {\n\t\told := s.r\n\t\ts.r = r\n\t\treturn old\n\t}\n\treturn s.scale.Ranger(r)\n}\n\nfunc (s *defaultScale) RangeType() reflect.Type {\n\tif s.scale == nil {\n\t\treturn s.r.RangeType()\n\t}\n\treturn s.scale.RangeType()\n}\n\nfunc (s *defaultScale) Map(x interface{}) interface{} {\n\treturn s.ensure().Map(x)\n}\n\nfunc (s *defaultScale) Ticks(max int, pred func(major, minor table.Slice, labels []string) bool) (major, minor table.Slice, labels []string) {\n\treturn s.ensure().Ticks(max, pred)\n}\n\nfunc (s *defaultScale) SetFormatter(f interface{}) {\n\tif s.scale == nil {\n\t\ts.formatter = f\n\t\treturn\n\t}\n\ts.scale.SetFormatter(f)\n}\n\nfunc (s *defaultScale) CloneScaler() Scaler {\n\tif s.scale == nil {\n\t\treturn &defaultScale{nil, s.r, s.formatter}\n\t}\n\treturn &defaultScale{s.scale.CloneScaler(), nil, s.formatter}\n}\n\nfunc DefaultScale(seq table.Slice) (Scaler, error) {\n\t// Handle common case types.\n\tswitch seq.(type) {\n\tcase []float64, []int, []uint:\n\t\treturn NewLinearScaler(), nil\n\n\tcase []string:\n\t\t// TODO: Ordinal scale\n\n\tcase []time.Time:\n\t\treturn NewTimeScaler(), nil\n\t}\n\n\trt := reflect.TypeOf(seq).Elem()\n\trtk := rt.Kind()\n\n\tswitch {\n\tcase rt.Implements(colorType):\n\t\t// For things that are already visual values, use an\n\t\t// identity scale.\n\t\treturn NewIdentityScale(), nil\n\n\t\t// TODO: GroupAuto needs to make similar\n\t\t// cardinal/ordinal/nominal decisions. Deduplicate\n\t\t// these better.\n\tcase isCardinal(rtk):\n\t\treturn NewLinearScaler(), nil\n\n\tcase slice.CanSort(seq):\n\t\treturn NewOrdinalScale(), nil\n\n\tcase rt.Comparable():\n\t\t// TODO: Nominal scale\n\t\tpanic(\"not implemented\")\n\t}\n\n\treturn nil, fmt.Errorf(\"no default scale type for %T\", seq)\n}\n\n// defaultRanger returns the default Ranger for the given aesthetic.\n// If aes is an axis aesthetic, it returns nil (since these Rangers\n// are assigned at render time). If aes is unknown, it panics.\nfunc defaultRanger(aes string) Ranger {\n\tswitch aes {\n\tcase \"x\", \"y\":\n\t\treturn nil\n\n\tcase \"stroke\", \"fill\":\n\t\treturn &defaultColorRanger{}\n\n\tcase \"opacity\":\n\t\treturn NewFloatRanger(0.1, 1)\n\n\tcase \"size\":\n\t\t// Default to ranging between 1% and 10% of the\n\t\t// minimum plot dimension.\n\t\treturn NewFloatRanger(0.01, 0.1)\n\t}\n\n\tpanic(fmt.Sprintf(\"unknown aesthetic %q\", aes))\n}\n\n// TODO: I'd like to remove identity scales and expose only Unscaled,\n// but I use identity scales for physical types like color.Color right\n// now. Probably that should bypass Scaler altogether.\n\nfunc NewIdentityScale() Scaler {\n\treturn &identityScale{}\n}\n\ntype identityScale struct {\n\trangeType reflect.Type\n}\n\nfunc (s *identityScale) ExpandDomain(v table.Slice) {\n\ts.rangeType = reflect.TypeOf(v).Elem()\n}\n\nfunc (s *identityScale) RangeType() reflect.Type {\n\treturn s.rangeType\n}\n\nfunc (s *identityScale) Ranger(r Ranger) Ranger { return nil }\nfunc (s *identityScale) Map(x interface{}) interface{} { return x }\n\nfunc (s *identityScale) Ticks(max int, pred func(major, minor table.Slice, labels []string) bool) (major, minor table.Slice, labels []string) {\n\treturn nil, nil, nil\n}\n\nfunc (s *identityScale) SetFormatter(f interface{}) {}\n\nfunc (s *identityScale) CloneScaler() Scaler {\n\ts2 := *s\n\treturn &s2\n}\n\n// NewLinearScaler returns a continuous linear scale. The domain must\n// be a VarCardinal.\n//\n// XXX If I return a Scaler, I can't have methods for setting fixed\n// bounds and such. I don't really want to expose the whole type.\n// Maybe a sub-interface for continuous Scalers?\nfunc NewLinearScaler() ContinuousScaler {\n\t// TODO: Control over base.\n\treturn &moremathScale{\n\t\tmin: math.NaN(),\n\t\tmax: math.NaN(),\n\t\tdataMin: math.NaN(),\n\t\tdataMax: math.NaN(),\n\t}\n}\n\nfunc NewLogScaler(base int) ContinuousScaler {\n\treturn &moremathScale{\n\t\tmin: math.NaN(),\n\t\tmax: math.NaN(),\n\t\tbase: base,\n\t\tdataMin: math.NaN(),\n\t\tdataMax: math.NaN(),\n\t}\n}\n\ntype moremathScale struct {\n\tr Ranger\n\tf interface{}\n\n\tdomainType reflect.Type\n\tbase int\n\tmin, max float64\n\tdataMin, dataMax float64\n}\n\nfunc (s *moremathScale) String() string {\n\tif s.base > 0 {\n\t\treturn fmt.Sprintf(\"log [%d,%g,%g] => %s\", s.base, s.min, s.max, s.r)\n\t}\n\treturn fmt.Sprintf(\"linear [%g,%g] => %s\", s.min, s.max, s.r)\n}\n\nfunc (s *moremathScale) ExpandDomain(vs table.Slice) {\n\tif s.domainType == nil {\n\t\ts.domainType = reflect.TypeOf(vs).Elem()\n\t}\n\n\tvar data []float64\n\tslice.Convert(&data, vs)\n\tmin, max := s.dataMin, s.dataMax\n\tfor _, v := range data {\n\t\tif math.IsNaN(v) || math.IsInf(v, 0) {\n\t\t\tcontinue\n\t\t}\n\t\tif v < min || math.IsNaN(min) {\n\t\t\tmin = v\n\t\t}\n\t\tif v > max || math.IsNaN(max) {\n\t\t\tmax = v\n\t\t}\n\t}\n\ts.dataMin, s.dataMax = min, max\n}\n\nfunc (s *moremathScale) SetMin(v interface{}) ContinuousScaler {\n\tif v == nil {\n\t\ts.min = math.NaN()\n\t\treturn s\n\t}\n\tvfloat := reflect.ValueOf(v).Convert(float64Type).Float()\n\ts.min = vfloat\n\treturn s\n}\n\nfunc (s *moremathScale) SetMax(v interface{}) ContinuousScaler {\n\tif v == nil {\n\t\ts.max = math.NaN()\n\t\treturn s\n\t}\n\tvfloat := reflect.ValueOf(v).Convert(float64Type).Float()\n\ts.max = vfloat\n\treturn s\n}\n\nfunc (s *moremathScale) Include(v interface{}) ContinuousScaler {\n\tif v == nil {\n\t\treturn s\n\t}\n\tvfloat := reflect.ValueOf(v).Convert(float64Type).Float()\n\tif math.IsNaN(vfloat) || math.IsInf(vfloat, 0) {\n\t\treturn s\n\t}\n\tif math.IsNaN(s.dataMin) {\n\t\ts.dataMin, s.dataMax = vfloat, vfloat\n\t} else {\n\t\ts.dataMin = math.Min(s.dataMin, vfloat)\n\t\ts.dataMax = math.Max(s.dataMax, vfloat)\n\t}\n\treturn s\n}\n\ntype tickMapper interface {\n\tscale.Ticker\n\tMap(float64) float64\n}\n\nfunc (s *moremathScale) get() tickMapper {\n\tmin, max := s.min, s.max\n\tif min > max {\n\t\tmin, max = max, min\n\t}\n\tif math.IsNaN(min) {\n\t\tmin = s.dataMin\n\t}\n\tif math.IsNaN(max) {\n\t\tmax = s.dataMax\n\t}\n\tif math.IsNaN(min) {\n\t\t// Only possible if both dataMin and dataMax are NaN.\n\t\tmin, max = -1, 1\n\t}\n\tif s.base > 0 {\n\t\tls, err := scale.NewLog(min, max, s.base)\n\t\tif err != nil {\n\t\t\tpanic(err)\n\t\t}\n\t\tls.SetClamp(true)\n\t\treturn &ls\n\t}\n\treturn &scale.Linear{\n\t\tMin: min, Max: max,\n\t}\n}\n\nfunc (s *moremathScale) Ranger(r Ranger) Ranger {\n\told := s.r\n\tif r != nil {\n\t\ts.r = r\n\t}\n\treturn old\n}\n\nfunc (s *moremathScale) RangeType() reflect.Type {\n\treturn s.r.RangeType()\n}\n\nfunc (s *moremathScale) Map(x interface{}) interface{} {\n\tls := s.get()\n\tvar scaled float64\n\tswitch x := x.(type) {\n\tcase float64:\n\t\tscaled = ls.Map(x)\n\tcase Unscaled:\n\t\tscaled = float64(x)\n\tdefault:\n\t\tv := reflect.ValueOf(x).Convert(float64Type).Float()\n\t\tscaled = ls.Map(v)\n\t}\n\n\tswitch r := s.r.(type) {\n\tcase ContinuousRanger:\n\t\treturn r.Map(scaled)\n\n\tcase DiscreteRanger:\n\t\t_, levels := r.Levels()\n\t\t// Bin the scaled value into 'levels' bins.\n\t\tlevel := int(scaled * float64(levels))\n\t\tif level < 0 {\n\t\t\tlevel = 0\n\t\t} else if level >= levels {\n\t\t\tlevel = levels - 1\n\t\t}\n\t\treturn r.MapLevel(level, levels)\n\n\tdefault:\n\t\tpanic(\"Ranger must be a ContinuousRanger or DiscreteRanger\")\n\t}\n}\n\nfunc (s *moremathScale) Ticks(max int, pred func(major, minor table.Slice, labels []string) bool) (major, minor table.Slice, labels []string) {\n\ttype Stringer interface {\n\t\tString() string\n\t}\n\tif s.domainType == nil {\n\t\t// There are no values and no domain type, so we can't\n\t\t// compute ticks or return slices of the domain type.\n\t\treturn nil, nil, nil\n\t}\n\n\to := scale.TickOptions{Max: max}\n\n\t// If the domain type is integral, don't let the tick level go\n\t// below 0. This is particularly important if the domain type\n\t// is a Stringer since the conversion back to the domain type\n\t// will cut off any fractional part.\n\tswitch s.domainType.Kind() {\n\tcase reflect.Int, reflect.Uint, reflect.Uintptr,\n\t\treflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,\n\t\treflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:\n\t\to.MinLevel, o.MaxLevel = 0, 1000\n\tdefault:\n\t\t// Set bounds for the pred loop below.\n\t\to.MinLevel, o.MaxLevel = -1000, 1000\n\t}\n\tls := s.get()\n\tlevel, ok := o.FindLevel(ls, 0)\n\tif !ok {\n\t\treturn nil, nil, nil\n\t}\n\n\tmkLabels := func(major []float64) []string {\n\t\t// Compute labels.\n\t\tlabels = make([]string, len(major))\n\t\tif s.f != nil {\n\t\t\t// Use custom formatter.\n\t\t\tif f, ok := s.f.(func(float64) string); ok {\n\t\t\t\t// Fast path.\n\t\t\t\tfor i, x := range major {\n\t\t\t\t\tlabels[i] = f(x)\n\t\t\t\t}\n\t\t\t\treturn labels\n\t\t\t}\n\t\t\t// TODO: Type check for better error.\n\t\t\tfv := reflect.ValueOf(s.f)\n\t\t\tat := fv.Type().In(0)\n\t\t\tvar avs [1]reflect.Value\n\t\t\tfor i, x := range major {\n\t\t\t\tavs[0] = reflect.ValueOf(x).Convert(at)\n\t\t\t\trvs := fv.Call(avs[:])\n\t\t\t\tlabels[i] = rvs[0].Interface().(string)\n\t\t\t}\n\t\t\treturn labels\n\t\t}\n\t\tif s.domainType != nil {\n\t\t\tz := reflect.Zero(s.domainType).Interface()\n\t\t\tif _, ok := z.(Stringer); ok {\n\t\t\t\t// Convert the ticks back into the domain type\n\t\t\t\t// and use its String method.\n\t\t\t\tfor i, x := range major {\n\t\t\t\t\tv := reflect.ValueOf(x).Convert(s.domainType)\n\t\t\t\t\tlabels[i] = v.Interface().(Stringer).String()\n\t\t\t\t}\n\t\t\t\treturn labels\n\t\t\t}\n\t\t}\n\t\t// Otherwise, just format them as floats.\n\t\tfor i, x := range major {\n\t\t\tlabels[i] = fmt.Sprintf(\"%.6g\", x)\n\t\t}\n\t\treturn labels\n\t}\n\t// Adjust level to satisfy pred.\n\tfor ; level <= o.MaxLevel; level++ {\n\t\tmajorx := ls.TicksAtLevel(level)\n\t\tminorx := ls.TicksAtLevel(level - 1)\n\t\tlabels := mkLabels(majorx.([]float64))\n\n\t\t// Convert to domain type.\n\t\tmajorv := reflect.New(reflect.SliceOf(s.domainType))\n\t\tminorv := reflect.New(reflect.SliceOf(s.domainType))\n\t\tslice.Convert(majorv.Interface(), majorx)\n\t\tslice.Convert(minorv.Interface(), minorx)\n\t\tmajor, minor = majorv.Elem().Interface(), minorv.Elem().Interface()\n\n\t\tif pred == nil || pred(major, minor, labels) {\n\t\t\treturn major, minor, labels\n\t\t}\n\t}\n\tWarning.Printf(\"%s: unable to compute satisfactory ticks, axis will be empty\", s)\n\treturn nil, nil, nil\n}\n\nfunc (s *moremathScale) SetFormatter(f interface{}) {\n\ts.f = f\n}\n\nfunc (s *moremathScale) CloneScaler() Scaler {\n\ts2 := *s\n\treturn &s2\n}\n\n// NewTimeScaler returns a continuous linear scale. The domain must\n// be time.Time.\nfunc NewTimeScaler() *timeScale {\n\treturn &timeScale{}\n}\n\ntype timeScale struct {\n\tr Ranger\n\tf func(time.Time) string\n\tmin, max time.Time\n\tdataMin, dataMax time.Time\n}\n\nfunc (s *timeScale) String() string {\n\treturn fmt.Sprintf(\"time [%g,%g] => %s\", s.min, s.max, s.r)\n}\n\nfunc (s *timeScale) ExpandDomain(vs table.Slice) {\n\tvar data []time.Time\n\tslice.Convert(&data, vs)\n\tmin, max := s.dataMin, s.dataMax\n\tfor _, v := range data {\n\t\tif v.Before(min) || min.IsZero() {\n\t\t\tmin = v\n\t\t}\n\t\tif v.After(max) || max.IsZero() {\n\t\t\tmax = v\n\t\t}\n\t}\n\ts.dataMin, s.dataMax = min, max\n}\n\nfunc (s *timeScale) SetMin(v interface{}) ContinuousScaler {\n\ts.min = v.(time.Time)\n\treturn s\n}\n\nfunc (s *timeScale) SetMax(v interface{}) ContinuousScaler {\n\ts.max = v.(time.Time)\n\treturn s\n}\n\nfunc (s *timeScale) Include(v interface{}) ContinuousScaler {\n\ttv := v.(time.Time)\n\tif s.dataMin.IsZero() {\n\t\ts.dataMin, s.dataMax = tv, tv\n\t} else {\n\t\tif tv.Before(s.dataMin) {\n\t\t\ts.dataMin = tv\n\t\t}\n\t\tif tv.After(s.dataMax) {\n\t\t\ts.dataMax = tv\n\t\t}\n\t}\n\treturn s\n}\n\nfunc (s *timeScale) Ranger(r Ranger) Ranger {\n\told := s.r\n\tif r != nil {\n\t\ts.r = r\n\t}\n\treturn old\n}\n\nfunc (s *timeScale) RangeType() reflect.Type {\n\treturn s.r.RangeType()\n}\n\nfunc (s *timeScale) getMinMax() (time.Time, time.Time) {\n\tmin := s.min\n\tif min.IsZero() {\n\t\tmin = s.dataMin\n\t}\n\tmax := s.max\n\tif max.IsZero() {\n\t\tmax = s.dataMax\n\t}\n\treturn min, max\n}\n\nfunc (s *timeScale) Map(x interface{}) interface{} {\n\tmin, max := s.getMinMax()\n\tt := x.(time.Time)\n\tvar scaled float64 = float64(t.Sub(min)) / float64(max.Sub(min))\n\n\tswitch r := s.r.(type) {\n\tcase ContinuousRanger:\n\t\treturn r.Map(scaled)\n\n\tcase DiscreteRanger:\n\t\t_, levels := r.Levels()\n\t\t// Bin the scaled value into 'levels' bins.\n\t\tlevel := int(scaled * float64(levels))\n\t\tif level < 0 {\n\t\t\tlevel = 0\n\t\t} else if level >= levels {\n\t\t\tlevel = levels - 1\n\t\t}\n\t\treturn r.MapLevel(level, levels)\n\n\tdefault:\n\t\tpanic(\"Ranger must be a ContinuousRanger or DiscreteRanger\")\n\t}\n}\n\ntype durationTicks time.Duration\n\nfunc (d durationTicks) Next(t time.Time) time.Time {\n\tif d == 0 {\n\t\tpanic(\"invalid zero duration\")\n\t}\n\treturn t.Add(time.Duration(d)).Truncate(time.Duration(d))\n}\n\nvar timeTickerLevels = []struct {\n\tmin time.Duration\n\tnext func(t time.Time) time.Time\n}{\n\t{time.Minute, durationTicks(time.Minute).Next},\n\t{10 * time.Minute, durationTicks(10 * time.Minute).Next},\n\t{time.Hour, func(t time.Time) time.Time {\n\t\tyear, month, day := t.Date()\n\t\t// N.B. This will skip an hour at some DST transitions.\n\t\treturn time.Date(year, month, day, t.Hour()+1, 0, 0, 0, t.Location())\n\t}},\n\t{6 * time.Hour, func(t time.Time) time.Time {\n\t\tyear, month, day := t.Date()\n\t\t// N.B. This will skip an hour if the DST transition\n\t\t// happens at a multiple of 6 hours.\n\t\treturn time.Date(year, month, day, ((t.Hour()+6)/6)*6, 0, 0, 0, t.Location())\n\t}},\n\t{24 * time.Hour, func(t time.Time) time.Time {\n\t\tyear, month, day := t.Date()\n\t\treturn time.Date(year, month, day+1, 0, 0, 0, 0, t.Location())\n\t}},\n\t{7 * 24 * time.Hour, func(t time.Time) time.Time {\n\t\tyear, month, day := t.Date()\n\t\tloc := t.Location()\n\t\t_, week1 := t.ISOWeek()\n\t\tfor {\n\t\t\tday++\n\t\t\tt = time.Date(year, month, day, 0, 0, 0, 0, loc)\n\t\t\tif _, week2 := t.ISOWeek(); week1 != week2 {\n\t\t\t\treturn t\n\t\t\t}\n\t\t}\n\t}},\n\t{30 * 24 * time.Hour, func(t time.Time) time.Time {\n\t\tyear, month, _ := t.Date()\n\t\treturn time.Date(year, month+1, 1, 0, 0, 0, 0, t.Location())\n\t}},\n\t{365 * 24 * time.Hour, func(t time.Time) time.Time {\n\t\treturn time.Date(t.Year()+1, time.January, 1, 0, 0, 0, 0, t.Location())\n\t}},\n}\n\n// timeTicker calculates the ticks between min and max. levels >= 0\n// refer to entries in timeTickerLevels. levels < 0 start with -1 at\n// every 10 seconds and then alternate dividing by 2 and 5. So level\n// -3 is 1s, -9 is 1ms, -12 is 1us, etc.\n// https://play.golang.org/p/xUv4P25Wxi will print the level step\n// sizes.\ntype timeTicker struct {\n\tmin, max time.Time\n}\n\nfunc (t *timeTicker) getNextTick(level int) func(time.Time) time.Time {\n\tif level >= 0 {\n\t\tif level >= len(timeTickerLevels) {\n\t\t\t// TODO: larger ticks should do multiples of\n\t\t\t// the year, like the linear scale does.\n\t\t\tpanic(fmt.Sprintf(\"invalid level %d\", level))\n\t\t}\n\t\treturn timeTickerLevels[level].next\n\t} else {\n\t\texp, double := level/2+1, (level%2 == 0)\n\t\tstep := math.Pow10(exp) * 1e9\n\t\tif double {\n\t\t\tstep = step * 5\n\t\t}\n\t\treturn durationTicks(time.Duration(step)).Next\n\t}\n}\n\nfunc (t *timeTicker) CountTicks(level int) int {\n\tnext := t.getNextTick(level)\n\tvar i int\n\t// N.B. We cut off at 1e5 ticks. If your plot is larger than\n\t// that, you're on your own.\n\tfor x := next(t.min.Add(-1)); !x.After(t.max) && i < 1e5; x = next(x) {\n\t\ti++\n\t}\n\treturn i\n}\n\nfunc (t *timeTicker) TicksAtLevel(level int) interface{} {\n\tvar ticks []time.Time\n\tnext := t.getNextTick(level)\n\tfor x := next(t.min.Add(-1)); !x.After(t.max); x = next(x) {\n\t\tticks = append(ticks, x)\n\t}\n\treturn ticks\n}\n\nfunc (t *timeTicker) GuessLevel() int {\n\tdur := t.max.Sub(t.min)\n\tfor i := len(timeTickerLevels) - 1; i >= 0; i-- {\n\t\tif dur > timeTickerLevels[i].min {\n\t\t\treturn i\n\t\t}\n\t}\n\treturn int(2 * (math.Log10(float64(dur)/1e9) - 2))\n}\n\nfunc (timeTicker) MaxLevel() int {\n\treturn len(timeTickerLevels) - 1\n}\n\nfunc (timeTicker) Label(cur, prev time.Time, level int) string {\n\tdateFmt := \"2006\"\n\tswitch {\n\tcase level < 6:\n\t\tdateFmt = \"2006/1/2\"\n\t\tif !prev.IsZero() {\n\t\t\tif prev.Year() == cur.Year() {\n\t\t\t\tdateFmt = \"Jan 2\"\n\t\t\t\t_, prevweek := prev.ISOWeek()\n\t\t\t\t_, curweek := cur.ISOWeek()\n\t\t\t\tif prevweek == curweek {\n\t\t\t\t\tdateFmt = \"Mon\"\n\t\t\t\t\tif prev.YearDay() == cur.YearDay() {\n\t\t\t\t\t\tdateFmt = \"\"\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\tcase level < 7:\n\t\tdateFmt = \"2006/1\"\n\t\tif !prev.IsZero() && prev.Year() == cur.Year() {\n\t\t\tdateFmt = \"Jan\"\n\t\t}\n\t}\n\ttimeFmt := \"\"\n\tswitch {\n\tcase level < -3: // < 1s\n\t\tdigits := (-level - 2) / 2\n\t\ttimeFmt = \"15:04:05.\" + strings.Repeat(\"0\", digits)\n\tcase level < 0: // < 1m\n\t\ttimeFmt = \"15:04:05\"\n\tcase level < 4: // < 1d\n\t\ttimeFmt = \"15:04\"\n\t}\n\treturn cur.Format(strings.TrimSpace(dateFmt + \" \" + timeFmt))\n}\n\nfunc (s *timeScale) Ticks(maxTicks int, pred func(major, minor table.Slice, labels []string) bool) (table.Slice, table.Slice, []string) {\n\tmin, max := s.getMinMax()\n\tticker := &timeTicker{min, max}\n\to := scale.TickOptions{Max: maxTicks, MinLevel: -21, MaxLevel: ticker.MaxLevel()}\n\tlevel, ok := o.FindLevel(ticker, ticker.GuessLevel())\n\tif !ok {\n\t\t// TODO(quentin): Better handling of too-large time range.\n\t\treturn nil, nil, nil\n\t}\n\tmkLabels := func(major []time.Time) []string {\n\t\t// TODO(quentin): Pick a format based on which parts\n\t\t// of the time have changed and are non-zero.\n\t\tlabels := make([]string, len(major))\n\t\tif s.f != nil {\n\t\t\t// Use custom formatter.\n\t\t\tfor i, x := range major {\n\t\t\t\tlabels[i] = s.f(x)\n\t\t\t}\n\t\t\treturn labels\n\t\t}\n\t\tvar prev time.Time\n\t\tfor i, t := range major {\n\t\t\tlabels[i] = ticker.Label(t, prev, level)\n\t\t\tprev = t\n\t\t}\n\t\treturn labels\n\t}\n\tvar majors, minors []time.Time\n\tvar labels []string\n\tfor ; level <= o.MaxLevel; level++ {\n\t\tmajors = ticker.TicksAtLevel(level).([]time.Time)\n\t\tif level > o.MinLevel {\n\t\t\tminors = ticker.TicksAtLevel(level - 1).([]time.Time)\n\t\t}\n\t\tlabels = mkLabels(majors)\n\t\tif pred == nil || pred(majors, minors, labels) {\n\t\t\tbreak\n\t\t}\n\t}\n\treturn majors, minors, labels\n}\n\nfunc (s *timeScale) SetFormatter(f interface{}) {\n\ts.f = f.(func(time.Time) string)\n}\n\nfunc (s *timeScale) CloneScaler() Scaler {\n\ts2 := *s\n\treturn &s2\n}\n\n// TODO: The ordinal scale can only work with values it actually sees\n// in the data. It has no sense of the type's actual domain. If the\n// type is an enumerated type, we could fill in intermediate values\n// and the caller could set a min and max for the scale to enumerate\n// between.\n\nfunc NewOrdinalScale() Scaler {\n\treturn &ordinalScale{}\n}\n\ntype ordinalScale struct {\n\tallData []slice.T\n\tr Ranger\n\tf interface{}\n\tordered table.Slice\n\tindex map[interface{}]int\n}\n\nfunc (s *ordinalScale) ExpandDomain(v table.Slice) {\n\t// TODO: Type-check? For example, if I try to use a cardinal\n\t// type for \"Color\" and then a continuous type, this will\n\t// crash confusingly only once Map calls makeIndex and\n\t// NubAppend tries to make a consistently typed slice.\n\ts.allData = append(s.allData, slice.T(v))\n\ts.ordered, s.index = nil, nil\n}\n\nfunc (s *ordinalScale) Ranger(r Ranger) Ranger {\n\told := s.r\n\tif r != nil {\n\t\ts.r = r\n\t}\n\treturn old\n}\n\nfunc (s *ordinalScale) RangeType() reflect.Type {\n\treturn s.r.RangeType()\n}\n\nfunc (s *ordinalScale) makeIndex() {\n\tif s.index != nil {\n\t\treturn\n\t}\n\n\t// Compute ordered data index and cache.\n\ts.ordered = slice.NubAppend(s.allData...)\n\tslice.Sort(s.ordered)\n\tov := reflect.ValueOf(s.ordered)\n\ts.index = make(map[interface{}]int, ov.Len())\n\tfor i, len := 0, ov.Len(); i < len; i++ {\n\t\ts.index[ov.Index(i).Interface()] = i\n\t}\n}\n\nfunc (s *ordinalScale) Map(x interface{}) interface{} {\n\tvar i int\n\tswitch x := x.(type) {\n\tcase Unscaled:\n\t\ti = int(x)\n\tdefault:\n\t\ts.makeIndex()\n\t\ti = s.index[x]\n\t}\n\n\tswitch r := s.r.(type) {\n\tcase DiscreteRanger:\n\t\tminLevels, maxLevels := r.Levels()\n\t\tif len(s.index) <= minLevels {\n\t\t\treturn r.MapLevel(i, minLevels)\n\t\t} else if len(s.index) <= maxLevels {\n\t\t\treturn r.MapLevel(i, len(s.index))\n\t\t} else {\n\t\t\t// TODO: Binning would also be a reasonable\n\t\t\t// policy.\n\t\t\treturn r.MapLevel(i%maxLevels, maxLevels)\n\t\t}\n\n\tcase ContinuousRanger:\n\t\t// Map i to the \"middle\" of the ith equal j-way\n\t\t// subdivision of [0, 1].\n\t\tj := len(s.index)\n\t\tx := (float64(i) + 0.5) / float64(j)\n\t\treturn r.Map(x)\n\n\tdefault:\n\t\tpanic(\"Ranger must be a ContinuousRanger or DiscreteRanger\")\n\t}\n}\n\nfunc (s *ordinalScale) Ticks(max int, pred func(major, minor table.Slice, labels []string) bool) (major, minor table.Slice, labels []string) {\n\t// TODO: Return *no* ticks and only labels. Can't currently\n\t// express this.\n\n\t// TODO: Honor constraints.\n\n\ts.makeIndex()\n\tlabels = make([]string, len(s.index))\n\tov := reflect.ValueOf(s.ordered)\n\n\tif s.f != nil {\n\t\t// Use custom formatter.\n\t\t// TODO: Type check for better error.\n\t\tfv := reflect.ValueOf(s.f)\n\t\tat := fv.Type().In(0)\n\t\tvar avs [1]reflect.Value\n\t\tfor i, len := 0, ov.Len(); i < len; i++ {\n\t\t\tavs[0] = ov.Index(i).Convert(at)\n\t\t\trvs := fv.Call(avs[:])\n\t\t\tlabels[i] = rvs[0].Interface().(string)\n\t\t}\n\t} else {\n\t\t// Use String() method or standard format.\n\t\tfor i, len := 0, ov.Len(); i < len; i++ {\n\t\t\tlabels[i] = fmt.Sprintf(\"%v\", ov.Index(i).Interface())\n\t\t}\n\t}\n\treturn s.ordered, nil, labels\n}\n\nfunc (s *ordinalScale) SetFormatter(f interface{}) {\n\ts.f = f\n}\n\nfunc (s *ordinalScale) CloneScaler() Scaler {\n\tns := &ordinalScale{\n\t\tallData: make([]slice.T, len(s.allData)),\n\t\tr: s.r,\n\t}\n\tfor i, v := range s.allData {\n\t\tns.allData[i] = v\n\t}\n\treturn s\n}\n\n// XXX\n//\n// A Ranger must be either a ContinuousRanger or a DiscreteRanger.\ntype Ranger interface {\n\tRangeType() reflect.Type\n}\n\ntype ContinuousRanger interface {\n\tRanger\n\tMap(x float64) (y interface{})\n\tUnmap(y interface{}) (x float64, ok bool)\n}\n\ntype DiscreteRanger interface {\n\tRanger\n\tLevels() (min, max int)\n\tMapLevel(i, j int) interface{}\n}\n\nfunc NewFloatRanger(lo, hi float64) ContinuousRanger {\n\treturn &floatRanger{lo, hi - lo}\n}\n\ntype floatRanger struct {\n\tlo, w float64\n}\n\nfunc (r *floatRanger) String() string {\n\treturn fmt.Sprintf(\"[%g,%g]\", r.lo, r.lo+r.w)\n}\n\nfunc (r *floatRanger) RangeType() reflect.Type {\n\treturn float64Type\n}\n\nfunc (r *floatRanger) Map(x float64) interface{} {\n\treturn x*r.w + r.lo\n}\n\nfunc (r *floatRanger) Unmap(y interface{}) (float64, bool) {\n\tswitch y := y.(type) {\n\tdefault:\n\t\treturn 0, false\n\n\tcase float64:\n\t\treturn (y - r.lo) / r.w, true\n\t}\n}\n\nfunc NewColorRanger(palette []color.Color) DiscreteRanger {\n\t// TODO: Support continuous palettes.\n\t//\n\t// TODO: Support discrete palettes that vary depending on the\n\t// number of levels.\n\treturn &colorRanger{palette}\n}\n\ntype colorRanger struct {\n\tpalette []color.Color\n}\n\nfunc (r *colorRanger) RangeType() reflect.Type {\n\treturn colorType\n}\n\nfunc (r *colorRanger) Levels() (min, max int) {\n\treturn len(r.palette), len(r.palette)\n}\n\nfunc (r *colorRanger) MapLevel(i, j int) interface{} {\n\tif i < 0 {\n\t\ti = 0\n\t} else if i >= len(r.palette) {\n\t\ti = len(r.palette) - 1\n\t}\n\treturn r.palette[i]\n}\n\n// defaultColorRanger is the default color ranger. It is both a\n// ContinuousRanger and a DiscreteRanger.\ntype defaultColorRanger struct{}\n\n// autoPalette is the discrete palette used by defaultColorRanger.\nvar autoPalette = []color.Color{\n\tcolor.RGBA{0x4c, 0x72, 0xb0, 0xff},\n\tcolor.RGBA{0x55, 0xa8, 0x68, 0xff},\n\tcolor.RGBA{0xc4, 0x4e, 0x52, 0xff},\n\tcolor.RGBA{0x81, 0x72, 0xb2, 0xff},\n\tcolor.RGBA{0xcc, 0xb9, 0x74, 0xff},\n\tcolor.RGBA{0x64, 0xb5, 0xcd, 0xff},\n}\n\nfunc (r *defaultColorRanger) RangeType() reflect.Type {\n\treturn colorType\n}\n\nfunc (r *defaultColorRanger) Map(x float64) interface{} {\n\treturn palette.Viridis.Map(x)\n}\n\nfunc (r *defaultColorRanger) Unmap(y interface{}) (float64, bool) {\n\tswitch y := y.(type) {\n\tdefault:\n\t\treturn 0, false\n\n\tcase color.RGBA:\n\t\treturn float64(y.G) / float64(226), true\n\t}\n}\n\nfunc (r *defaultColorRanger) Levels() (min, max int) {\n\treturn len(autoPalette), len(autoPalette)\n}\n\nfunc (r *defaultColorRanger) MapLevel(i, j int) interface{} {\n\tif i < 0 {\n\t\ti = 0\n\t} else if i >= len(autoPalette) {\n\t\ti = len(autoPalette) - 1\n\t}\n\treturn autoPalette[i]\n}\n\n// mapMany applies scaler.Map to all of the values in seq and returns\n// a slice of the results.\n//\n// TODO: Maybe this should just be how Scaler.Map works.\nfunc mapMany(scaler Scaler, seq table.Slice) table.Slice {\n\tsv := reflect.ValueOf(seq)\n\trt := reflect.SliceOf(scaler.RangeType())\n\tif seq == nil {\n\t\treturn reflect.MakeSlice(rt, 0, 0).Interface()\n\t}\n\tres := reflect.MakeSlice(rt, sv.Len(), sv.Len())\n\tfor i, len := 0, sv.Len(); i < len; i++ {\n\t\tval := scaler.Map(sv.Index(i).Interface())\n\t\tres.Index(i).Set(reflect.ValueOf(val))\n\t}\n\treturn res.Interface()\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/gg/stepmode_string.go", "content": "// Code generated by \"stringer -type StepMode\"; DO NOT EDIT\n\npackage gg\n\nimport \"fmt\"\n\nconst _StepMode_name = \"StepHVStepVHStepHMidStepVMid\"\n\nvar _StepMode_index = [...]uint8{0, 6, 12, 20, 28}\n\nfunc (i StepMode) String() string {\n\tif i < 0 || i >= StepMode(len(_StepMode_index)-1) {\n\t\treturn fmt.Sprintf(\"StepMode(%d)\", i)\n\t}\n\treturn _StepMode_name[_StepMode_index[i]:_StepMode_index[i+1]]\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/gg/testmain.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// +build ignore\n\npackage main\n\nimport (\n\t\"math\"\n\t\"math/rand\"\n\t\"os\"\n\n\t\"github.com/aclements/go-gg/gg\"\n\t\"github.com/aclements/go-gg/ggstat\"\n\t\"github.com/aclements/go-gg/table\"\n\t\"github.com/aclements/go-moremath/vec\"\n)\n\nfunc main() {\n\txs1 := vec.Linspace(-10, 10, 100)\n\tfor i := range xs1 {\n\t\txs1[i] = rand.Float64()*20 - 10\n\t}\n\tys1 := vec.Map(math.Sin, xs1)\n\n\txs2 := vec.Linspace(-10, 10, 100)\n\tys2 := vec.Map(math.Cos, xs2)\n\n\twhich := []string{}\n\tfor range xs1 {\n\t\twhich = append(which, \"sin\")\n\t}\n\tfor range xs2 {\n\t\twhich = append(which, \"cos\")\n\t}\n\n\txs := vec.Concat(xs1, xs2)\n\tys := vec.Concat(ys1, ys2)\n\n\ttab := table.NewBuilder(nil).Add(\"x\", xs).Add(\"y\", ys).Add(\"which\", which).Done()\n\n\tplot := gg.NewPlot(tab)\n\tplot.GroupAuto()\n\tplot.Add(gg.FacetX{Col: \"which\"})\n\tplot.Add(gg.FacetY{Col: \"which\"})\n\tplot.Add(gg.LayerLines{X: \"x\", Y: \"y\"})\n\n\tplot.Save()\n\tplot.SetData(ggstat.ECDF{X: \"x\"}.F(plot.Data()))\n\tplot.Add(gg.LayerSteps{Step: gg.StepHV})\n\t//plot.Add(gg.LayerSteps{Step:gg.StepHMid})\n\tplot.Restore()\n\n\tplot.Save()\n\tplot.SetData(ggstat.Density{X: \"x\"}.F(plot.Data()))\n\tplot.Add(gg.LayerPaths{})\n\tplot.Restore()\n\n\tplot.WriteSVG(os.Stdout, 400, 300)\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/gg/text.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage gg\n\nimport \"unicode/utf8\"\n\ntype textMetrics struct {\n\twidth float64\n\tleading float64\n}\n\n// measureString returns the metrics in pixels of s rendered in a font\n// with pixel size pxSize.\n//\n// TODO: Often all I want is the leading, which is much cheaper to get\n// than the width. Maybe textMetrics should have methods?\nfunc measureString(pxSize float64, s string) textMetrics {\n\t// TODO: This is absolutely horribly awful. Make it real,\n\t// perhaps using the freetype package.\n\n\t// Chrome's default font-size is 16px, so 20px is a reasonable\n\t// leading.\n\treturn textMetrics{\n\t\twidth: 0.5 * pxSize * float64(utf8.RuneCountInString(s)),\n\t\tleading: 1.25 * pxSize,\n\t}\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/gg/transform.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage gg\n\nimport \"github.com/aclements/go-gg/table\"\n\n// SortBy sorts each group by the named columns. If a column's type\n// implements sort.Interface, rows will be sorted according to that\n// order. Otherwise, the values in the column must be naturally\n// ordered (their types must be orderable by the Go specification). If\n// neither is true, SortBy panics with a *generic.TypeError. If more\n// than one column is given, SortBy sorts by the tuple of the columns;\n// that is, if two values in the first column are equal, they are\n// sorted by the second column, and so on.\nfunc (p *Plot) SortBy(cols ...string) *Plot {\n\treturn p.SetData(table.SortBy(p.Data(), cols...))\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/ggstat/agg.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage ggstat\n\nimport (\n\t\"fmt\"\n\t\"reflect\"\n\n\t\"github.com/aclements/go-gg/generic/slice\"\n\t\"github.com/aclements/go-gg/table\"\n\t\"github.com/aclements/go-moremath/stats\"\n\t\"github.com/aclements/go-moremath/vec\"\n)\n\n// TODO: AggFirst, AggTukey. StdDev?\n\n// Agg constructs an Aggregate transform from a grouping column and a\n// set of Aggregators.\n//\n// TODO: Does this belong in ggstat? The specific aggregator functions\n// probably do, but the concept could go in package table.\nfunc Agg(xs ...string) func(aggs ...Aggregator) Aggregate {\n\treturn func(aggs ...Aggregator) Aggregate {\n\t\treturn Aggregate{xs, aggs}\n\t}\n}\n\n// Aggregate computes aggregate functions of a table grouped by\n// distinct values of a column or set of columns.\n//\n// Aggregate first groups the table by the Xs columns. Each of these\n// groups produces a single row in the output table, where the unique\n// value of each of the Xs columns appears in the output row, along\n// with constant columns from the input, as well as any columns that\n// have a unique value within every group (they're \"effectively\"\n// constant). Additional columns in the output row are produced by\n// applying the Aggregator functions to the group.\ntype Aggregate struct {\n\t// Xs is the list column names to group values by before\n\t// computing aggregate functions.\n\tXs []string\n\n\t// Aggregators is the set of Aggregator functions to apply to\n\t// each group of values.\n\tAggregators []Aggregator\n}\n\n// An Aggregator is a function that aggregates each group of input\n// into one row and adds it to output. It may be based on multiple\n// columns from input and may add multiple columns to output.\ntype Aggregator func(input table.Grouping, output *table.Builder)\n\nfunc (s Aggregate) F(g table.Grouping) table.Grouping {\n\tisConst := make([]bool, len(g.Columns()))\n\tfor i := range isConst {\n\t\tisConst[i] = true\n\t}\n\n\tsubgroups := map[table.GroupID]table.Grouping{}\n\tfor _, gid := range g.Tables() {\n\t\tg := table.GroupBy(g.Table(gid), s.Xs...)\n\t\tsubgroups[gid] = g\n\n\t\tfor i, col := range g.Columns() {\n\t\t\tif !isConst[i] {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\t// Can this column be promoted to constant?\n\t\t\tfor _, gid2 := range g.Tables() {\n\t\t\t\tt := g.Table(gid2)\n\t\t\t\tisConst[i] = isConst[i] && checkConst(t, col)\n\t\t\t}\n\t\t}\n\t}\n\n\treturn table.MapTables(g, func(_ table.GroupID, t *table.Table) *table.Table {\n\t\tg := table.GroupBy(t, s.Xs...)\n\t\tvar nt table.Builder\n\n\t\t// Construct X columns.\n\t\trows := len(g.Tables())\n\t\tfor colidx, xcol := range s.Xs {\n\t\t\txs := reflect.MakeSlice(table.ColType(t, xcol), rows, rows)\n\t\t\tfor i, gid := range g.Tables() {\n\t\t\t\tfor j := 0; j < len(s.Xs)-colidx-1; j++ {\n\t\t\t\t\tgid = gid.Parent()\n\t\t\t\t}\n\t\t\t\txs.Index(i).Set(reflect.ValueOf(gid.Label()))\n\t\t\t}\n\n\t\t\tnt.Add(xcol, xs.Interface())\n\t\t}\n\n\t\t// Apply Aggregators.\n\t\tfor _, agg := range s.Aggregators {\n\t\t\tagg(g, &nt)\n\t\t}\n\n\t\t// Keep constant and effectively constant columns.\n\t\tfor i := range isConst {\n\t\t\tcol := t.Columns()[i]\n\t\t\tif !isConst[i] || nt.Has(col) {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tif cv, ok := t.Const(col); ok {\n\t\t\t\tnt.AddConst(col, cv)\n\t\t\t\tcontinue\n\t\t\t}\n\n\t\t\tncol := reflect.MakeSlice(table.ColType(t, col), len(g.Tables()), len(g.Tables()))\n\t\t\tfor i, gid := range g.Tables() {\n\t\t\t\tv := reflect.ValueOf(g.Table(gid).Column(col))\n\t\t\t\tncol.Index(i).Set(v.Index(0))\n\t\t\t}\n\t\t\tnt.Add(col, ncol.Interface())\n\t\t}\n\t\treturn nt.Done()\n\t})\n}\n\nfunc checkConst(t *table.Table, col string) bool {\n\tif _, ok := t.Const(col); ok {\n\t\treturn true\n\t}\n\tv := reflect.ValueOf(t.Column(col))\n\tif v.Len() <= 1 {\n\t\treturn true\n\t}\n\tif !v.Type().Elem().Comparable() {\n\t\treturn false\n\t}\n\telem := v.Index(0).Interface()\n\tfor i, l := 1, v.Len(); i < l; i++ {\n\t\tif elem != v.Index(i).Interface() {\n\t\t\treturn false\n\t\t}\n\t}\n\treturn true\n}\n\n// AggCount returns an aggregate function that computes the number of\n// rows in each group. The resulting column will be named label, or\n// \"count\" if label is \"\".\nfunc AggCount(label string) Aggregator {\n\tif label == \"\" {\n\t\tlabel = \"count\"\n\t}\n\n\treturn func(input table.Grouping, b *table.Builder) {\n\t\tcounts := make([]int, 0, len(input.Tables()))\n\t\tfor _, gid := range input.Tables() {\n\t\t\tcounts = append(counts, input.Table(gid).Len())\n\t\t}\n\t\tb.Add(label, counts)\n\t}\n}\n\n// AggMean returns an aggregate function that computes the mean of\n// each of cols. The resulting columns will be named \"mean \" and\n// will have the same type as .\nfunc AggMean(cols ...string) Aggregator {\n\treturn aggFn(stats.Mean, \"mean \", cols...)\n}\n\n// AggGeoMean returns an aggregate function that computes the\n// geometric mean of each of cols. The resulting columns will be named\n// \"geomean \" and will have the same type as .\nfunc AggGeoMean(cols ...string) Aggregator {\n\treturn aggFn(stats.GeoMean, \"geomean \", cols...)\n}\n\n// AggMin returns an aggregate function that computes the minimum of\n// each of cols. The resulting columns will be named \"min \" and\n// will have the same type as .\nfunc AggMin(cols ...string) Aggregator {\n\tmin := func(xs []float64) float64 {\n\t\tx, _ := stats.Bounds(xs)\n\t\treturn x\n\t}\n\treturn aggFn(min, \"min \", cols...)\n}\n\n// AggMax returns an aggregate function that computes the maximum of\n// each of cols. The resulting columns will be named \"max \" and\n// will have the same type as .\nfunc AggMax(cols ...string) Aggregator {\n\tmax := func(xs []float64) float64 {\n\t\t_, x := stats.Bounds(xs)\n\t\treturn x\n\t}\n\treturn aggFn(max, \"max \", cols...)\n}\n\n// AggSum returns an aggregate function that computes the sum of each\n// of cols. The resulting columns will be named \"sum \" and will\n// have the same type as .\nfunc AggSum(cols ...string) Aggregator {\n\treturn aggFn(vec.Sum, \"sum \", cols...)\n}\n\n// AggQuantile returns an aggregate function that computes a quantile\n// of each of cols. quantile has a range of [0,1]. The resulting\n// columns will be named \" \" and will have the same type\n// as .\nfunc AggQuantile(prefix string, quantile float64, cols ...string) Aggregator {\n\t// \"prefix\" could be autogenerated (e.g. fmt.Sprintf(\"p%g \",\n\t// quantile * 100)), but then the caller would need to do the\n\t// same fmt.Sprintf to compute the column name they had just\n\t// created. Perhaps Aggregator should provide a way to find\n\t// the generated column names.\n\treturn aggFn(func(data []float64) float64 {\n\t\treturn stats.Sample{Xs: data}.Quantile(quantile)\n\t}, prefix+\" \", cols...)\n}\n\nfunc aggFn(f func([]float64) float64, prefix string, cols ...string) Aggregator {\n\tocols := make([]string, len(cols))\n\tfor i, col := range cols {\n\t\tocols[i] = prefix + col\n\t}\n\n\treturn func(input table.Grouping, b *table.Builder) {\n\t\tfor coli, col := range cols {\n\t\t\tmeans := make([]float64, 0, len(input.Tables()))\n\n\t\t\tvar xs []float64\n\t\t\tfor _, gid := range input.Tables() {\n\t\t\t\tv := input.Table(gid).MustColumn(col)\n\t\t\t\tslice.Convert(&xs, v)\n\t\t\t\tmeans = append(means, f(xs))\n\t\t\t}\n\n\t\t\tct := table.ColType(input, col)\n\t\t\tif ct == float64SliceType {\n\t\t\t\tb.Add(ocols[coli], means)\n\t\t\t} else {\n\t\t\t\t// Convert means back to the type of col.\n\t\t\t\toutptr := reflect.New(ct)\n\t\t\t\tslice.Convert(outptr.Interface(), means)\n\t\t\t\tb.Add(ocols[coli], outptr.Elem().Interface())\n\t\t\t}\n\t\t}\n\t}\n}\n\n// AggUnique returns an aggregate function retains the unique value of\n// each of cols within each aggregate group, or panics if some group\n// contains more than one value for one of these columns.\n//\n// Note that Aggregate will automatically retain columns that happen\n// to be unique. AggUnique can be used to enforce at aggregation time\n// that certain columns *must* be unique (and get a nice error if they\n// are not).\nfunc AggUnique(cols ...string) Aggregator {\n\treturn func(input table.Grouping, b *table.Builder) {\n\t\tif len(cols) == 0 {\n\t\t\treturn\n\t\t}\n\t\tif len(input.Tables()) == 0 {\n\t\t\tpanic(fmt.Sprintf(\"unknown column: %q\", cols[0]))\n\t\t}\n\n\t\tfor _, col := range cols {\n\t\t\tctype := table.ColType(input, col)\n\t\t\trows := len(input.Tables())\n\t\t\tvs := reflect.MakeSlice(ctype, rows, rows)\n\t\t\tfor i, gid := range input.Tables() {\n\t\t\t\t// Get values in this column.\n\t\t\t\txs := reflect.ValueOf(input.Table(gid).MustColumn(col))\n\n\t\t\t\t// Check for uniqueness.\n\t\t\t\tif xs.Len() == 0 {\n\t\t\t\t\tpanic(fmt.Sprintf(\"cannot AggUnique empty column %q\", col))\n\t\t\t\t}\n\t\t\t\tuniquev := xs.Index(0)\n\t\t\t\tunique := uniquev.Interface()\n\t\t\t\tfor i, len := 1, xs.Len(); i < len; i++ {\n\t\t\t\t\tother := xs.Index(i).Interface()\n\t\t\t\t\tif unique != other {\n\t\t\t\t\t\tpanic(fmt.Sprintf(\"column %q is not unique; contains at least %v and %v\", col, unique, other))\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Store unique value.\n\t\t\t\tvs.Index(i).Set(uniquev)\n\t\t\t}\n\n\t\t\t// Add unique values slice to output table.\n\t\t\tb.Add(col, vs.Interface())\n\t\t}\n\t}\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/ggstat/bin.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage ggstat\n\nimport (\n\t\"math\"\n\t\"reflect\"\n\t\"sort\"\n\n\t\"github.com/aclements/go-gg/generic\"\n\t\"github.com/aclements/go-gg/generic/slice\"\n\t\"github.com/aclements/go-gg/table\"\n\t\"github.com/aclements/go-moremath/vec\"\n)\n\n// XXX If this is just based on the number of bins, it can come up\n// with really ugly boundary numbers. If the bin width is specified,\n// then you could also specify the left edge and bins will be placed\n// at [align+width*N, align+width*(N+1)]. ggplot2 also lets you\n// specify the center alignment.\n//\n// XXX In Matlab and NumPy, bins are open on the right *except* for\n// the last bin, which is closed on both.\n//\n// XXX Number of bins/bin width/specify boundaries, same bins across\n// all groups/separate for each group/based on shared scales (don't\n// have that information here), relative or absolute histogram (Matlab\n// has lots more).\n//\n// XXX Scale transform.\n//\n// The result of Bin has two columns in addition to constant columns from the input:\n//\n// - Column X is the left edge of the bin.\n//\n// - Column W is the sum of the rows' weights, or column \"count\" is\n// the number of rows in the bin.\ntype Bin struct {\n\t// X is the name of the column to use for samples.\n\tX string\n\n\t// W is the optional name of the column to use for sample\n\t// weights. It may be \"\" to weight each sample as 1.\n\tW string\n\n\t// Width controls how wide each bin should be. If not provided\n\t// or 0, a width will be chosen to produce 30 bins. If X is an\n\t// integer column, this width will be treated as an integer as\n\t// well.\n\tWidth float64\n\n\t// Center controls the center point of each bin. To center on\n\t// integers, for example, you could use {Width: 1, Center:\n\t// 0}.\n\t// XXX What does center mean for integers? Should an unspecified center yield an autochosen one, or 0?\n\t//Center float64\n\n\t// Breaks is the set of break points to use as boundaries\n\t// between bins. The interval of each bin is [Breaks[i],\n\t// Breaks[i+1]). Data points before the first break are\n\t// dropped. If provided, Width and Center are ignored.\n\tBreaks table.Slice\n\n\t// SplitGroups indicates that each group in the table should\n\t// have separate bounds based on the data in that group alone.\n\t// The default, false, indicates that the binning function\n\t// should use the bounds of all of the data combined. This\n\t// makes it easier to compare bins across groups.\n\tSplitGroups bool\n}\n\nfunc (b Bin) F(g table.Grouping) table.Grouping {\n\tbreaks := reflect.ValueOf(b.Breaks)\n\tagg := AggCount(\"count\")\n\tif b.W != \"\" {\n\t\tagg = aggFn(vec.Sum, \"\", b.W)\n\t}\n\tif !breaks.IsValid() && !b.SplitGroups {\n\t\tbreaks = b.computeBreaks(g)\n\t}\n\t// Change b.X to the start of the bin.\n\tg = table.MapTables(g, func(_ table.GroupID, t *table.Table) *table.Table {\n\t\tbreaks := breaks\n\t\tif !breaks.IsValid() {\n\t\t\tbreaks = b.computeBreaks(t)\n\t\t}\n\t\tnbreaks := breaks.Len()\n\n\t\tin := reflect.ValueOf(t.MustColumn(b.X))\n\t\tnin := in.Len()\n\n\t\tout := reflect.MakeSlice(breaks.Type(), nin, nin)\n\t\tvar found []int\n\t\tfor i := 0; i < nin; i++ {\n\t\t\telt := in.Index(i)\n\t\t\tbin := sort.Search(nbreaks, func(j int) bool {\n\t\t\t\treturn generic.OrderR(elt, breaks.Index(j)) < 0\n\t\t\t})\n\t\t\t// 0 means the row doesn't fit on the front\n\t\t\t// XXX Allow configuring the first and last bin as infinite or not.\n\t\t\tbin = bin - 1\n\t\t\tif bin >= 0 {\n\t\t\t\tfound = append(found, i)\n\t\t\t\tout.Index(i).Set(breaks.Index(bin))\n\t\t\t}\n\t\t}\n\t\tvar nt table.Builder\n\t\tfor _, col := range t.Columns() {\n\t\t\tif col == b.X {\n\t\t\t\tnt.Add(col, slice.Select(out.Interface(), found))\n\t\t\t} else if c, ok := t.Const(col); ok {\n\t\t\t\tnt.AddConst(col, c)\n\t\t\t} else {\n\t\t\t\tnt.Add(col, slice.Select(t.Column(col), found))\n\t\t\t}\n\t\t}\n\t\treturn nt.Done()\n\t})\n\t// Group by the found bin\n\treturn Agg(b.X)(agg).F(g)\n}\n\nfunc (b Bin) computeBreaks(g table.Grouping) reflect.Value {\n\tvar cols []slice.T\n\tfor _, gid := range g.Tables() {\n\t\tcols = append(cols, g.Table(gid).MustColumn(b.X))\n\t}\n\tdata := slice.Concat(cols...)\n\n\tmin := slice.Min(data)\n\tmax := slice.Max(data)\n\n\trv := reflect.ValueOf(min)\n\tswitch rv.Type().Kind() {\n\tcase reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:\n\t\tmin, max := rv.Int(), reflect.ValueOf(max).Int()\n\t\twidth := int64(b.Width)\n\t\tif width == 0 {\n\t\t\twidth = (max - min) / 30\n\t\t\tif width < 1 {\n\t\t\t\twidth = 1\n\t\t\t}\n\t\t}\n\t\t// XXX: This assumes boundaries should be aligned with\n\t\t// 0. We should support explicit Center or Boundary\n\t\t// requests.\n\t\tmin -= (min % width)\n\t\tvar breaks []int64\n\t\tfor i := min; i < max; i += width {\n\t\t\tbreaks = append(breaks, i)\n\t\t}\n\t\touts := reflect.New(reflect.ValueOf(cols[0]).Type())\n\t\tslice.Convert(outs.Interface(), breaks)\n\t\treturn outs.Elem()\n\tcase reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:\n\t\tmin, max := rv.Uint(), reflect.ValueOf(max).Uint()\n\t\twidth := uint64(b.Width)\n\t\tif width == 0 {\n\t\t\twidth = (max - min) / 30\n\t\t\tif width < 1 {\n\t\t\t\twidth = 1\n\t\t\t}\n\t\t}\n\t\tmin -= (min % width)\n\t\tvar breaks []uint64\n\t\tfor i := min; i < max; i += width {\n\t\t\tbreaks = append(breaks, i)\n\t\t}\n\t\touts := reflect.New(reflect.ValueOf(cols[0]).Type())\n\t\tslice.Convert(outs.Interface(), breaks)\n\t\treturn outs.Elem()\n\tcase reflect.Float32, reflect.Float64:\n\t\tmin, max := rv.Float(), reflect.ValueOf(max).Float()\n\t\twidth := b.Width\n\t\tif width == 0 {\n\t\t\twidth = (max - min) / 30\n\t\t\tif width == 0 {\n\t\t\t\twidth = 1\n\t\t\t}\n\t\t}\n\t\tmin -= math.Mod(min, width)\n\t\tvar breaks []float64\n\t\tfor i := min; i < max; i += width {\n\t\t\tbreaks = append(breaks, i)\n\t\t}\n\t\touts := reflect.New(reflect.ValueOf(cols[0]).Type())\n\t\tslice.Convert(outs.Interface(), breaks)\n\t\treturn outs.Elem()\n\tdefault:\n\t\tpanic(\"can't compute breaks for unknown type\")\n\t}\n}\n\n// TODO: Count for categorical data.\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/ggstat/common.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage ggstat\n\nimport \"reflect\"\n\nvar float64Type = reflect.TypeOf(float64(0))\nvar float64SliceType = reflect.TypeOf([]float64(nil))\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/ggstat/density.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage ggstat\n\nimport (\n\t\"github.com/aclements/go-gg/generic/slice\"\n\t\"github.com/aclements/go-gg/table\"\n\t\"github.com/aclements/go-moremath/stats\"\n\t\"github.com/aclements/go-moremath/vec\"\n)\n\n// TODO: Default to first (and second) column for X (and Y)?\n\n// Density constructs a probability density estimate from a set of\n// samples using kernel density estimation.\n//\n// X is the only required field. All other fields have reasonable\n// default zero values.\n//\n// The result of Density has three columns in addition to constant\n// columns from the input:\n//\n// - Column X is the points at which the density estimate is sampled.\n//\n// - Column \"probability density\" is the density estimate.\n//\n// - Column \"cumulative density\" is the cumulative density estimate.\ntype Density struct {\n\t// X is the name of the column to use for samples.\n\tX string\n\n\t// W is the optional name of the column to use for sample\n\t// weights. It may be \"\" to uniformly weight samples.\n\tW string\n\n\t// N is the number of points to sample the KDE at. If N is 0,\n\t// a reasonable default is used.\n\t//\n\t// TODO: This is particularly sensitive to the scale\n\t// transform.\n\t//\n\t// TODO: Base the default on the bandwidth. If the bandwidth\n\t// is really narrow, we may need a lot of samples to exceed\n\t// the Nyquist rate.\n\tN int\n\n\t// Domain specifies the domain at which to sample this function.\n\t// If Domain is nil, it defaults to DomainData{}.\n\tDomain FunctionDomainer\n\n\t// Kernel is the kernel to use for the KDE.\n\tKernel stats.KDEKernel\n\n\t// Bandwidth is the bandwidth to use for the KDE.\n\t//\n\t// If this is zero, the bandwidth is computed from the data\n\t// using a default bandwidth estimator (currently\n\t// stats.BandwidthScott).\n\tBandwidth float64\n\n\t// BoundaryMethod is the boundary correction method to use for\n\t// the KDE. The default value is BoundaryReflect; however, the\n\t// default bounds are effectively +/-inf, which is equivalent\n\t// to performing no boundary correction.\n\tBoundaryMethod stats.KDEBoundaryMethod\n\n\t// [BoundaryMin, BoundaryMax) specify a bounded support for\n\t// the KDE. If both are 0 (their default values), they are\n\t// treated as +/-inf.\n\t//\n\t// To specify a half-bounded support, set Min to math.Inf(-1)\n\t// or Max to math.Inf(1).\n\tBoundaryMin float64\n\tBoundaryMax float64\n}\n\nfunc (d Density) F(g table.Grouping) table.Grouping {\n\tkde := stats.KDE{\n\t\tKernel: d.Kernel,\n\t\tBandwidth: d.Bandwidth,\n\t\tBoundaryMethod: d.BoundaryMethod,\n\t\tBoundaryMin: d.BoundaryMin,\n\t\tBoundaryMax: d.BoundaryMax,\n\t}\n\tdname, cname := \"probability density\", \"cumulative density\"\n\n\taddEmpty := func(out *table.Builder) {\n\t\tout.Add(dname, []float64{})\n\t\tout.Add(cname, []float64{})\n\t}\n\n\treturn Function{\n\t\tX: d.X, N: d.N, Domain: d.Domain,\n\t\tFn: func(gid table.GroupID, in *table.Table, sampleAt []float64, out *table.Builder) {\n\t\t\tif len(sampleAt) == 0 {\n\t\t\t\taddEmpty(out)\n\t\t\t\treturn\n\t\t\t}\n\n\t\t\t// Get input sample.\n\t\t\tvar sample stats.Sample\n\t\t\tslice.Convert(&sample.Xs, in.MustColumn(d.X))\n\t\t\tif d.W != \"\" {\n\t\t\t\tslice.Convert(&sample.Weights, in.MustColumn(d.W))\n\t\t\t\tif sample.Weight() == 0 {\n\t\t\t\t\taddEmpty(out)\n\t\t\t\t\treturn\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Compute KDE.\n\t\t\tkde.Sample = sample\n\t\t\tif d.Bandwidth == 0 {\n\t\t\t\tkde.Bandwidth = stats.BandwidthScott(sample)\n\t\t\t}\n\n\t\t\tout.Add(dname, vec.Map(kde.PDF, sampleAt))\n\t\t\tout.Add(cname, vec.Map(kde.CDF, sampleAt))\n\t\t},\n\t}.F(g)\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/ggstat/domain.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage ggstat\n\nimport (\n\t\"math\"\n\n\t\"github.com/aclements/go-gg/generic/slice\"\n\t\"github.com/aclements/go-gg/table\"\n\t\"github.com/aclements/go-moremath/stats\"\n)\n\n// A FunctionDomainer computes the domain over which to evaluate a\n// statistical function.\ntype FunctionDomainer interface {\n\t// FunctionDomain computes the domain of a particular column\n\t// within a table. It takes a Grouping and a column in that\n\t// Grouping to compute the domain of and returns a function\n\t// that computes the domain for a specific group in the\n\t// Grouping. This makes it possible for FunctionDomain to\n\t// easily compute either Grouping-wide domains, or per-Table\n\t// domains.\n\t//\n\t// The returned domain may be (NaN, NaN) to indicate that\n\t// there is no data and the domain is vacuous.\n\tFunctionDomain(g table.Grouping, col string) func(gid table.GroupID) (min, max float64)\n}\n\n// DomainFixed is a FunctionDomainer that returns a fixed domain.\ntype DomainFixed struct {\n\tMin, Max float64\n}\n\nvar _ FunctionDomainer = DomainFixed{}\n\nfunc (r DomainFixed) FunctionDomain(g table.Grouping, col string) func(gid table.GroupID) (min, max float64) {\n\treturn func(table.GroupID) (min, max float64) {\n\t\treturn r.Min, r.Max\n\t}\n}\n\n// DomainData is a FunctionDomainer that computes domains based on the\n// bounds of the data.\ntype DomainData struct {\n\t// Widen expands the domain by Widen times the span of the\n\t// data.\n\t//\n\t// A value of 1.0 means to use exactly the bounds of the data.\n\t// If Widen is 0, it is treated as 1.1 (that is, widen the\n\t// domain by 10%, or 5% on the left and 5% on the right).\n\tWiden float64\n\n\t// SplitGroups indicates that each group in the table should\n\t// have a separate domain based on the data in that group\n\t// alone. The default, false, indicates that the domain should\n\t// be based on all of the data in the table combined. This\n\t// makes it possible to stack functions and easier to compare\n\t// them across groups.\n\tSplitGroups bool\n}\n\nvar _ FunctionDomainer = DomainData{}\n\nconst defaultWiden = 1.1\n\nfunc (r DomainData) FunctionDomain(g table.Grouping, col string) func(gid table.GroupID) (min, max float64) {\n\twiden := r.Widen\n\tif widen <= 0 {\n\t\twiden = defaultWiden\n\t}\n\n\tvar xs []float64\n\tif !r.SplitGroups {\n\t\t// Compute combined bounds.\n\t\tgmin, gmax := math.NaN(), math.NaN()\n\t\tfor _, gid := range g.Tables() {\n\t\t\tt := g.Table(gid)\n\t\t\tslice.Convert(&xs, t.MustColumn(col))\n\t\t\txmin, xmax := stats.Bounds(xs)\n\t\t\tif xmin < gmin || math.IsNaN(gmin) {\n\t\t\t\tgmin = xmin\n\t\t\t}\n\t\t\tif xmax > gmax || math.IsNaN(gmax) {\n\t\t\t\tgmax = xmax\n\t\t\t}\n\t\t}\n\n\t\t// Widen bounds.\n\t\tspan := gmax - gmin\n\t\tgmin, gmax = gmin-span*(widen-1)/2, gmax+span*(widen-1)/2\n\n\t\treturn func(table.GroupID) (min, max float64) {\n\t\t\treturn gmin, gmax\n\t\t}\n\t}\n\n\treturn func(gid table.GroupID) (min, max float64) {\n\t\t// Compute bounds.\n\t\tslice.Convert(&xs, g.Table(gid).MustColumn(col))\n\t\tmin, max = stats.Bounds(xs)\n\n\t\t// Widen bounds.\n\t\tspan := max - min\n\t\tmin, max = min-span*(widen-1)/2, max+span*(widen-1)/2\n\t\treturn\n\t}\n}\n" }, { "path": "benchplot/vendor/github.com/aclements/go-gg/ggstat/ecdf.go", "content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage ggstat\n\nimport (\n\t\"github.com/aclements/go-gg/generic/slice\"\n\t\"github.com/aclements/go-gg/table\"\n\t\"github.com/aclements/go-moremath/vec\"\n)\n\n// ECDF constructs an empirical CDF from a set of samples.\n//\n// X is the only required field. All other fields have reasonable\n// default zero values.\n//\n// The result of ECDF has three columns in addition to constant\n// columns from the input. The names of the columns depend on whether\n// Label is \"\".\n//\n// - Column X is the points at which the CDF changes (a subset of the\n// samples).\n//\n// - Column \"cumulative density\" or \"cumulative density of