// 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
}
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
}
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)
}
}
// AddLines adds Line plotters to a plot.
// The variadic arguments must be either strings
// or plotter.XYers. Each plotter.XYer is added to
// the plot using the next color and dashes
// shape via the Color and Dashes functions.
// If a plotter.XYer is immediately preceeded by
// a string then a legend entry is added to the plot
// using the string as the name.
//
// If an error occurs then none of the plotters are added
// to the plot, and the error is returned.
func AddLines(plt *plot.Plot, vs ...interface{}) error {
var ps []plot.Plotter
names := make(map[*plotter.Line]string)
name := ""
var i int
for _, v := range vs {
switch t := v.(type) {
case string:
name = t
case plotter.XYer:
l, err := plotter.NewLine(t)
if err != nil {
return err
}
l.Color = Color(i)
l.Dashes = Dashes(i)
i++
ps = append(ps, l)
if name != "" {
names[l] = name
name = ""
}
default:
panic(fmt.Sprintf("AddLines handles strings and plotter.XYers, got %T", t))
}
}
plt.Add(ps...)
for p, n := range names {
plt.Legend.Add(n, p)
}
return nil
}
// 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
}
// 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 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)
}
}
func PlotBands(symbol string, all []bands.Band) {
dclose := make(plotter.XYs, len(all))
dsma := make(plotter.XYs, len(all))
dup := make(plotter.XYs, len(all))
ddown := make(plotter.XYs, len(all))
for i, b := range all {
dclose[i].X = float64(-1 * i)
dclose[i].Y = b.Close
dsma[i].X = float64(-1 * i)
dsma[i].Y = b.SMA
dup[i].X = float64(-1 * i)
dup[i].Y = b.Up
ddown[i].X = float64(-1 * i)
ddown[i].Y = b.Down
}
p, _ := plot.New()
p.Title.Text = fmt.Sprintf("Bollinger Bands: %s", symbol)
p.X.Label.Text = "Time (Days)"
p.Y.Label.Text = "Value"
p.Add(plotter.NewGrid())
lclose, _ := plotter.NewLine(dclose)
lsma, _ := plotter.NewLine(dsma)
lsma.LineStyle.Color = color.RGBA{B: 255, A: 255}
lup, _ := plotter.NewLine(dup)
lup.LineStyle.Color = color.RGBA{R: 255, A: 255}
ldown, _ := plotter.NewLine(ddown)
ldown.LineStyle.Color = color.RGBA{G: 255, A: 255}
p.Add(lclose, lsma, lup, ldown)
p.Legend.Add("Closing", lclose)
p.Legend.Add("SMA", lsma)
p.Legend.Add("Up", lup)
p.Legend.Add("Down", ldown)
p.Save(16, 9, fmt.Sprintf("%s.png", symbol))
}
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
}
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")
}
}
// AddStackedAreaPlots adds stacked area plot plotters to a plot.
// The variadic arguments must be either strings
// or plotter.Valuers. Each valuer adds a stacked area
// plot to the plot below the stacked area plots added
// before it. If a plotter.Valuer is immediately
// preceeded by a string then the string value is used to
// label the legend.
// Plots should be added in order of tallest to shortest,
// because they will be drawn in the order they are added
// (i.e. later plots will be painted over earlier plots).
//
// If an error occurs then none of the plotters are added
// to the plot, and the error is returned.
func AddStackedAreaPlots(plt *plot.Plot, xs plotter.Valuer, vs ...interface{}) error {
var ps []plot.Plotter
names := make(map[*plotter.Line]string)
name := ""
var i int
for _, v := range vs {
switch t := v.(type) {
case string:
name = t
case plotter.Valuer:
if xs.Len() != t.Len() {
return errors.New("X/Y length mismatch")
}
// Make a line plotter and set its style.
l, err := plotter.NewLine(combineXYs{xs: xs, ys: t})
if err != nil {
return err
}
l.LineStyle.Width = vg.Points(0)
color := Color(i)
i++
l.ShadeColor = &color
ps = append(ps, l)
if name != "" {
names[l] = name
name = ""
}
default:
panic(fmt.Sprintf("AddStackedAreaPlots handles strings and plotter.Valuers, got %T", t))
}
}
plt.Add(ps...)
for p, n := range names {
plt.Legend.Add(n, p)
}
return nil
}
func plotBehind(sp *raw.SpicePlot, scale_vector *raw.SpiceVector, typemap map[string][]*raw.SpiceVector) PlotMap {
m := findMultiplicity(scale_vector.Data)
c := int(sp.NPoints) / m
plots := PlotMap{}
for vector_type, vectors := range typemap {
plot, err := plot.New()
if err != nil {
log.Fatal(err)
}
for i, vector := range vectors {
xys := SpiceToXY(scale_vector, vector)
for j := 0; j < m; j++ {
line, err := plotter.NewLine(xys[j*c : (j+1)*c])
if err != nil {
log.Fatal(err)
}
line.Color = plotutil.Color(i)
line.Dashes = plotutil.Dashes(0)
plot.Add(line)
// plot.Legend.Add(vector.Name, line)
// plot.Legend.Add(fmt.Sprintf("%s-%d", vector.Name, j), line)
if j == 0 {
plot.Legend.Add(vector.Name, line)
}
}
// xys := SpiceToXY(scale_vector, vector)
// line, err := plotter.NewLine(xys)
// if err != nil {
// log.Fatal(err)
// }
// line.Color = plotutil.Color(i + 1)
// line.Dashes = plotutil.Dashes(0)
// plot.Add(line)
// plot.Legend.Add(vector.Name, line)
}
plot.Title.Text = sp.Title + ": " + sp.Name
plot.X.Label.Text = scale_vector.Name
plot.Y.Label.Text = vector_type
// plots = append(plots, plot)
plots[vector_type] = plot
}
return plots
}
// Example_points draws some scatter points, a line,
// and a line with points.
func Example_points() *plot.Plot {
rand.Seed(int64(0))
n := 15
scatterData := randomPoints(n)
lineData := randomPoints(n)
linePointsData := randomPoints(n)
p, err := plot.New()
if err != nil {
panic(err)
}
p.Title.Text = "Points Example"
p.X.Label.Text = "X"
p.Y.Label.Text = "Y"
p.Add(plotter.NewGrid())
s := must(plotter.NewScatter(scatterData)).(*plotter.Scatter)
s.GlyphStyle.Color = color.RGBA{R: 255, B: 128, A: 255}
s.GlyphStyle.Radius = vg.Points(3)
l := must(plotter.NewLine(lineData)).(*plotter.Line)
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}
lpLine, lpPoints, err := plotter.NewLinePoints(linePointsData)
if err != nil {
panic(err)
}
lpLine.Color = color.RGBA{G: 255, A: 255}
lpPoints.Shape = plot.CircleGlyph{}
lpPoints.Color = color.RGBA{R: 255, A: 255}
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
}
// Report builds up a plot of the response times of the requests
// in SVG format and writes it to out
func (r *TimingsPlotReporter) Report(out io.Writer) error {
timestamps := make([]time.Time, 0)
timings := make([]time.Duration, 0)
for e := r.responses.Front(); e != nil; e = e.Next() {
r := e.Value.(*result)
timestamps = append(timestamps, r.timestamp)
timings = append(timings, r.timing)
}
p, err := plot.New()
if err != nil {
return err
}
pts := make(plotter.XYs, len(timestamps))
for i := 0; i < len(pts); i++ {
pts[i].X = timestamps[i].Sub(timestamps[0]).Seconds()
pts[i].Y = timings[i].Seconds() * 1000
}
line, err := plotter.NewLine(pts)
if err != nil {
return err
}
line.Color = plotutil.Color(1)
p.Add(line)
p.X.Padding = vg.Length(3.0)
p.X.Label.Text = "Time elapsed"
p.Y.Padding = vg.Length(3.0)
p.Y.Label.Text = "Latency (ms)"
w, h := vg.Millimeters(float64(len(timestamps))), vg.Centimeters(12.0)
canvas := vgsvg.New(w, h)
p.Draw(plot.MakeDrawArea(canvas))
_, err = canvas.WriteTo(out)
return err
}
// AddLines adds Line plotters to a plot.
// The variadic arguments must be either strings
// or plotter.XYers. Each plotter.XYer is added to
// the plot using the next color and dashes
// shape via the Color and Dashes functions.
// If a plotter.XYer is immediately preceeded by
// a string then a legend entry is added to the plot
// using the string as the name.
func AddLines(plt *plot.Plot, vs ...interface{}) {
name := ""
var i int
for _, v := range vs {
switch t := v.(type) {
case string:
name = t
case plotter.XYer:
l := plotter.NewLine(t)
l.Color = Color(i)
l.Dashes = Dashes(i)
i++
plt.Add(l)
if name != "" {
plt.Legend.Add(name, l)
name = ""
}
default:
panic(fmt.Sprintf("AddLines handles strings and plotter.XYers, got %T", t))
}
}
}
// Writes step data and position to a graph
func WriteStepsToChart(stepData <-chan int8) {
maxNumberSteps := 1500
leftVel := make(chartplotter.XYs, maxNumberSteps)
rightVel := make(chartplotter.XYs, maxNumberSteps)
leftPos := make(chartplotter.XYs, maxNumberSteps)
rightPos := make(chartplotter.XYs, maxNumberSteps)
var byteDataL, byteDataR int8
stepIndex := 0
for stepDataOpen := true; stepDataOpen; {
byteDataL, stepDataOpen = <-stepData
byteDataR, stepDataOpen = <-stepData
leftVel[stepIndex].X = float64(stepIndex)
leftVel[stepIndex].Y = float64(byteDataL) * Settings.StepSize_MM / (32.0 * 0.002)
rightVel[stepIndex].X = float64(stepIndex)
rightVel[stepIndex].Y = float64(byteDataR) * Settings.StepSize_MM / (32.0 * 0.002)
leftPos[stepIndex].X = float64(stepIndex)
if stepIndex > 0 {
leftPos[stepIndex].Y = leftPos[stepIndex-1].Y + (leftVel[stepIndex].Y * .002)
} else {
leftPos[stepIndex].Y = 0
}
rightPos[stepIndex].X = float64(stepIndex)
if stepIndex > 0 {
rightPos[stepIndex].Y = rightPos[stepIndex-1].Y + (rightVel[stepIndex].Y * .002)
} else {
rightPos[stepIndex].Y = 0
}
stepIndex++
if stepIndex >= maxNumberSteps {
break
}
}
// chop down slices if maxNumberSteps wasn't needed
if stepIndex < maxNumberSteps {
leftVel = leftVel[:stepIndex]
rightVel = rightVel[:stepIndex]
leftPos = leftPos[:stepIndex]
rightPos = rightPos[:stepIndex]
}
// Create a new plot, set its title and
// axis labels.
p, err := chart.New()
if err != nil {
panic(err)
}
p.Title.Text = "Polargraph Position & Velocity"
p.X.Label.Text = "2ms Slice"
p.Y.Label.Text = "Position(mm) / Velocity (mm/s)"
// Draw a grid behind the data
p.Add(chartplotter.NewGrid())
leftPosLine, _ := chartplotter.NewLine(leftPos)
leftPosLine.LineStyle.Width = vg.Points(1)
leftPosLine.LineStyle.Color = color.RGBA{B: 255, A: 255}
rightPosLine, _ := chartplotter.NewLine(rightPos)
rightPosLine.LineStyle.Width = vg.Points(1)
rightPosLine.LineStyle.Color = color.RGBA{R: 255, A: 255}
leftVelLine, _ := chartplotter.NewLine(leftVel)
leftVelLine.LineStyle.Width = vg.Points(1)
leftVelLine.LineStyle.Color = color.RGBA{B: 150, G: 150, A: 255}
rightVelLine, _ := chartplotter.NewLine(rightVel)
rightVelLine.LineStyle.Width = vg.Points(1)
rightVelLine.LineStyle.Color = color.RGBA{R: 150, G: 150, A: 255}
p.Add(leftPosLine, rightPosLine)
p.Legend.Add("Left Pos", leftPosLine)
p.Legend.Add("Right Pos", rightPosLine)
p.Add(leftVelLine, rightVelLine)
p.Legend.Add("Left Vel", leftVelLine)
p.Legend.Add("Right Vel", rightVelLine)
// Save the plot to a PNG file.
if err := p.Save(14, 8.5, "chart.png"); err != nil {
panic(err)
}
}
func RunServer(config *Config) {
// manually load fonts from resource
for _, fontasset := range AssetNames() {
if strings.HasPrefix(fontasset, "res/fonts/") {
fontname := strings.TrimSuffix(path.Base(fontasset), path.Ext(fontasset))
fontbytes, err := Asset(fontasset)
if err != nil {
panic(err)
}
fontreader := bytes.NewReader(fontbytes)
vg.LoadFont(fontname, fontreader)
}
}
// create memory caches
homeCache := cache.New(10*time.Minute, 5*time.Minute)
categoryCache := cache.New(30*time.Minute, 30*time.Minute)
detailCache := cache.New(15*time.Minute, 10*time.Minute)
initialCheck := func(w http.ResponseWriter, r *http.Request) bool {
// clear cache if requested
nocache := r.Form.Get("nocache")
if nocache == "1" {
homeCache.Flush()
categoryCache.Flush()
detailCache.Flush()
}
return true
}
http.HandleFunc("/favicon.ico", func(w http.ResponseWriter, r *http.Request) {
http.Error(w, "Not found", 404)
})
http.HandleFunc("/favicon.png", func(w http.ResponseWriter, r *http.Request) {
http.Error(w, "Not found", 404)
})
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
//config.Logger.Printf("Connection: %s\n", r.URL.String())
var err error
r.ParseForm()
if !initialCheck(w, r) {
return
}
csession := config.Session.Clone()
defer csession.Close()
cat := r.Form.Get("category")
chart := r.Form.Get("chart")
p_page := r.Form.Get("pg")
page := 1
if p_page != "" {
t_page, err := strconv.ParseInt(p_page, 10, 32)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
page = int(t_page)
}
if page < 1 {
page = 1
}
i := fstopinfo.NewInfo(config.Logger, csession)
i.Database = config.Database
// load categories
var c fstopinfo.FSCategoryList
catcache, catfound := categoryCache.Get("category")
if catfound {
c = catcache.(fstopinfo.FSCategoryList)
}
if c == nil {
c, err = i.Categories()
if err != nil {
http.Error(w, err.Error(), 500)
return
}
if c != nil {
categoryCache.Set("category", c, 0)
}
}
if c == nil {
http.Error(w, "Could not load categories", 500)
return
}
// load home
var d fstopimp.FSTopStatsList
var dcache interface{}
var dfound bool
var dname string
if cat == "" {
dname = "index"
} else {
// check if category exists
if !c.Exists(cat) {
http.Error(w, "Category not found", 404)
return
}
dname = cat
}
dcache, dfound = homeCache.Get(dname)
if dfound {
d = dcache.(fstopimp.FSTopStatsList)
}
// data not on cache, load
if d == nil {
if cat == "" {
d, err = i.Top(config.TopId)
} else {
d, err = i.TopCategory(config.TopId, cat)
}
if err != nil {
http.Error(w, err.Error(), 500)
return
}
if len(d) > 0 {
homeCache.Set(dname, d, 0)
}
}
pagecount := d.PageCount(config.PageSize)
d = d.Paged(page, config.PageSize)
w.Header().Add("Content-Type", "text/html; charset=utf-8")
var body *bytes.Buffer = new(bytes.Buffer)
tmpldata := map[string]interface{}{
"Title": config.Title,
"page": page,
"categories": c,
}
fmt.Fprintln(body, "<table class=\"main\">")
fmt.Fprintln(body, "<tr><th>Chart</th><th>Title</th><th width=\"8%\">Added</th><th width=\"5%\">Score</th><th width=\"5%\">Count</th><th width=\"5%\">Comm.</th></tr>")
for _, ii := range d {
fmt.Fprintf(body, "<tr>\n")
if chart == "" {
fmt.Fprintf(body, "<td><img style=\"height: 107px;\" src=\"/chart?id=%s&size=short\"></td>",
ii.Id)
}
fmt.Fprintf(body, "<td><a href=\"%s\">%s</a> <a href=\"/view?id=%s\">[data]</a> <a href=\"/chart?id=%s\">[chart]</a></td>"+
"<td align=\"center\" style=\"%s\">%s</td>"+
"<td align=\"right\">%d</td><td align=\"center\">%d</td><td align=\"center\">%d</td>\n",
ii.Link, ii.Title, ii.Id, ii.Id,
StyleAddDate(ii.Last.AddDate), FormatAddDate(ii.Last.AddDate), ii.Score, ii.Count, ii.Last.Comments)
fmt.Fprintf(body, "</tr>\n")
if chart == "1" {
fmt.Fprintf(body, "<tr><td colspan=\"5\" align=\"center\"><img src=\"/chart?id=%s&size=small\"/></td></tr>\n", ii.Id)
}
}
fmt.Fprintln(body, "</table>")
pageparams := url.Values{}
if cat != "" {
pageparams.Add("category", cat)
}
if page > 1 {
pageparams.Set("pg", "1")
tmpldata["page_first"] = fmt.Sprintf("/?%s", pageparams.Encode())
}
if page > 1 {
pageparams.Set("pg", strconv.Itoa(page-1))
tmpldata["page_prev"] = fmt.Sprintf("/?%s", pageparams.Encode())
}
if len(d) > 0 && page < pagecount {
pageparams.Set("pg", strconv.Itoa(page+1))
tmpldata["page_next"] = fmt.Sprintf("/?%s", pageparams.Encode())
}
if page != pagecount {
pageparams.Set("pg", strconv.Itoa(pagecount))
tmpldata["page_last"] = fmt.Sprintf("/?%s", pageparams.Encode())
}
tmpl := LoadTemplates("index")
tmpldata["Body"] = template.HTML(body.String())
err = tmpl.ExecuteTemplate(w, "index", tmpldata)
if err != nil {
http.Error(w, "Error processing template", 500)
return
}
})
http.HandleFunc("/view", func(w http.ResponseWriter, r *http.Request) {
r.ParseForm()
if !initialCheck(w, r) {
return
}
csession := config.Session.Clone()
defer csession.Close()
w.Header().Add("Content-Type", "text/html; charset=utf-8")
id := r.Form.Get("id")
if id == "" {
http.Error(w, "ID not sent", 500)
return
}
i := fstopinfo.NewInfo(config.Logger, csession)
i.Database = config.Database
var d []*fstopinfo.FSInfoHistory
var err error
dcache, found := detailCache.Get(id)
if found {
d = dcache.([]*fstopinfo.FSInfoHistory)
}
if d == nil {
d, err = i.History(id, config.HistoryDays)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
if d != nil {
detailCache.Set(id, d, 0)
}
}
if d == nil {
http.Error(w, "Not found", 500)
return
}
var body *bytes.Buffer = new(bytes.Buffer)
fmt.Fprintln(body, "<table class=\"main\" border=\"1\">")
fmt.Fprintln(body, "<tr><th>Date</th><th>Hour</th><th>Seeders</th><th>Leechers</th><th>Complete</th><th>Comments</th></tr>")
var last *fstopinfo.FSInfoHistory
first := true
for _, ii := range d {
//if ii.Item != nil {
if ii.Item != nil && first {
fmt.Fprintf(body, "<tr><td colspan=\"7\">%s <a href=\"%s\">[goto]</a></td></tr>", strings.TrimSpace(ii.Item.Title), ii.Item.Link)
first = false
}
if last != nil {
if ii.Item != nil && last.Item != nil {
//fmt.Printf("%s - [%d] [%d] [%d]\n", item.Title, pi.Seeders-item.Last.Seeders,
//pi.Leechers-item.Last.Leechers, pi.Complete-item.Last.Complete)
seeders := int64(ii.Item.Seeders - last.Item.Seeders)
leechers := int64(ii.Item.Leechers - last.Item.Leechers)
complete := int64(ii.Item.Complete - last.Item.Complete)
comments := int64(ii.Item.Comments - last.Item.Comments)
fmt.Fprintf(body, "<tr><td>%s</td><td>%d</td><td>%d (%d)</td><td>%d (%d)</td><td>%d (%d)</td><td>%d (%d)</td></tr>",
ii.Date, ii.Hour,
ii.Item.Seeders, seeders,
ii.Item.Leechers, leechers,
ii.Item.Complete, complete,
ii.Item.Comments, comments)
} else if ii.Item != nil && last.Item == nil {
fmt.Fprintf(body, "<tr><td>%s</td><td>%d</td><td>%d (-)</td><td>%d (-)</td><td>%d (-)</td><td>%d (-)</td></tr>",
ii.Date, ii.Hour,
ii.Item.Seeders,
ii.Item.Leechers,
ii.Item.Complete,
ii.Item.Comments)
} else {
fmt.Fprintf(body, "<tr><td>%s</td><td>%d</td></tr>",
ii.Date, ii.Hour)
}
}
last = ii
//}
}
fmt.Fprintln(body, "</table>")
tmpl := LoadTemplates("base")
tmpldata := map[string]interface{}{
"Title": config.Title,
"Body": template.HTML(body.String()),
}
err = tmpl.ExecuteTemplate(w, "base", tmpldata)
if err != nil {
http.Error(w, "Error processing template", 500)
return
}
})
http.HandleFunc("/chart", func(w http.ResponseWriter, r *http.Request) {
r.ParseForm()
if !initialCheck(w, r) {
return
}
csession := config.Session.Clone()
defer csession.Close()
id := r.Form.Get("id")
if id == "" {
w.Header().Add("Content-Type", "text/html; charset=utf-8")
http.Error(w, "ID not sent", 500)
return
}
size := r.Form.Get("size")
i := fstopinfo.NewInfo(config.Logger, csession)
i.Database = config.Database
var d []*fstopinfo.FSInfoHistory
var err error
dcache, found := detailCache.Get(id)
if found {
d = dcache.([]*fstopinfo.FSInfoHistory)
}
if d == nil {
d, err = i.History(id, config.HistoryDays)
if err != nil {
w.Header().Add("Content-Type", "text/html; charset=utf-8")
http.Error(w, err.Error(), 500)
return
}
if d != nil {
detailCache.Set(id, d, 0)
}
}
if d == nil {
w.Header().Add("Content-Type", "text/html; charset=utf-8")
http.Error(w, "Not found", 500)
return
}
p, err := plot.New()
if err != nil {
panic(err)
}
p.Title.Text = "Chart"
p.X.Label.Text = "Time"
p.Y.Label.Text = "Amount"
c_seeders := make(plotter.XYs, 0)
c_leechers := make(plotter.XYs, 0)
c_complete := make(plotter.XYs, 0)
c_comments := make(plotter.XYs, 0)
var last *fstopinfo.FSInfoHistory
first := true
cttotal := int32(0)
for _, ii := range d {
if ii.Item != nil {
cttotal++
if first {
p.Title.Text = strings.TrimSpace(ii.Item.Title)
first = false
}
if last != nil && last.Item != nil {
c_seeders = append(c_seeders, struct{ X, Y float64 }{float64(cttotal), float64(ii.Item.Seeders)})
c_leechers = append(c_leechers, struct{ X, Y float64 }{float64(cttotal), float64(ii.Item.Leechers)})
c_complete = append(c_complete, struct{ X, Y float64 }{float64(cttotal), float64(ii.Item.Complete - last.Item.Complete)})
c_comments = append(c_comments, struct{ X, Y float64 }{float64(cttotal), float64(ii.Item.Comments)})
}
last = ii
}
}
w.Header().Add("Content-Type", "image/png")
pl_seeders, err := plotter.NewLine(c_seeders)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
pl_seeders.LineStyle.Width = vg.Length(1)
pl_seeders.LineStyle.Color = color.RGBA{R: 255, A: 255}
p.Add(pl_seeders)
p.Legend.Add("Seeders", pl_seeders)
pl_leechers, err := plotter.NewLine(c_leechers)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
pl_leechers.LineStyle.Width = vg.Length(1)
pl_leechers.LineStyle.Color = color.RGBA{G: 255, A: 255}
p.Add(pl_leechers)
p.Legend.Add("Leechers", pl_leechers)
pl_complete, err := plotter.NewLine(c_complete)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
pl_complete.LineStyle.Width = vg.Length(1)
pl_complete.LineStyle.Color = color.RGBA{B: 255, A: 255}
p.Add(pl_complete)
p.Legend.Add("@Complete", pl_complete)
pl_comments, err := plotter.NewLine(c_comments)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
pl_comments.LineStyle.Width = vg.Length(1)
pl_comments.LineStyle.Color = color.RGBA{R: 255, B: 255, A: 255}
p.Add(pl_comments)
p.Legend.Add("Comments", pl_comments)
width := vg.Length(640)
height := vg.Length(480)
if size == "small" {
width = vg.Length(640)
height = vg.Length(160)
} else if size == "short" {
width = vg.Length(200)
height = vg.Length(80)
p.Title.Text = ""
p.X.Label.Text = ""
p.Y.Label.Text = ""
}
c := vgimg.PngCanvas{vgimg.New(width, height)}
p.Draw(plot.MakeDrawArea(c))
c.WriteTo(w)
})
http.HandleFunc("/res/", func(w http.ResponseWriter, r *http.Request) {
p := strings.Replace(path.Clean(r.URL.Path), "/res/", "res/files/", 1)
d, err := Asset(p)
if err != nil {
http.Error(w, "Error loading resource", 500)
return
}
w.Header().Add("Content-Type", mime.TypeByExtension(path.Ext(p)))
w.Write(d)
//fmt.Fprintf(w, "RES %s\n", p)
})
http.ListenAndServe(fmt.Sprintf("localhost:%d", config.Port), nil)
}
func main() {
fmt.Println("Running...")
start := time.Now()
var a float64 = -1.0 //lower limit of range
var b float64 = 1.0 //upper limit of range
var err plotter.XYs
err = make(plotter.XYs, nstop-nstart)
var maxerr float64
var interp [4]plotter.XYs
for i := range interp {
interp[i] = make(plotter.XYs, np+1)
}
var k int = 0
for n := nstart; n < nstop; n++ {
maxerr = 0
err[n-nstart].X = float64(n)
var x []float64 = make([]float64, n+1)
var dx float64 = (b - a) / float64(n)
for i := range x {
x[i] = a + dx*float64(i)
}
dx = (b - a) / float64(np-1)
var j int = 1
for i := 0; i < np+1; i++ {
tx := a + dx*float64(i)
if tx > x[j] && j < n {
j++
}
z := (tx - x[j-1]) / (x[j] - x[j-1])
ty := F(x[j-1])*(1-z)*(1-2*z) + 4*F((x[j-1]+x[j])/2.0)*z*(1-z) + F(x[j])*z*(2*z-1)
maxerr = math.Max(maxerr, math.Abs(ty-F(tx)))
if k < 4 {
if n == plotValues[k] {
interp[k][i].X = tx
interp[k][i].Y = ty
}
}
}
if k < 4 {
if n == plotValues[k] {
k++
}
}
err[n-nstart].Y = math.Log(maxerr)
}
//Plotting
pi, e0 := plot.New()
if e0 != nil {
panic(e0)
}
pi.Title.Text = "Maximum Error of Spline Interpolation of Runge's Function"
pi.X.Label.Text = "N"
pi.Y.Label.Text = "Log(Error)"
// Make a line plotter and set its style.
l := plotter.NewLine(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}
pi.Add(l)
// Save the plot to a PNG file.
if err := pi.Save(6, 4, "runge_error.png"); err != nil {
panic(err)
}
pi, e0 = plot.New()
if e0 != nil {
panic(e0)
}
pi.Title.Text = "Spline Interpolation of Runge's Function"
pi.X.Label.Text = "N"
pi.Y.Label.Text = "Log(Error)"
plotutil.AddLinePoints(pi, interp[2], interp[1], interp[0])
//Set plot bounds
pi.X.Min = 0
pi.X.Max = 0.5
// Save the plot to a PNG file.
if err := pi.Save(6, 4, "runge_interp.png"); err != nil {
panic(err)
}
fmt.Println(time.Since(start))
fmt.Println("...program terminated successfully!")
}
func TestServiceEpsilonGreedy(t *testing.T) {
var (
horizon = 250
epsilons = []float32{0.1, 0.5, 0.9}
hosts = map[string]bernouilliExperiment{
echo1: 0.1,
echo2: 0.1,
echo3: 0.9,
}
)
e1 := newEchoServer(t, echo1)
defer e1.close()
e2 := newEchoServer(t, echo2)
defer e2.close()
e3 := newEchoServer(t, echo3)
defer e3.close()
p, err := plot.New()
if err != nil {
t.Fatal(err)
}
p.Add(plotter.NewGrid())
p.X.Label.Text = "trials"
p.Y.Label.Text = "average score"
p.X.Max = float64(horizon)
p.Y.Min = 0
p.Y.Max = 1
for _, e := range epsilons {
means := make(plotter.XYs, horizon)
s := NewService("echo", &ServiceConfig{
BanditStrategy: NewEpsilonGreedy(e),
MemoizeScoreDuration: 1 * time.Millisecond,
})
s.Add(echo1)
s.Add(echo2)
s.Add(echo3)
time.Sleep(1 * time.Millisecond) // wait for propagation
for i := 0; i < horizon; i++ {
c, err := s.GetConn()
if err != nil {
t.Error(err)
continue
}
if i == 0 {
means[i].X = 0
means[i].Y = c.host.Score()
} else {
n := means[i-1].X + 1
m := means[i-1].Y
means[i].X = float64(i)
means[i].Y = m + (c.host.Score()-m)/(n+1)
}
a := c.Address()
if err := c.Release(nil, hosts[a].trial()); err != nil {
t.Error(err)
continue
}
time.Sleep(1 * time.Millisecond) // wait for memoization
}
s.Close()
l, err := plotter.NewLine(means)
if err != nil {
t.Fatal(err)
}
l.LineStyle.Color = color.RGBA{B: uint8(255 * e), A: 255}
p.Legend.Add("epsilon "+strconv.FormatFloat(float64(e), 'f', 1, 32), l)
p.Add(l)
}
if err := p.Save(7, 7, "egreedy_test.svg"); err != nil {
t.Fatal(err)
}
}