| [0, 1, 2, 3, 4, 5, 6], | |
| ] | |
| @classmethod | |
| def Colors(cls): | |
| """Returns the list of colors. | |
| """ | |
| return cls.colors | |
| @classmethod | |
| def ColorGenerator(cls, n): | |
| """Returns an iterator of color strings. | |
| n: how many colors will be used | |
| """ | |
| for i in cls.which_colors[n]: | |
| yield cls.colors[i] | |
| raise StopIteration('Ran out of colors in _Brewer.ColorGenerator') | |
| @classmethod | |
| def InitializeIter(cls, num): | |
| """Initializes the color iterator with the given number of colors.""" | |
| cls.color_iter = cls.ColorGenerator(num) | |
| @classmethod | |
| def ClearIter(cls): | |
| """Sets the color iterator to None.""" | |
| cls.color_iter = None | |
| @classmethod | |
| def GetIter(cls): | |
| """Gets the color iterator.""" | |
| if cls.color_iter is None: | |
| cls.InitializeIter(7) | |
| return cls.color_iter | |
| def PrePlot(num=None, rows=None, cols=None): | |
| """Takes hints about what's coming. | |
| num: number of lines that will be plotted | |
| rows: number of rows of subplots | |
| cols: number of columns of subplots | |
| """ | |
| if num: | |
| _Brewer.InitializeIter(num) | |
| if rows is None and cols is None: | |
| return | |
| if rows is not None and cols is None: | |
| cols = 1 | |
| if cols is not None and rows is None: | |
| rows = 1 | |
| # resize the image, depending on the number of rows and cols | |
| size_map = {(1, 1): (8, 6), | |
| (1, 2): (14, 6), | |
| (1, 3): (14, 6), | |
| (2, 2): (10, 10), | |
| (2, 3): (16, 10), | |
| (3, 1): (8, 10), | |
| } | |
| if (rows, cols) in size_map: | |
| fig = pyplot.gcf() | |
| fig.set_size_inches(*size_map[rows, cols]) | |
| # create the first subplot | |
| if rows > 1 or cols > 1: | |
| pyplot.subplot(rows, cols, 1) | |
| global SUBPLOT_ROWS, SUBPLOT_COLS | |
| SUBPLOT_ROWS = rows | |
| SUBPLOT_COLS = cols | |
| def SubPlot(plot_number, rows=None, cols=None): | |
| """Configures the number of subplots and changes the current plot. | |
| rows: int | |
| cols: int | |
| plot_number: int | |
| """ | |
| rows = rows or SUBPLOT_ROWS | |
| cols = cols or SUBPLOT_COLS | |
| pyplot.subplot(rows, cols, plot_number) | |
| def _Underride(d, **options): | |
| """Add key-value pairs to d only if key is not in d. | |
| If d is None, create a new dictionary. | |
| d: dictionary | |
| options: keyword args to add to d | |
| """ | |
| if d is None: | |
| d = {} | |
| for key, val in options.items(): | |
| d.setdefault(key, val) | |
| return d | |
| def Clf(): | |
| """Clears the figure and any hints that have been set.""" | |
| global LOC | |
| LOC = None | |
| _Brewer.ClearIter() | |
| pyplot.clf() | |
| fig = pyplot.gcf() | |
| fig.set_size_inches(8, 6) | |
| def Figure(**options): | |
| """Sets options for the current figure.""" | |
| _Underride(options, figsize=(6, 8)) | |
| pyplot.figure(**options) | |
| def _UnderrideColor(options): | |
| if 'color' in options: | |
| return options | |
| color_iter = _Brewer.GetIter() | |
| if color_iter: | |
| try: | |
| options['color'] = next(color_iter) | |
| except StopIteration: | |
| # TODO: reconsider whether this should warn | |
| # warnings.warn('Warning: Brewer ran out of colors.') | |
| _Brewer.ClearIter() | |
| return options | |
| def Plot(obj, ys=None, style='', **options): | |
| """Plots a line. | |
| Args: | |
| obj: sequence of x values, or Series, or anything with Render() | |
| ys: sequence of y values | |
| style: style string passed along to pyplot.plot | |
| options: keyword args passed to pyplot.plot | |
| """ | |
| options = _UnderrideColor(options) | |
| label = getattr(obj, 'label', '_nolegend_') | |
| options = _Underride(options, linewidth=3, alpha=0.8, label=label) | |
| xs = obj | |
| if ys is None: | |
| if hasattr(obj, 'Render'): | |
| xs, ys = obj.Render() | |
| if isinstance(obj, pandas.Series): | |
| ys = obj.values | |
| xs = obj.index | |
| if ys is None: | |
| pyplot.plot(xs, style, **options) | |
| else: | |
| pyplot.plot(xs, ys, style, **options) | |
| def FillBetween(xs, y1, y2=None, where=None, **options): | |
| """Plots a line. | |
| Args: | |
| xs: sequence of x values | |
| y1: sequence of y values | |
| y2: sequence of y values | |
| where: sequence of boolean | |
| options: keyword args passed to pyplot.fill_between | |
| """ | |
| options = _UnderrideColor(options) | |
| options = _Underride(options, linewidth=0, alpha=0.5) | |
| pyplot.fill_between(xs, y1, y2, where, **options) | |
| def Bar(xs, ys, **options): | |
| """Plots a line. | |
| Args: | |
| xs: sequence of x values | |
| ys: sequence of y values | |
| options: keyword args passed to pyplot.bar | |
| """ | |
| options = _UnderrideColor(options) | |
| options = _Underride(options, linewidth=0, alpha=0.6) | |
| pyplot.bar(xs, ys, **options) | |
| def Scatter(xs, ys=None, **options): | |
| """Makes a scatter plot. | |
| xs: x values | |
| ys: y values | |
| options: options passed to pyplot.scatter | |
| """ | |
| options = _Underride(options, color='blue', alpha=0.2, | |
| s=30, edgecolors='none') | |
| if ys is None and isinstance(xs, pandas.Series): | |
| ys = xs.values | |
| xs = xs.index | |
| pyplot.scatter(xs, ys, **options) | |
| def HexBin(xs, ys, **options): | |
| """Makes a scatter plot. | |
| xs: x values | |
| ys: y values | |
| options: options passed to pyplot.scatter | |
| """ | |
| options = _Underride(options, cmap=matplotlib.cm.Blues) | |
| pyplot.hexbin(xs, ys, **options) | |
| def Pdf(pdf, **options): | |
| """Plots a Pdf, Pmf, or Hist as a line. | |
| Args: | |
| pdf: Pdf, Pmf, or Hist object | |
| options: keyword args passed to pyplot.plot | |
| """ | |
| low, high = options.pop('low', None), options.pop('high', None) | |
| n = options.pop('n', 101) | |
| xs, ps = pdf.Render(low=low, high=high, n=n) | |
| options = _Underride(options, label=pdf.label) | |
| Plot(xs, ps, **options) | |
| def Pdfs(pdfs, **options): | |
| """Plots a sequence of PDFs. | |
| Options are passed along for all PDFs. If you want different | |
| options for each pdf, make multiple calls to Pdf. | |
| Args: | |
| pdfs: sequence of PDF objects | |
| options: keyword args passed to pyplot.plot | |
| """ | |
| for pdf in pdfs: | |
| Pdf(pdf, **options) | |
| def Hist(hist, **options): | |
| """Plots a Pmf or Hist with a bar plot. | |
| The default width of the bars is based on the minimum difference | |
| between values in the Hist. If that's too small, you can override | |
| it by providing a width keyword argument, in the same units | |
| as the values. | |
| Args: | |
| hist: Hist or Pmf object | |
| options: keyword args passed to pyplot.bar | |
| """ | |
| # find the minimum distance between adjacent values | |
| xs, ys = hist.Render() | |
| if 'width' not in options: | |
| try: | |
| options['width'] = 0.9 * np.diff(xs).min() | |
| except TypeError: | |
| warnings.warn("Hist: Can't compute bar width automatically." | |
| "Check for non-numeric types in Hist." | |
| "Or try providing width option." | |
| ) | |
| options = _Underride(options, label=hist.label) | |
| options = _Underride(options, align='center') | |
| if options['align'] == 'left': | |
| options['align'] = 'edge' | |
| elif options['align'] == 'right': | |
| options['align'] = 'edge' | |
| options['width'] *= -1 | |
| Bar(xs, ys, **options) | |
| def Hists(hists, **options): | |
| """Plots two histograms as interleaved bar plots. | |
| Options are passed along for all PMFs. If you want different | |
| options for each pmf, make multiple calls to Pmf. | |
| Args: | |
| hists: list of two Hist or Pmf objects | |
| options: keyword args passed to pyplot.plot | |
| """ | |
| for hist in hists: | |
| Hist(hist, **options) | |
| def Pmf(pmf, **options): | |
| """Plots a Pmf or Hist as a line. | |
| Args: | |
| pmf: Hist or Pmf object | |
| options: keyword args passed to pyplot.plot | |
| """ | |
| xs, ys = pmf.Render() | |
| low, high = min(xs), max(xs) | |
| width = options.pop('width', None) | |
| if width is None: | |
| try: | |
| width = np.diff(xs).min() | |
| except TypeError: | |
| warnings.warn("Pmf: Can't compute bar width automatically." | |
| "Check for non-numeric types in Pmf." | |