// Plots the historgram using plotinum func Histogram(r RetCalc) { //eb := all_paths.End_balances() eb := make([]float64, len(r.All_paths), len(r.All_paths)) incs := r.RunIncomes() for i := range incs { eb[i] = incs[i] } v := make(plotter.Values, len(eb)) for i := range v { v[i] = eb[i] } p, err := plot.New() if err != nil { panic(err) } p.Title.Text = "Histogram" h, err := plotter.NewHist(v, 100) if err != nil { panic(err) } //h.Normalize(1) p.Add(h) if err := p.Save(4, 4, "hist.png"); err != nil { panic(err) } fmt.Println(h) }
// Example_quartPlots draws vertical quartile plots. func Example_quartPlots() *plot.Plot { rand.Seed(int64(0)) n := 100 uniform := make(plotter.Values, n) normal := make(plotter.Values, n) expon := make(plotter.Values, n) for i := 0; i < n; i++ { uniform[i] = rand.Float64() normal[i] = rand.NormFloat64() expon[i] = rand.ExpFloat64() } p, err := plot.New() if err != nil { panic(err) } p.Title.Text = "Quartile Plot" p.Y.Label.Text = "plotter.Values" p.Add(must(plotter.NewQuartPlot(0, uniform)).(*plotter.QuartPlot), must(plotter.NewQuartPlot(1, normal)).(*plotter.QuartPlot), must(plotter.NewQuartPlot(2, expon)).(*plotter.QuartPlot)) // Set the X axis of the plot to nominal with // the given names for x=0, x=1 and x=2. p.NominalX("Uniform\nDistribution", "Normal\nDistribution", "Exponential\nDistribution") return p }
func plotData(name string, us, ys, ts, fs []float64) { p, err := plot.New() if err != nil { fmt.Printf("Cannot create new plot: %s\n", err) return } p.Title.Text = "Least-square fit of convex function" p.X.Min = -0.1 p.X.Max = 2.3 p.Y.Min = -1.1 p.Y.Max = 7.2 p.Add(plotter.NewGrid()) pts := plotter.NewScatter(dataset(us, ys)) pts.GlyphStyle.Color = color.RGBA{R: 255, A: 255} fit := plotter.NewLine(dataset(ts, fs)) fit.LineStyle.Width = vg.Points(1) fit.LineStyle.Color = color.RGBA{B: 255, A: 255} p.Add(pts) p.Add(fit) if err := p.Save(4, 4, name); err != nil { fmt.Printf("Save to '%s' failed: %s\n", name, err) } }
// Plot saves an image of the latency histogram to filePath. The extension of filePath defines // the format to be used - png, svg, etc. func Plot(h *latency.Histogram, description, filePath string) error { count := len(h.Buckets) xys := make(plotter.XYs, count) for bucket, freq := range h.Buckets { xys[bucket].X = float64(bucket) xys[bucket].Y = float64(freq) } p, err := plot.New() if err != nil { return fmt.Errorf("error generating plot: %v", err) } p.Title.Text = description p.X.Label.Text = fmt.Sprintf("Latency (%v resolution)", h.Resolution) p.Y.Label.Text = "Frequency" hh, err := plotter.NewHistogram(xys, count) if err != nil { return fmt.Errorf("error generating histogram: %v", err) } p.Add(hh) // Save the plot to a file. Units in inches (one inch == 72 points). fmt.Fprintf(os.Stderr, "Saving latency histogram to %v\n", filePath) return p.Save(8, 6, filePath) }
func test1() { rand.Seed(int64(0)) p, err := plot.New() if err != nil { panic(err) } p.Title.Text = "Plotutil example" p.X.Label.Text = "X" p.Y.Label.Text = "Y" err = plotutil.AddLinePoints(p, "First", randomPoints(15), "Second", randomPoints(15), "Third", randomPoints(15)) if err != nil { panic(err) } // Save the plot to a PNG file. if err := p.Save(4, 4, "points.png"); err != nil { panic(err) } }
func test_point() { rand.Seed(int64(0)) points_data := randomPoint(200) points_data2 := randomPoint(50) p, err := plot.New() if err != nil { panic(err) } p.Title.Text = "Points" p.X.Label.Text = "X" p.Y.Label.Text = "Y" bs, _ := plotter.NewBubbles(points_data, vg.Points(5), vg.Points(5)) bs2, _ := plotter.NewBubbles(points_data2, vg.Points(5), vg.Points(5)) bs.Color = color.RGBA{R: 255, G: 0, B: 0, A: 255} bs2.Color = color.RGBA{R: 0, G: 255, B: 0, A: 255} p.Add(bs) p.Add(bs2) if err := p.Save(10, 10, "points.png"); err != nil { panic(err) } }
func plotData(name string, xs, ys []float64) { p, err := plot.New() if err != nil { fmt.Printf("Cannot create new plot: %s\n", err) return } p.Title.Text = "Chernoff lower bound" p.X.Label.Text = "Sigma" p.X.Min = 0.2 p.X.Max = 0.5 p.Y.Label.Text = "Probability of correct detection" p.Y.Min = 0.9 p.Y.Max = 1.0 p.Add(plotter.NewGrid()) l := plotter.NewLine(dataset(xs, ys)) l.LineStyle.Width = vg.Points(1) //l.LineStyle.Dashes = []vg.Length(vg.Points(5), vg.Points(5)) l.LineStyle.Color = color.RGBA{B: 255, A: 255} p.Add(l) if err := p.Save(4, 4, name); err != nil { fmt.Printf("Save to '%s' failed: %s\n", name, err) } }
// Example_boxPlots draws vertical boxplots. func Example_boxPlots() *plot.Plot { rand.Seed(int64(0)) n := 100 uniform := make(plotter.Values, n) normal := make(plotter.Values, n) expon := make(plotter.Values, n) for i := 0; i < n; i++ { uniform[i] = rand.Float64() normal[i] = rand.NormFloat64() expon[i] = rand.ExpFloat64() } p, err := plot.New() if err != nil { panic(err) } p.Title.Text = "Box Plot" p.Y.Label.Text = "plotter.Values" // Make boxes for our data and add them to the plot. p.Add(plotter.NewBoxPlot(vg.Points(20), 0, uniform), plotter.NewBoxPlot(vg.Points(20), 1, normal), plotter.NewBoxPlot(vg.Points(20), 2, expon)) // Set the X axis of the plot to nominal with // the given names for x=0, x=1 and x=2. p.NominalX("Uniform\nDistribution", "Normal\nDistribution", "Exponential\nDistribution") return p }
// draw is a generic plotter of labelled lines. func draw(lines graph, title, xLabel, yLabel string) error { p, err := plot.New() if err != nil { return fmt.Errorf(err.Error()) } p.Title.Text = title p.X.Label.Text = xLabel p.Y.Label.Text = yLabel i := 0 for legend, data := range lines { i = i + 1 l, err := plotter.NewLine(xys(data)) if err != nil { return fmt.Errorf(err.Error()) } p.Add(l) p.Legend.Add(legend, l) l.LineStyle.Color = getColor(i) } if err != nil { return fmt.Errorf(err.Error()) } name := strings.Replace(strings.ToLower(title), " ", "-", -1) filename := fmt.Sprintf("strategy-%s.svg", name) if err := p.Save(8, 8, filename); err != nil { return fmt.Errorf(err.Error()) } return nil }
func Example_groupedHorizontalQuartPlots() *plot.Plot { rand.Seed(int64(0)) n := 100 uniform := make(plotter.Values, n) normal := make(plotter.Values, n) expon := make(plotter.Values, n) for i := 0; i < n; i++ { uniform[i] = rand.Float64() normal[i] = rand.NormFloat64() expon[i] = rand.ExpFloat64() } p, err := plot.New() if err != nil { panic(err) } p.Title.Text = "Box Plot" p.Y.Label.Text = "plotter.Values" w := vg.Points(10) for x := 0.0; x < 3.0; x++ { b0 := must(plotter.MakeHorizQuartPlot(x, uniform)).(plotter.HorizQuartPlot) b0.Offset = -w b1 := must(plotter.MakeHorizQuartPlot(x, normal)).(plotter.HorizQuartPlot) b2 := must(plotter.MakeHorizQuartPlot(x, expon)).(plotter.HorizQuartPlot) b2.Offset = w p.Add(b0, b1, b2) } p.Add(plotter.NewGlyphBoxes()) p.NominalY("Group 0", "Group 1", "Group 2") return p }
// Draw the plotinum logo. func Example_logo() *plot.Plot { p, err := plot.New() if err != nil { panic(err) } plotter.DefaultLineStyle.Width = vg.Points(1) plotter.DefaultGlyphStyle.Radius = vg.Points(3) p.Y.Tick.Marker = plot.ConstantTicks([]plot.Tick{ {0, "0"}, {0.25, ""}, {0.5, "0.5"}, {0.75, ""}, {1, "1"}, }) p.X.Tick.Marker = plot.ConstantTicks([]plot.Tick{ {0, "0"}, {0.25, ""}, {0.5, "0.5"}, {0.75, ""}, {1, "1"}, }) pts := plotter.XYs{{0, 0}, {0, 1}, {0.5, 1}, {0.5, 0.6}, {0, 0.6}} line := must(plotter.NewLine(pts)).(*plotter.Line) scatter := must(plotter.NewScatter(pts)).(*plotter.Scatter) p.Add(line, scatter) pts = plotter.XYs{{1, 0}, {0.75, 0}, {0.75, 0.75}} line = must(plotter.NewLine(pts)).(*plotter.Line) scatter = must(plotter.NewScatter(pts)).(*plotter.Scatter) p.Add(line, scatter) pts = plotter.XYs{{0.5, 0.5}, {1, 0.5}} line = must(plotter.NewLine(pts)).(*plotter.Line) scatter = must(plotter.NewScatter(pts)).(*plotter.Scatter) p.Add(line, scatter) return p }
// Example_errBars draws points and error bars. func Example_errBars() *plot.Plot { type errPoints struct { plotter.XYs plotter.YErrors plotter.XErrors } rand.Seed(int64(0)) n := 15 data := errPoints{ XYs: randomPoints(n), YErrors: plotter.YErrors(randomError(n)), XErrors: plotter.XErrors(randomError(n)), } p, err := plot.New() if err != nil { panic(err) } scatter := must(plotter.NewScatter(data)).(*plotter.Scatter) scatter.Shape = plot.CrossGlyph{} xerrs, err := plotter.NewXErrorBars(data) if err != nil { panic(err) } yerrs, err := plotter.NewYErrorBars(data) if err != nil { panic(err) } p.Add(scatter, xerrs, yerrs) p.Add(plotter.NewGlyphBoxes()) return p }
// An example of making a histogram. func Example_histogram() *plot.Plot { rand.Seed(int64(0)) n := 10000 vals := make(plotter.Values, n) for i := 0; i < n; i++ { vals[i] = rand.NormFloat64() } p, err := plot.New() if err != nil { panic(err) } p.Title.Text = "Histogram" h, err := plotter.NewHist(vals, 16) if err != nil { panic(err) } h.Normalize(1) p.Add(h) // The normal distribution function norm := plotter.NewFunction(stdNorm) norm.Color = color.RGBA{R: 255, A: 255} norm.Width = vg.Points(2) p.Add(norm) return p }
func main() { // Get some random data. n, m := 5, 10 pts := make([]plotter.XYer, n) for i := range pts { xys := make(plotter.XYs, m) pts[i] = xys center := float64(i) for j := range xys { xys[j].X = center + (rand.Float64() - 0.5) xys[j].Y = center + (rand.Float64() - 0.5) } } plt, err := plot.New() if err != nil { panic(err) } mean95 := plotutil.NewErrorPoints(plotutil.MeanAndConf95, pts...) medMinMax := plotutil.NewErrorPoints(plotutil.MedianAndMinMax, pts...) plotutil.AddLinePoints(plt, "mean and 95% confidence", mean95, "median and minimum and maximum", medMinMax) plotutil.AddErrorBars(plt, mean95, medMinMax) plotutil.AddScatters(plt, pts[0], pts[1], pts[2], pts[3], pts[4]) plt.Save(4, 4, "errpoints.png") }
// createLine creates a line graph from provided x,y data and title func createLine(xdat, ydat [][]float64, ylab []string, title string) { p, err := plot.New() if err != nil { panic(err) } p.Add(plotter.NewGrid()) p.Title.Text = title p.Legend.Top = true p.Legend.XOffs = -10.0 p.Legend.YOffs = -10.0 var scatdata xyer var s *plotter.Line for i, _ := range ydat { scatdata = xyer{xdat[i], ydat[i]} s = plotter.NewLine(scatdata) s.LineStyle.Width = 2 s.LineStyle.Color = cols[i] p.Add(s) p.Legend.Add(ylab[i], s) } p.X.Max = 2.5 p.Y.Max = 3.5 p.X.Label.Text = "Time / ps" p.Y.Label.Text = "Probability density" if err := p.Save(5, 5, "out/"+title+".png"); err != nil { panic(err) } }
func plotLine(xy plotter.XYs) (image.Image, error) { p, err := plot.New() if err != nil { return nil, err } p.HideAxes() p.BackgroundColor = &color.RGBA{0, 0, 0, 255} //s, err := NewSparkLines(xy) s, err := plotter.NewLine(xy) if err != nil { return nil, err } s.Color = &color.RGBA{0, 255, 0, 128} p.Add(s) // Draw the plot to an in-memory image. // _, rows, _ := terminal.GetSize(0) charWidth := optCharWidth charHeight := optCharHeight //width := cols * charWidth height := optRows * charHeight img := image.NewRGBA(image.Rect(0, 0, 5+(len(xy)*charWidth), height)) canvas := vgimg.NewImage(img) da := plot.MakeDrawArea(canvas) p.Draw(da) return img, nil }
// Example_groupedBoxPlots draws vertical boxplots. func Example_groupedBoxPlots() *plot.Plot { rand.Seed(int64(0)) n := 100 uniform := make(plotter.Values, n) normal := make(plotter.Values, n) expon := make(plotter.Values, n) for i := 0; i < n; i++ { uniform[i] = rand.Float64() normal[i] = rand.NormFloat64() expon[i] = rand.ExpFloat64() } p, err := plot.New() if err != nil { panic(err) } p.Title.Text = "Box Plot" p.Y.Label.Text = "plotter.Values" w := vg.Points(20) for x := 0.0; x < 3.0; x++ { b0 := must(plotter.NewBoxPlot(w, x, uniform)).(*plotter.BoxPlot) b0.Offset = -w - vg.Points(3) b1 := must(plotter.NewBoxPlot(w, x, normal)).(*plotter.BoxPlot) b2 := must(plotter.NewBoxPlot(w, x, expon)).(*plotter.BoxPlot) b2.Offset = w + vg.Points(3) p.Add(b0, b1, b2) } // Set the X axis of the plot to nominal with // the given names for x=0, x=1 and x=2. p.NominalX("Group 0", "Group 1", "Group 2") return p }
// Example_functions draws some functions. func Example_functions() *plot.Plot { p, err := plot.New() if err != nil { panic(err) } p.Title.Text = "Functions" p.X.Label.Text = "X" p.Y.Label.Text = "Y" quad := plotter.NewFunction(func(x float64) float64 { return x * x }) quad.Color = color.RGBA{B: 255, A: 255} exp := plotter.NewFunction(func(x float64) float64 { return math.Pow(2, x) }) exp.Dashes = []vg.Length{vg.Points(2), vg.Points(2)} exp.Width = vg.Points(2) exp.Color = color.RGBA{G: 255, A: 255} sin := plotter.NewFunction(func(x float64) float64 { return 10*math.Sin(x) + 50 }) sin.Dashes = []vg.Length{vg.Points(4), vg.Points(5)} sin.Width = vg.Points(4) sin.Color = color.RGBA{R: 255, A: 255} p.Add(quad, exp, sin) p.Legend.Add("x^2", quad) p.Legend.Add("2^x", exp) p.Legend.Add("10*sin(x)+50", sin) p.Legend.ThumbnailWidth = vg.Inches(0.5) p.X.Min = 0 p.X.Max = 10 p.Y.Min = 0 p.Y.Max = 100 return p }
func main() { var maxworker = *flag.Int("maxworkers", MAXWORKER, "Maxworker") var queryNum = *flag.Int("qpr", QN, "query per worker") flag.Parse() fmt.Println(maxworker, queryNum) p, err := plot.New() if err != nil { panic(err) } p.Title.Text = "Query per second" p.X.Label.Text = "query number" p.Y.Label.Text = "query per second" pts := make(plotter.XYs, queryNum) for i := 10; i <= maxworker; i = i + 3 { for j := 1; j <= queryNum; j++ { val := mainLoop(i, j) pts[j-1].X = float64(j) pts[j-1].Y = val } err = plotutil.AddLinePointsColor(p, i, "Number of worker "+strconv.Itoa(i), pts) if err != nil { panic(err) } } if err := p.Save(4, 4, "points.png"); err != nil { panic(err) } }
func histPlot() *plot.Plot { // Draw some random values from the standard // normal distribution. rand.Seed(int64(0)) v := make(plotter.Values, 1000) for i := range v { v[i] = rand.NormFloat64() } // Make a plot and set its title. p, err := plot.New() if err != nil { panic(err) } p.Title.Text = "Histogram" // Create a histogram of our values drawn // from the standard normal. h, err := plotter.NewHist(v, 16) if err != nil { panic(err) } // Normalize the area under the histogram to // sum to one. h.Normalize(1) p.Add(h) // The normal distribution function norm := plotter.NewFunction(stdNorm) norm.Color = color.RGBA{R: 255, A: 255} norm.Width = vg.Points(2) p.Add(norm) return p }
func main() { fmt.Println("Running...") start := time.Now() A2 = make([]float64, 2) A3 = make([]float64, 3) A1 = 1 A2[0] = 1.0 / (3.0 * LaguerreD(2, z2[0]) * Laguerre(3, z2[0])) A2[1] = 1.0 / (3.0 * LaguerreD(2, z2[1]) * Laguerre(3, z2[1])) A3[0] = 1.0 / (4.0 * LaguerreD(3, z3[0]) * Laguerre(4, z3[0])) A3[1] = 1.0 / (4.0 * LaguerreD(3, z3[1]) * Laguerre(4, z3[1])) A3[2] = 1.0 / (4.0 * LaguerreD(3, z3[2]) * Laguerre(4, z3[2])) pt = make(plotter.XYs, nPlot) x = make([]float64, nPlot) dx := (xmax - xmin) / float64(nPlot-1) for i := range x { x[i] = dx*float64(i) + xmin pt[i].X = x[i] pt[i].Y = (math.Gamma(x[i])) } var p1, p2, p3 plotter.XYs p1 = make(plotter.XYs, nPlot) p2 = make(plotter.XYs, nPlot) p3 = make(plotter.XYs, nPlot) for i := range x { p1[i].X = x[i] p2[i].X = x[i] p3[i].X = x[i] p1[i].Y = (A1 * math.Pow(z1, x[i]-1)) p2[i].Y = (A2[0]*math.Pow(z2[0], x[i]-1) + A2[1]*math.Pow(z2[1], x[i]-1)) p3[i].Y = (A3[0]*math.Pow(z3[0], x[i]-1) + A3[1]*math.Pow(z3[1], x[i]-1) + A3[2]*math.Pow(z3[2], x[i]-1)) } p, err := plot.New() if err != nil { panic(err) } p.Title.Text = fmt.Sprintf("Gamma Function Approximations") p.Y.Label.Text = "Log(y)" p.X.Label.Text = "x" plotutil.AddLinePoints(p, "Log(Gamma)", pt, "m=0", p1, "m=1", p2, "m=2", p3) // Save the plot to a PNG file. if err := p.Save(6, 4, "gammaLow.png"); err != nil { panic(err) } fmt.Println(time.Since(start)) fmt.Println("...program terminated successfully!") }
func main() { if len(os.Args) != 2 { fmt.Fprintf(os.Stderr, "Usage: simpleRead <file.wav>\n") os.Exit(1) } // open file testInfo, err := os.Stat(os.Args[1]) checkErr(err) testWav, err := os.Open(os.Args[1]) checkErr(err) wavReader, err := wav.NewWavReader(testWav, testInfo.Size()) checkErr(err) // File informations fmt.Println(wavReader) // limit sample count sampleCnt := wavReader.GetSampleCount() if sampleCnt > 10000 { sampleCnt = 10000 } // setup plotter p, err := plot.New() checkErr(err) p.Title.Text = "Waveplot" p.X.Label.Text = "t" p.Y.Label.Text = "Ampl" pts := make(plotter.XYs, sampleCnt) // read samples and construct points for plot for i := range pts { n, err := wavReader.ReadSample() if err == io.EOF { break } checkErr(err) pts[i].X = float64(i) pts[i].Y = float64(n) } err = plotutil.AddLinePoints(p, "", pts) checkErr(err) // construct output filename inputFname := path.Base(os.Args[1]) plotFname := strings.Split(inputFname, ".")[0] + ".png" if err := p.Save(10, 4, plotFname); err != nil { panic(err) } }
func main() { fmt.Println("Running...") start := time.Now() count := 0 pt = make([]plotter.XYs, 0) for n := nMin; n <= nMax; n *= 2 { y1 = make([]float64, n) y2 = make([]float64, n) pt = append(pt, make(plotter.XYs, n)) y1[0] = 1.0 y2[0] = 3.0 h = (tMax - tMin) / float64(n-1) for i := 1; i < n; i++ { y1[i] = y1[i-1] + 2*y1[i-1]*(1-y2[i-1])*h y2[i] = y2[i-1] - y2[i-1]*(1-y1[i-1])*h } for i := 0; i < n; i++ { pt[count][i].X = y1[i] pt[count][i].Y = y2[i] } count++ } p, err := plot.New() if err != nil { panic(err) } p.Title.Text = fmt.Sprintf("Enright and Pryce #B1:Euler") p.Y.Label.Text = "y2(t)" p.X.Label.Text = "y1(t)" n := nMin for i := 0; i < count; i++ { l := plotter.NewLine(pt[i]) l.LineStyle.Width = vg.Points(1) l.LineStyle.Color = color.RGBA{R: 255 / uint8(i+1), G: 255 / uint8(i+1), B: 255 / uint8(i+1), A: 255} p.Add(l) n *= 2 } p.X.Min = 0 p.X.Max = 6.5 p.Y.Min = 0 p.Y.Max = 6.5 // Save the plot to a PNG file. if err := p.Save(6, 6, "euler_test.png"); err != nil { panic(err) } fmt.Println(time.Since(start)) fmt.Println("...program terminated successfully!") }
func DataTableToPng(b *bytes.Buffer, dt *db.DataTable, title string, width, height float64, xLabel string) error { p, err := plot.New() if err != nil { return err } p.Title.Text = title p.X.Label.Text = xLabel p.Y.Label.Text = "msec" // TODO: Fix this. // TODO: need new ticker function to handle equalX (while keeping xLabel as selected) if xLabel == common.TimeName { p.X.Tick.Marker = TimeTicks } p.Legend.Top = true numColumns := len(dt.ColumnNames) lines := make([]plotter.XYs, numColumns-1) // Skip X column. for _, dRow := range dt.Data { xp := (*dRow)[0] if xp != nil { for col := 1; col < numColumns; col++ { // Skip X column. yp := (*dRow)[col] if yp != nil { lines[col-1] = append(lines[col-1], struct{ X, Y float64 }{X: *xp, Y: *yp}) } } } } colorList := getColors(numColumns - 1) // Skip X column. for i, line := range lines { columnName := dt.ColumnNames[i+1] l, err := plotter.NewLine(line) if err != nil { return err } if strings.Index(columnName, common.RegressNamePrefix) == 0 { // If regression value. l.LineStyle.Color = color.RGBA{255, 0, 0, 255} l.LineStyle.Width = vg.Points(2.0) } else { l.LineStyle.Color = colorList[i] l.LineStyle.Width = vg.Points(1.5) } p.Add(l) p.Legend.Add(columnName, l) } tPng := time.Now() drawPng(b, p, width, height) glog.V(3).Infof("PERF: makePng time: %v", time.Now().Sub(tPng)) return nil }
func linesPlot() *plot.Plot { // Get some random points rand.Seed(int64(0)) n := 10 scatterData := randomPoints(n) lineData := randomPoints(n) linePointsData := randomPoints(n) // Create a new plot, set its title and // axis labels. p, err := plot.New() if err != nil { panic(err) } p.Title.Text = "Points Example" p.X.Label.Text = "X" p.Y.Label.Text = "Y" // Draw a grid behind the data p.Add(plotter.NewGrid()) // Make a scatter plotter and set its style. s, err := plotter.NewScatter(scatterData) if err != nil { panic(err) } s.GlyphStyle.Color = color.RGBA{R: 255, B: 128, A: 255} // Make a line plotter and set its style. l, err := plotter.NewLine(lineData) if err != nil { panic(err) } l.LineStyle.Width = vg.Points(1) l.LineStyle.Dashes = []vg.Length{vg.Points(5), vg.Points(5)} l.LineStyle.Color = color.RGBA{B: 255, A: 255} // Make a line plotter with points and set its style. lpLine, lpPoints, err := plotter.NewLinePoints(linePointsData) if err != nil { panic(err) } lpLine.Color = color.RGBA{G: 255, A: 255} lpPoints.Shape = plot.PyramidGlyph{} lpPoints.Color = color.RGBA{R: 255, A: 255} // Add the plotters to the plot, with a legend // entry for each p.Add(s, l, lpLine, lpPoints) p.Legend.Add("scatter", s) p.Legend.Add("line", l) p.Legend.Add("line points", lpLine, lpPoints) return p }
// Example_horizontalQuartPlots draws horizontal quartile plots // with some labels on their points. func Example_horizontalQuartPlots() *plot.Plot { rand.Seed(int64(0)) n := 100 uniform := make(valueLabels, n) normal := make(valueLabels, n) expon := make(valueLabels, n) for i := 0; i < n; i++ { uniform[i].Value = rand.Float64() uniform[i].Label = fmt.Sprintf("%4.4f", uniform[i].Value) normal[i].Value = rand.NormFloat64() normal[i].Label = fmt.Sprintf("%4.4f", normal[i].Value) expon[i].Value = rand.ExpFloat64() expon[i].Label = fmt.Sprintf("%4.4f", expon[i].Value) } p, err := plot.New() if err != nil { panic(err) } p.Title.Text = "Horizontal Quartile Plot" p.X.Label.Text = "plotter.Values" // Make boxes for our data and add them to the plot. uniBox := must(plotter.MakeHorizQuartPlot(0, uniform)).(plotter.HorizQuartPlot) uniLabels, err := uniBox.OutsideLabels(uniform) if err != nil { panic(err) } normBox := must(plotter.MakeHorizQuartPlot(1, normal)).(plotter.HorizQuartPlot) normLabels, err := normBox.OutsideLabels(normal) if err != nil { panic(err) } expBox := must(plotter.MakeHorizQuartPlot(2, expon)).(plotter.HorizQuartPlot) expLabels, err := expBox.OutsideLabels(expon) if err != nil { panic(err) } p.Add(uniBox, uniLabels, normBox, normLabels, expBox, expLabels) // Add a GlyphBox plotter for debugging. p.Add(plotter.NewGlyphBoxes()) // Set the Y axis of the plot to nominal with // the given names for y=0, y=1 and y=2. p.NominalY("Uniform\nDistribution", "Normal\nDistribution", "Exponential\nDistribution") return p }
func main() { tests := []*Test{} // if file, err := os.Open("results.txt"); err != nil { if file, err := os.Stdin, error(nil); err != nil { log.Fatal(err) } else { scanner := bufio.NewScanner(file) for scanner.Scan() { test, err := ParseLine(scanner.Text()) if err != nil { continue } test.Calculate() tests = append(tests, test) } } if len(tests) == 0 { log.Fatal("No tests found.") } if plt, err := plot.New(); err != nil { log.Fatal(err) } else { for i, test := range tests { xys := test.ToXY(100000.0) line, err := plotter.NewLine(xys) if err != nil { log.Fatal(err) } line.Color, line.Dashes = plotutil.Color(i), plotutil.Dashes(0) plt.Add(line) { name := fmt.Sprintf("%s (%d)", test.Name, int(test.Stats.Mean/100000)) plt.Legend.Add(name, line) } } // plt.Legend.Font.Size = vg.Inches(plt.Legend.Font.Size * 0.75) plt.Legend.Font.Size *= 0.65 plt.Legend.Top = true plt.Legend.Left = true // plt.Legend.YOffs = vg.Inches(-1.12) // plt.Legend.XOffs = vg.Inches(1) plt.HideX() // plt.X.Padding = 20 plt.Y.Min = 0 plt.Y.Max = 1600 plt.Title.Text = fmt.Sprintf("Speed Test (averaged over %d runs and %d tests)", 100000, 100) plt.Y.Label.Text = "Cycles" plt.Save(6, 4, "number-parse.svg") } }
func GenerateGraph(teamName string, pythagorean, reals []float64) { p, _ := plot.New() p.Title.Text = teamName p.X.Label.Text = "Day" p.Y.Label.Text = "Parcentage" p.X.Min = 0.0 p.X.Max = 38.0 p.Y.Min = 0.0 p.Y.Max = 100.0 plotutil.AddLinePoints(p, "", GeneratePlot(pythagorean), GeneratePlot(reals)) width := 4.0 height := 4.0 p.Save(width, height, fmt.Sprintf("%s.png", teamName)) }
func main() { fmt.Println("Running...") start := time.Now() ev = make([]float64, 0) for n := nmin; n <= nmax; n *= 2 { sum := 0.0 dx := (xmax - xmin) / float64(n) dy := (ymax - ymin) / float64(n) y = make([]float64, n) x = make([]float64, n) for k := 0; k < n; k++ { x[k] = float64(k)*dx + 0.5*dx + xmin y[k] = (float64(k)*dy + 0.5*dy + ymin) } for i := 0; i < n; i++ { for j := 0; j < n; j++ { sum += math.Exp(x[i]*y[j]) * dx * dy } } ev = append(ev, EXACT_VALUE-sum) } var pt plotter.XYs pt = make(plotter.XYs, len(ev)) for i := range pt { pt[i].X = math.Log10(float64(nmin) * math.Pow(2, float64(i))) pt[i].Y = math.Log10(math.Abs(ev[i])) } p, err := plot.New() if err != nil { panic(err) } p.Title.Text = fmt.Sprintf("Error of Midpoint Integral") p.X.Label.Text = "n" p.Y.Label.Text = "Log(|err|)" plotutil.AddLinePoints(p, pt) // Save the plot to a PNG file. if err := p.Save(6, 4, "error_hw12.png"); err != nil { panic(err) } fmt.Println(time.Since(start)) fmt.Println("...program terminated successfully!") }
// Example_verticalBoxPlots draws vertical boxplots // with some labels on their points. func Example_verticalBoxPlots() *plot.Plot { rand.Seed(int64(0)) n := 100 uniform := make(valueLabels, n) normal := make(valueLabels, n) expon := make(valueLabels, n) for i := 0; i < n; i++ { uniform[i].Value = rand.Float64() uniform[i].Label = fmt.Sprintf("%4.4f", uniform[i].Value) normal[i].Value = rand.NormFloat64() normal[i].Label = fmt.Sprintf("%4.4f", normal[i].Value) expon[i].Value = rand.ExpFloat64() expon[i].Label = fmt.Sprintf("%4.4f", expon[i].Value) } p, err := plot.New() if err != nil { panic(err) } p.Title.Text = "Box Plot" p.Y.Label.Text = "plotter.Values" // Make boxes for our data and add them to the plot. uniBox := must(plotter.NewBoxPlot(vg.Points(20), 0, uniform)).(*plotter.BoxPlot) uniLabels, err := uniBox.OutsideLabels(uniform) if err != nil { panic(err) } normBox := must(plotter.NewBoxPlot(vg.Points(20), 1, normal)).(*plotter.BoxPlot) normLabels, err := normBox.OutsideLabels(normal) if err != nil { panic(err) } expBox := must(plotter.NewBoxPlot(vg.Points(20), 2, expon)).(*plotter.BoxPlot) expLabels, err := expBox.OutsideLabels(expon) if err != nil { panic(err) } p.Add(uniBox, uniLabels, normBox, normLabels, expBox, expLabels) // Set the X axis of the plot to nominal with // the given names for x=0, x=1 and x=2. p.NominalX("Uniform\nDistribution", "Normal\nDistribution", "Exponential\nDistribution") return p }