fixed dependencies
This commit is contained in:
nuknal
381
vendor/gonum.org/v1/plot/plotutil/add.go
generated
vendored
Normal file
381
vendor/gonum.org/v1/plot/plotutil/add.go
generated
vendored
Normal file
@@ -0,0 +1,381 @@
|
||||
// Copyright ©2015 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package plotutil
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
|
||||
"gonum.org/v1/plot"
|
||||
"gonum.org/v1/plot/plotter"
|
||||
"gonum.org/v1/plot/vg"
|
||||
)
|
||||
|
||||
type combineXYs struct{ xs, ys plotter.Valuer }
|
||||
|
||||
func (c combineXYs) Len() int { return c.xs.Len() }
|
||||
func (c combineXYs) XY(i int) (float64, float64) { return c.xs.Value(i), c.ys.Value(i) }
|
||||
|
||||
type item struct {
|
||||
name string
|
||||
value plot.Thumbnailer
|
||||
}
|
||||
|
||||
// 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
|
||||
var names []item
|
||||
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.FillColor = color
|
||||
|
||||
ps = append(ps, l)
|
||||
|
||||
if name != "" {
|
||||
names = append(names, item{name: name, value: l})
|
||||
name = ""
|
||||
}
|
||||
|
||||
default:
|
||||
panic(fmt.Sprintf("plotutil: AddStackedAreaPlots handles strings and plotter.Valuers, got %T", t))
|
||||
}
|
||||
}
|
||||
|
||||
plt.Add(ps...)
|
||||
for _, v := range names {
|
||||
plt.Legend.Add(v.name, v.value)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// AddBoxPlots adds box plot plotters to a plot and
|
||||
// sets the X axis of the plot to be nominal.
|
||||
// The variadic arguments must be either strings
|
||||
// or plotter.Valuers. Each valuer adds a box plot
|
||||
// to the plot at the X location corresponding to
|
||||
// the number of box plots added before it. If a
|
||||
// plotter.Valuer is immediately preceeded by a
|
||||
// string then the string value is used to label the
|
||||
// tick mark for the box plot's X location.
|
||||
//
|
||||
// If an error occurs then none of the plotters are added
|
||||
// to the plot, and the error is returned.
|
||||
func AddBoxPlots(plt *plot.Plot, width vg.Length, vs ...interface{}) error {
|
||||
var ps []plot.Plotter
|
||||
var names []string
|
||||
name := ""
|
||||
for _, v := range vs {
|
||||
switch t := v.(type) {
|
||||
case string:
|
||||
name = t
|
||||
|
||||
case plotter.Valuer:
|
||||
b, err := plotter.NewBoxPlot(width, float64(len(names)), t)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
ps = append(ps, b)
|
||||
names = append(names, name)
|
||||
name = ""
|
||||
|
||||
default:
|
||||
panic(fmt.Sprintf("plotutil: AddBoxPlots handles strings and plotter.Valuers, got %T", t))
|
||||
}
|
||||
}
|
||||
plt.Add(ps...)
|
||||
plt.NominalX(names...)
|
||||
return nil
|
||||
}
|
||||
|
||||
// AddScatters adds Scatter 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 glyph shape
|
||||
// via the Color and Shape 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 AddScatters(plt *plot.Plot, vs ...interface{}) error {
|
||||
var ps []plot.Plotter
|
||||
var items []item
|
||||
name := ""
|
||||
var i int
|
||||
for _, v := range vs {
|
||||
switch t := v.(type) {
|
||||
case string:
|
||||
name = t
|
||||
|
||||
case plotter.XYer:
|
||||
s, err := plotter.NewScatter(t)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
s.Color = Color(i)
|
||||
s.Shape = Shape(i)
|
||||
i++
|
||||
ps = append(ps, s)
|
||||
if name != "" {
|
||||
items = append(items, item{name: name, value: s})
|
||||
name = ""
|
||||
}
|
||||
|
||||
default:
|
||||
panic(fmt.Sprintf("plotutil: AddScatters handles strings and plotter.XYers, got %T", t))
|
||||
}
|
||||
}
|
||||
plt.Add(ps...)
|
||||
for _, v := range items {
|
||||
plt.Legend.Add(v.name, v.value)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// AddLines adds Line plotters to a plot.
|
||||
// The variadic arguments must be a string
|
||||
// or one of a plotting type, plotter.XYers or *plotter.Function.
|
||||
// Each plotting type is added to
|
||||
// the plot using the next color and dashes
|
||||
// shape via the Color and Dashes functions.
|
||||
// If a plotting type 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
|
||||
var items []item
|
||||
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 != "" {
|
||||
items = append(items, item{name: name, value: l})
|
||||
name = ""
|
||||
}
|
||||
|
||||
case *plotter.Function:
|
||||
t.Color = Color(i)
|
||||
t.Dashes = Dashes(i)
|
||||
i++
|
||||
ps = append(ps, t)
|
||||
if name != "" {
|
||||
items = append(items, item{name: name, value: t})
|
||||
name = ""
|
||||
}
|
||||
|
||||
default:
|
||||
panic(fmt.Sprintf("plotutil: AddLines handles strings, plotter.XYers and *plotter.Function, got %T", t))
|
||||
}
|
||||
}
|
||||
plt.Add(ps...)
|
||||
for _, v := range items {
|
||||
plt.Legend.Add(v.name, v.value)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// AddLinePoints adds Line and Scatter 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, dashes, and glyph
|
||||
// shape via the Color, Dashes, and Shape 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 AddLinePoints(plt *plot.Plot, vs ...interface{}) error {
|
||||
var ps []plot.Plotter
|
||||
type item struct {
|
||||
name string
|
||||
value [2]plot.Thumbnailer
|
||||
}
|
||||
var items []item
|
||||
name := ""
|
||||
var i int
|
||||
for _, v := range vs {
|
||||
switch t := v.(type) {
|
||||
case string:
|
||||
name = t
|
||||
|
||||
case plotter.XYer:
|
||||
l, s, err := plotter.NewLinePoints(t)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
l.Color = Color(i)
|
||||
l.Dashes = Dashes(i)
|
||||
s.Color = Color(i)
|
||||
s.Shape = Shape(i)
|
||||
i++
|
||||
ps = append(ps, l, s)
|
||||
if name != "" {
|
||||
items = append(items, item{name: name, value: [2]plot.Thumbnailer{l, s}})
|
||||
name = ""
|
||||
}
|
||||
|
||||
default:
|
||||
panic(fmt.Sprintf("plotutil: AddLinePoints handles strings and plotter.XYers, got %T", t))
|
||||
}
|
||||
}
|
||||
plt.Add(ps...)
|
||||
for _, item := range items {
|
||||
v := item.value[:]
|
||||
plt.Legend.Add(item.name, v[0], v[1])
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// AddErrorBars adds XErrorBars and YErrorBars
|
||||
// to a plot. The variadic arguments must be
|
||||
// of type plotter.XYer, and must be either a
|
||||
// plotter.XErrorer, plotter.YErrorer, or both.
|
||||
// Each errorer is added to the plot the color from
|
||||
// the Colors function corresponding to its position
|
||||
// in the argument list.
|
||||
//
|
||||
// If an error occurs then none of the plotters are added
|
||||
// to the plot, and the error is returned.
|
||||
func AddErrorBars(plt *plot.Plot, vs ...interface{}) error {
|
||||
var ps []plot.Plotter
|
||||
for i, v := range vs {
|
||||
added := false
|
||||
|
||||
if xerr, ok := v.(interface {
|
||||
plotter.XYer
|
||||
plotter.XErrorer
|
||||
}); ok {
|
||||
e, err := plotter.NewXErrorBars(xerr)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
e.Color = Color(i)
|
||||
ps = append(ps, e)
|
||||
added = true
|
||||
}
|
||||
|
||||
if yerr, ok := v.(interface {
|
||||
plotter.XYer
|
||||
plotter.YErrorer
|
||||
}); ok {
|
||||
e, err := plotter.NewYErrorBars(yerr)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
e.Color = Color(i)
|
||||
ps = append(ps, e)
|
||||
added = true
|
||||
}
|
||||
|
||||
if added {
|
||||
continue
|
||||
}
|
||||
panic(fmt.Sprintf("plotutil: AddErrorBars expects plotter.XErrorer or plotter.YErrorer, got %T", v))
|
||||
}
|
||||
plt.Add(ps...)
|
||||
return nil
|
||||
}
|
||||
|
||||
// AddXErrorBars adds XErrorBars to a plot.
|
||||
// The variadic arguments must be
|
||||
// of type plotter.XYer, and plotter.XErrorer.
|
||||
// Each errorer is added to the plot the color from
|
||||
// the Colors function corresponding to its position
|
||||
// in the argument list.
|
||||
//
|
||||
// If an error occurs then none of the plotters are added
|
||||
// to the plot, and the error is returned.
|
||||
func AddXErrorBars(plt *plot.Plot, es ...interface {
|
||||
plotter.XYer
|
||||
plotter.XErrorer
|
||||
}) error {
|
||||
var ps []plot.Plotter
|
||||
for i, e := range es {
|
||||
bars, err := plotter.NewXErrorBars(e)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
bars.Color = Color(i)
|
||||
ps = append(ps, bars)
|
||||
}
|
||||
plt.Add(ps...)
|
||||
return nil
|
||||
}
|
||||
|
||||
// AddYErrorBars adds YErrorBars to a plot.
|
||||
// The variadic arguments must be
|
||||
// of type plotter.XYer, and plotter.YErrorer.
|
||||
// Each errorer is added to the plot the color from
|
||||
// the Colors function corresponding to its position
|
||||
// in the argument list.
|
||||
//
|
||||
// If an error occurs then none of the plotters are added
|
||||
// to the plot, and the error is returned.
|
||||
func AddYErrorBars(plt *plot.Plot, es ...interface {
|
||||
plotter.XYer
|
||||
plotter.YErrorer
|
||||
}) error {
|
||||
var ps []plot.Plotter
|
||||
for i, e := range es {
|
||||
bars, err := plotter.NewYErrorBars(e)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
bars.Color = Color(i)
|
||||
ps = append(ps, bars)
|
||||
}
|
||||
plt.Add(ps...)
|
||||
return nil
|
||||
}
|
||||
119
vendor/gonum.org/v1/plot/plotutil/errorpoints.go
generated
vendored
Normal file
119
vendor/gonum.org/v1/plot/plotutil/errorpoints.go
generated
vendored
Normal file
@@ -0,0 +1,119 @@
|
||||
// Copyright ©2015 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package plotutil
|
||||
|
||||
import (
|
||||
"math"
|
||||
"sort"
|
||||
|
||||
"gonum.org/v1/plot/plotter"
|
||||
)
|
||||
|
||||
// ErrorPoints holds a set of x, y pairs along
|
||||
// with their X and Y errors.
|
||||
type ErrorPoints struct {
|
||||
plotter.XYs
|
||||
plotter.XErrors
|
||||
plotter.YErrors
|
||||
}
|
||||
|
||||
// NewErrorPoints returns a new ErrorPoints where each
|
||||
// point in the ErrorPoints is given by evaluating the
|
||||
// center function on the Xs and Ys for the corresponding
|
||||
// set of XY values in the pts parameter. The XError
|
||||
// and YError are computed likewise, using the err
|
||||
// function.
|
||||
//
|
||||
// This function can be useful for summarizing sets of
|
||||
// scatter points using a single point and error bars for
|
||||
// each element of the scatter.
|
||||
func NewErrorPoints(f func([]float64) (c, l, h float64), pts ...plotter.XYer) (*ErrorPoints, error) {
|
||||
|
||||
c := &ErrorPoints{
|
||||
XYs: make(plotter.XYs, len(pts)),
|
||||
XErrors: make(plotter.XErrors, len(pts)),
|
||||
YErrors: make(plotter.YErrors, len(pts)),
|
||||
}
|
||||
|
||||
for i, xy := range pts {
|
||||
xs := make([]float64, xy.Len())
|
||||
ys := make([]float64, xy.Len())
|
||||
for j := 0; j < xy.Len(); j++ {
|
||||
xs[j], ys[j] = xy.XY(j)
|
||||
if err := plotter.CheckFloats(xs[j], ys[j]); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
c.XYs[i].X, c.XErrors[i].Low, c.XErrors[i].High = f(xs)
|
||||
if err := plotter.CheckFloats(c.XYs[i].X, c.XErrors[i].Low, c.XErrors[i].High); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
c.XYs[i].Y, c.YErrors[i].Low, c.YErrors[i].High = f(ys)
|
||||
if err := plotter.CheckFloats(c.XYs[i].Y, c.YErrors[i].Low, c.YErrors[i].High); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
return c, nil
|
||||
}
|
||||
|
||||
// MeanAndConf95 returns the mean
|
||||
// and the magnitude of the 95% confidence
|
||||
// interval on the mean as low and high
|
||||
// error values.
|
||||
//
|
||||
// MeanAndConf95 may be used as
|
||||
// the f argument to NewErrorPoints.
|
||||
func MeanAndConf95(vls []float64) (mean, lowerr, higherr float64) {
|
||||
n := float64(len(vls))
|
||||
|
||||
sum := 0.0
|
||||
for _, v := range vls {
|
||||
sum += v
|
||||
}
|
||||
mean = sum / n
|
||||
|
||||
sum = 0.0
|
||||
for _, v := range vls {
|
||||
diff := v - mean
|
||||
sum += diff * diff
|
||||
}
|
||||
stdev := math.Sqrt(sum / n)
|
||||
|
||||
conf := 1.96 * stdev / math.Sqrt(n)
|
||||
return mean, conf, conf
|
||||
}
|
||||
|
||||
// MedianAndMinMax returns the median
|
||||
// value and error on the median given
|
||||
// by the minimum and maximum data
|
||||
// values.
|
||||
//
|
||||
// MedianAndMinMax may be used as
|
||||
// the f argument to NewErrorPoints.
|
||||
func MedianAndMinMax(vls []float64) (med, lowerr, higherr float64) {
|
||||
n := len(vls)
|
||||
if n == 0 {
|
||||
panic("plotutil: MedianAndMinMax: No values")
|
||||
}
|
||||
if n == 1 {
|
||||
return vls[0], 0, 0
|
||||
}
|
||||
sort.Float64s(vls)
|
||||
if n%2 == 0 {
|
||||
med = (vls[n/2]-vls[n/2-1])/2 + vls[n/2-1]
|
||||
} else {
|
||||
med = vls[n/2]
|
||||
}
|
||||
|
||||
min := vls[0]
|
||||
max := vls[0]
|
||||
for _, v := range vls {
|
||||
min = math.Min(min, v)
|
||||
max = math.Max(max, v)
|
||||
}
|
||||
|
||||
return med, med - min, max - med
|
||||
}
|
||||
116
vendor/gonum.org/v1/plot/plotutil/plotutil.go
generated
vendored
Normal file
116
vendor/gonum.org/v1/plot/plotutil/plotutil.go
generated
vendored
Normal file
@@ -0,0 +1,116 @@
|
||||
// Copyright ©2015 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// Package plotutil contains a small number of utilites for creating plots.
|
||||
//
|
||||
// This package is under active development so portions of it may change.
|
||||
package plotutil // import "gonum.org/v1/plot/plotutil"
|
||||
|
||||
import (
|
||||
"image/color"
|
||||
|
||||
"gonum.org/v1/plot/vg"
|
||||
"gonum.org/v1/plot/vg/draw"
|
||||
)
|
||||
|
||||
// DefaultColors is a set of colors used by the Color function.
|
||||
var DefaultColors = SoftColors
|
||||
|
||||
var DarkColors = []color.Color{
|
||||
rgb(238, 46, 47),
|
||||
rgb(0, 140, 72),
|
||||
rgb(24, 90, 169),
|
||||
rgb(244, 125, 35),
|
||||
rgb(102, 44, 145),
|
||||
rgb(162, 29, 33),
|
||||
rgb(180, 56, 148),
|
||||
}
|
||||
|
||||
var SoftColors = []color.Color{
|
||||
rgb(241, 90, 96),
|
||||
rgb(122, 195, 106),
|
||||
rgb(90, 155, 212),
|
||||
rgb(250, 167, 91),
|
||||
rgb(158, 103, 171),
|
||||
rgb(206, 112, 88),
|
||||
rgb(215, 127, 180),
|
||||
}
|
||||
|
||||
func rgb(r, g, b uint8) color.RGBA {
|
||||
return color.RGBA{r, g, b, 255}
|
||||
}
|
||||
|
||||
// Color returns the ith default color, wrapping
|
||||
// if i is less than zero or greater than the max
|
||||
// number of colors in the DefaultColors slice.
|
||||
func Color(i int) color.Color {
|
||||
n := len(DefaultColors)
|
||||
if i < 0 {
|
||||
return DefaultColors[i%n+n]
|
||||
}
|
||||
return DefaultColors[i%n]
|
||||
}
|
||||
|
||||
// DefaultGlyphShapes is a set of GlyphDrawers used by
|
||||
// the Shape function.
|
||||
var DefaultGlyphShapes = []draw.GlyphDrawer{
|
||||
draw.RingGlyph{},
|
||||
draw.SquareGlyph{},
|
||||
draw.TriangleGlyph{},
|
||||
draw.CrossGlyph{},
|
||||
draw.PlusGlyph{},
|
||||
draw.CircleGlyph{},
|
||||
draw.BoxGlyph{},
|
||||
draw.PyramidGlyph{},
|
||||
}
|
||||
|
||||
// Shape returns the ith default glyph shape,
|
||||
// wrapping if i is less than zero or greater
|
||||
// than the max number of GlyphDrawers
|
||||
// in the DefaultGlyphShapes slice.
|
||||
func Shape(i int) draw.GlyphDrawer {
|
||||
n := len(DefaultGlyphShapes)
|
||||
if i < 0 {
|
||||
return DefaultGlyphShapes[i%n+n]
|
||||
}
|
||||
return DefaultGlyphShapes[i%n]
|
||||
}
|
||||
|
||||
// DefaultDashes is a set of dash patterns used by
|
||||
// the Dashes function.
|
||||
var DefaultDashes = [][]vg.Length{
|
||||
{},
|
||||
|
||||
{vg.Points(6), vg.Points(2)},
|
||||
|
||||
{vg.Points(2), vg.Points(2)},
|
||||
|
||||
{vg.Points(1), vg.Points(1)},
|
||||
|
||||
{vg.Points(5), vg.Points(2), vg.Points(1), vg.Points(2)},
|
||||
|
||||
{vg.Points(10), vg.Points(2), vg.Points(2), vg.Points(2),
|
||||
vg.Points(2), vg.Points(2), vg.Points(2), vg.Points(2)},
|
||||
|
||||
{vg.Points(10), vg.Points(2), vg.Points(2), vg.Points(2)},
|
||||
|
||||
{vg.Points(5), vg.Points(2), vg.Points(5), vg.Points(2),
|
||||
vg.Points(2), vg.Points(2), vg.Points(2), vg.Points(2)},
|
||||
|
||||
{vg.Points(4), vg.Points(2), vg.Points(4), vg.Points(1),
|
||||
vg.Points(1), vg.Points(1), vg.Points(1), vg.Points(1),
|
||||
vg.Points(1), vg.Points(1)},
|
||||
}
|
||||
|
||||
// Dashes returns the ith default dash pattern,
|
||||
// wrapping if i is less than zero or greater
|
||||
// than the max number of dash patters
|
||||
// in the DefaultDashes slice.
|
||||
func Dashes(i int) []vg.Length {
|
||||
n := len(DefaultDashes)
|
||||
if i < 0 {
|
||||
return DefaultDashes[i%n+n]
|
||||
}
|
||||
return DefaultDashes[i%n]
|
||||
}
|
||||
Reference in New Issue
Block a user