 

Expyplot.Plot – expyplot v1.2.2

expyplot v1.2.2

 Expyplot.Plot

===============================

**This is the end-user API for pyplot.**See the matplotlib.plot docs at:

<http://matplotlib.org/api/pyplot_api.html>

**Most of these functions are UNTESTED. I know. That's terrible. But you can test them by using them! Then, if they don't work, open an issue on the github:**<https://github.com/MaxStrange/expyplot/issues>

**Or better yet, you could write some tests or a patch and open a pull request!**Also, since the return values are simply the string representations of whatever was returned to the python server, all of the return values

will need to be converted into actual Elixir datastructures. I would love to get around to changing this behavior in the future, but for now, it is

as it is. **This also means that numpy arrays that are returned are likely to be truncated**.

This documentation is mostly just copied from the matplotlib.plot docs, and much of it isn’t translated to Elixir like it should be.

 Summary

==========

[Functions](#functions)

------------------------

[acorr(x, opts \\ [hold: nil, data: nil], kwargs \\ [])](#acorr/3)

Plot the autocorrelation of x

[angle\_spectrum(x, opts \\ [\_Fs: 2, \_Fc: 0, pad\_to: nil, sides: :default], kwargs \\ [])](#angle_spectrum/3)

Plot the angle spectrum

[annotate(opts \\ [], kwargs \\ [])](#annotate/2)

Annotate the point xy with text s

[arrow(x, y, dx, dy, opts \\ [hold: nil], kwargs \\ [])](#arrow/6)

Add an arrow to the axes

[autoscale(opts \\ [enable: true, axis: :both, tight: nil])](#autoscale/1)

Autoscale the axis view to the data (toggle)

[autumn()](#autumn/0)

Set the default colormap to autumn and apply to current image if any. See help(colormaps) for more information

[axes(opts \\ [], kwargs \\ [])](#axes/2)

Add an axes to the figure

[axhline(opts \\ [y: 0, xmin: 0, xmax: 1, hold: nil], kwargs \\ [])](#axhline/2)

Add a horizontal line across the axis

[axhspan(ymin, ymax, opts \\ [xmin: 0, xmax: 1, hold: nil], kwargs \\ [])](#axhspan/4)

Add a horizontal span (rectangle) across the axis

[axis\_get(kwargs \\ [])](#axis_get/1)

**This is how *axis* has been implemented in this library: as two functions - a get and a set, rather than just the one**Convenience method to get or set axis properties

[axis\_set(v, kwargs \\ [])](#axis_set/2)

**This is how *axis* has been implemented in this library: as two functions - a get and a set, rather than just the one**Convenience method to get or set axis properties

[axvline(opts \\ [x: 0, ymin: 0, ymax: 1, hold: nil], kwargs \\ [])](#axvline/2)

Add a vertical line across the axes

[axvspan(xmin, xmax, opts \\ [ymin: 0, ymax: 1, hold: nil], kwargs \\ [])](#axvspan/4)

Add a vertical span (rectangle) across the axes

[bar(left, height, opts \\ [width: 0.8, bottom: nil, hold: nil, data: nil], kwargs \\ [])](#bar/4)

Make a bar plot

[barbs(opts \\ [], kwargs \\ [])](#barbs/2)

Plot a 2-D field of barbs

[barh(bottom, width, opts \\ [height: 0.8, left: nil, hold: nil], kwargs \\ [])](#barh/4)

Make a horizontal bar plot

[bone()](#bone/0)

Set the default colormap to bone and apply to current image if any

[boxplot(x, opts \\ [notch: nil, sym: nil, vert: nil, whis: nil, positions: nil, widths: nil, patch\_artist: nil, bootstrap: nil, usermedians: nil, conf\_intervals: nil, meanline: nil, showmeans: nil, showcaps: nil, showbox: nil, showfliers: nil, boxprops: nil, labels: nil, flierprops: nil, medianprops: nil, meanprops: nil, capprops: nil, whiskerprops: nil, manage\_xticks: true, autorange: false, zorder: nil, hold: nil, data: nil])](#boxplot/2)

Make a box and whisker plot

[broken\_barh(xranges, yrange, opts \\ [hold: nil, data: nil], kwargs \\ [])](#broken_barh/4)

Plot horizontal bars

[cla()](#cla/0)

Clear the current axes

[clabel(cs, opts \\ [], kwargs \\ [])](#clabel/3)

Label a contour plot

[clf()](#clf/0)

Clear the current figure

[clim(opts \\ [vmin: nil, vmax: nil])](#clim/1)

Set the color limits of the current image

[close(opts \\ [])](#close/1)

Close a figure window

[cohere(x, y, opts \\ [nfft: 256, \_Fs: 2, \_Fc: 0, noverlap: 0, pad\_to: nil, sides: :default, scale\_by\_freq: nil, hold: nil, data: nil], kwargs \\ [])](#cohere/4)

Plot the coherence between *x* and *y*

[colorbar(opts \\ [mappable: nil, cax: nil, ax: nil], kwargs \\ [])](#colorbar/2)

Add a colorbar to a plot

[colors()](#colors/0)

This is a do-nothing function to provide you with help on how matplotlib handles colors

[contour(opts \\ [], kwargs \\ [])](#contour/2)

Plot contours

[contourf(opts \\ [], kwargs \\ [])](#contourf/2)

Plot contours

[cool()](#cool/0)

Set the default colormap to cool and apply to current image if any

[copper()](#copper/0)

Set the default colormap to copper and apply to current image if any

[csd(x, y, opts \\ [nfft: 256, \_Fs: 2, \_Fc: 0, noverlap: 0, pad\_to: nil, sides: :default, scale\_by\_freq: nil, return\_line: nil], kwargs \\ [])](#csd/4)

Plot the cross-spectral density

[delaxes(opts \\ [])](#delaxes/1)

Remove an axes from the current figure. If *ax* doesn’t exist, an error will be raised

[draw()](#draw/0)

Redraw the current figure

[errorbar(x, y, opts \\ [yerr: nil, xerr: nil, fmt: "", ecolor: nil, elinewidth: nil, capsize: nil, barsabove: false, lolims: false, uplims: false, xlolims: false, xuplims: false, errorevery: 1, capthick: nil, hold: nil, data: nil], kwargs \\ [])](#errorbar/4)

Plot an errorbar graph

[eventplot(positions, opts \\ [orientation: :horizontal, lineoffsets: 1, linelengths: 1, linewidths: nil, colors: nil, linestyles: :solid, hold: nil, data: nil], kwargs \\ [])](#eventplot/3)

Plot identical parallel lines at specific positions

[figimage(opts \\ [], kwargs \\ [])](#figimage/2)

Adds a non-resampled image to the figure

[figlegend(handles, labels, loc, kwargs \\ [])](#figlegend/4)

Place a legend in the figure

[fignum\_exists(num)](#fignum_exists/1)

[figtext(opts \\ [], kwargs \\ [])](#figtext/2)

Add text to figure

[figure(opts \\ [num: nil, figsize: nil, dpi: nil, facecolor: nil, edgecolor: nil, frameon: true], kwargs \\ [])](#figure/2)

Creates a new figure

[fill(opts \\ [], kwargs \\ [])](#fill/2)

Plot filled polygons

[fill\_between\_horizontal(y, x1, opts \\ [x2: 0, where: nil, step: nil, hold: nil, data: nil], kwargs \\ [])](#fill_between_horizontal/4)

Make filled polygons between two horizontal curves

[fill\_between\_vertical(x, y1, opts \\ [y2: 0, where: nil, interpolate: false, step: nil, hold: nil, data: nil], kwargs \\ [])](#fill_between_vertical/4)

Make filled polygons between two curves

[findobj(opts \\ [o: nil, match: nil, include\_self: true])](#findobj/1)

Find artist objects

[flag()](#flag/0)

Set the default colormap to flag and apply to current image if any

[gca(kwargs \\ [])](#gca/1)

Get the current Axes instance on the current figure matching the given keyword args, or create one

[gcf()](#gcf/0)

Get a reference to the current figure

[gci()](#gci/0)

Get the current colorable artist. Specifically, returns the current ScalarMappable instance (image or patch collection), or “Nothing” if no

images or patch collections have been defined. The commands imshow() and figimage() create Image instances, and the commands

pcolor() and scatter() create Collection instances. The current image is an attribute of the current axes, or the nearest earlier axes

in the current figure that contains an image

[get\_current\_fig\_manager()](#get_current_fig_manager/0)

[get\_figlabels()](#get_figlabels/0)

Return a list of existing figure labels

[get\_fignums()](#get_fignums/0)

Return a list of existing figure numbers

[get\_plot\_commands()](#get_plot_commands/0)

Get a sorted list of all of the plotting commands

[ginput(opts \\ [], kwargs \\ [])](#ginput/2)

This will wait for *n* clicks from the user and return a list of the coordinates of each click

[gray()](#gray/0)

Set the default colormap to gray and apply to current image if any

[grid(opts \\ [b: nil, which: :major, axis: :both], kwargs \\ [])](#grid/2)

Turn the axes grids on or off

[hexbin(x, y, opts \\ [c: nil, gridsize: 100, bins: nil, xscale: :linear, yscale: :linear, extent: nil, cmap: nil, norm: nil, vmin: nil, vmax: nil, alpha: nil, linewidths: nil, edgecolors: :none, mincnt: nil, marginals: false, hold: nil, data: nil], kwargs \\ [])](#hexbin/4)

Make a hexagonal binning plot

[hist(x, opts \\ [bins: nil, range: nil, normed: false, weights: nil, cumulative: false, bottom: nil, histtype: :bar, align: :mid, orientation: :vertical, rwidth: nil, log: false, color: nil, label: nil, stacked: false, hold: nil, data: nil], kwargs \\ [])](#hist/3)

Plot a histogram

[hist2d(x, y, opts \\ [bins: 10, range: nil, normed: false, weights: nil, cmin: nil, cmax: nil, hold: nil, data: nil], kwargs \\ [])](#hist2d/4)

Make a 2D histogram plot

[hlines(y, xmin, xmax, opts \\ [colors: :k, linestyles: :solid, label: "", hold: nil, data: nil], kwargs \\ [])](#hlines/5)

Plot horizontal lines at each *y* from *xmin* to *xmax*

[hot()](#hot/0)

Set the default colormap to hot and apply to current image if any

[hsv()](#hsv/0)

Set the default colormap to hsv and apply to current image if any

[imread(opts \\ [], kwargs \\ [])](#imread/2)

Read an image from a file into an array

[imsave(opts \\ [], kwargs \\ [])](#imsave/2)

Save an array as an image file

[imshow(x, opts \\ [cmap: nil, norm: nil, aspect: nil, interpolation: nil, alpha: nil, vmin: nil, vmax: nil, origin: nil, extent: nil, shape: nil, filternorm: 1, filterrad: 4.0, imlim: nil, resample: nil, url: nil, hold: nil, data: nil], kwargs \\ [])](#imshow/3)

Display an image on the axes

[inferno()](#inferno/0)

Set the default colormap to inferno and apply to current image if any

[ioff()](#ioff/0)

Turn interactive mode off

[ion()](#ion/0)

Turn interactive mode on

[isinteractive()](#isinteractive/0)

Return status of interactive mode

[jet()](#jet/0)

Set the default coormap to jet and apply to current image if any

[legend(opts \\ [], kwargs \\ [])](#legend/2)

Places a legend on the axes

[locator\_params(opts \\ [axis: :both, tight: nil], kwargs \\ [])](#locator_params/2)

Control behavior of tick locators

[loglog(opts \\ [], kwargs \\ [])](#loglog/2)

Make a plot with log scaling on both the *x* and *y* axis

[magma()](#magma/0)

Set the default colormap to magma and apply to current image if any

[magnitude\_spectrum(x, opts \\ [\_Fs: nil, \_Fc: nil, window: nil, pad\_to: nil, sides: nil, scale: nil, hold: nil, data: nil], kwargs \\ [])](#magnitude_spectrum/3)

Plot the magnitude spectrum

[margins(opts \\ [], kwargs \\ [])](#margins/2)

Set or retrieve autoscaling margins

[matshow(a, opts \\ [fignum: nil], kwargs \\ [])](#matshow/3)

Display an array as a matrix in a new figure window

[minorticks\_off()](#minorticks_off/0)

Remove minor ticks from the current plot

[nipy\_spectral()](#nipy_spectral/0)

Set the default colormap to nipy\_spectral and apply to current image if any

[pause(interval)](#pause/1)

Pause for *interval* seconds

[pcolor(opts \\ [], kwargs \\ [])](#pcolor/2)

Create a pseudocolor plot of a 2-D array

[pcolormesh(opts \\ [], kwargs \\ [])](#pcolormesh/2)

Plot a quadrilateral mesh

[phase\_spectrum(x, opts \\ [\_Fs: nil, \_Fc: nil, window: nil, pad\_to: nil, sides: nil, hold: nil, data: nil], kwargs \\ [])](#phase_spectrum/3)

Plot the phase spectrum

[pie(x, opts \\ [explode: nil, labels: nil, colors: nil, autopct: nil, pctdistance: 0.6, shadow: false, labeldistance: 1.1, startangle: nil, radius: nil, counterclock: true, wedgeprops: nil, textprops: nil, center: {0, 0}, frame: false, hold: nil, data: nil])](#pie/2)

Plot a pie chart

[pink()](#pink/0)

Set the default colormap to pink and apply to current image if any

[plasma()](#plasma/0)

Set the default colormap to plasma and apply to current image if any

[plot(opts \\ [], kwargs \\ [])](#plot/2)

Plot lines and/or markers to the Axes. *args* is a variable length argument, allowing for multiple *x, y* pairs with an optional format string

[plot\_date(x, y, opts \\ [fmt: :o, tz: nil, xdate: true, ydate: false, hold: nil, data: nil], kwargs \\ [])](#plot_date/4)

A plot with data that contains dates

[plotfile(fname, opts \\ [cols: {0}, plotfuncs: nil, comments: "#", skiprows: 0, checkrows: 5, delimiter: ",", names: nil, subplots: true, newfig: true], kwargs \\ [])](#plotfile/3)

Plot the data in a file

[polar(opts \\ [], kwargs \\ [])](#polar/2)

make a polar plot

[prism()](#prism/0)

Set the default colormap to prism and apply to current image if any

[psd(x, opts \\ [nfft: nil, \_Fs: nil, \_Fc: nil, detrend: nil, window: nil, noverlap: nil, pad\_to: nil, sides: nil, scale\_by\_freq: nil, return\_line: nil, hold: nil, data: nil], kwargs \\ [])](#psd/3)

Plot the power spectral density

[quiver(opts \\ [], kwargs \\ [])](#quiver/2)

Plot a 2-D field of arrows

[quiverkey(opts \\ [], kwargs \\ [])](#quiverkey/2)

Add a key to a quiver plot

[rc(opts \\ [], kwargs \\ [])](#rc/2)

Set the current rc params. Group is the grouping for the rc

[rcdefaults()](#rcdefaults/0)

Restore the default rc params. These are not the params loaded by the rc file, but mpl’s internal params. See rc\_file\_defaults for reloading

the default params from the rc file

[rgrids(opts \\ [], kwargs \\ [])](#rgrids/2)

Get or set the radial gridlines on a polar plot

[savefig(opts \\ [], kwargs \\ [])](#savefig/2)

Save the current figure

[scatter(x, y, opts \\ [s: nil, c: nil, marker: nil, cmap: nil, norm: nil, vmin: nil, vmax: nil, alpha: nil, linewidths: nil, verts: nil, edgecolors: nil, hold: nil, data: nil], kwargs \\ [])](#scatter/4)

Make a scatter plot of x vs y

[semilogx(opts \\ [], kwargs \\ [])](#semilogx/2)

Make a plot with log scaling on the x axis

[semilogy(opts \\ [], kwargs \\ [])](#semilogy/2)

Make a plot with log scaling on the y axis

[set\_cmap(cmap)](#set_cmap/1)

Set the default colormap. Applies to the current image if any

[show(opts \\ [], kwargs \\ [])](#show/2)

Display a figure

[specgram(x, opts \\ [nfft: nil, \_Fs: nil, \_Fc: nil, detrend: nil, window: nil, noverlap: nil, cmap: nil, xextent: nil, pad\_to: nil, sides: nil, scale\_by\_freq: nil, mode: nil, scale: nil, vmin: nil, vmax: nil, hold: nil, data: nil], kwargs \\ [])](#specgram/3)

Plot a spectrogram

[spectral()](#spectral/0)

Set the default colormap to spectral and apply to current image if any

[spring()](#spring/0)

Set the default colormap to spring and apply to current image if any

[spy(z, opts \\ [precision: 0, marker: nil, markersize: nil, aspect: :equal], kwargs \\ [])](#spy/3)

Plot the sparsity pattern on a 2-D array

[stackplot(x, opts \\ [], kwargs \\ [])](#stackplot/3)

Draws a stacked area plot

[stem(opts \\ [], kwargs \\ [])](#stem/2)

Create a stem plot

[step(x, y, opts \\ [], kwargs \\ [])](#step/4)

Make a step plot

[streamplot(x, y, u, v, opts \\ [density: 1, linewidth: nil, color: nil, cmap: nil, norm: nil, arrowsize: 1, arrowstyle: "-|>", minlength: 0.1, transform: nil, zorder: nil, start\_points: nil, hold: nil, data: nil])](#streamplot/5)

Draws streamlinkes of a vector flow

[subplot(opts \\ [], kwargs \\ [])](#subplot/2)

Return a subplot axes positioned by the given grid definition

[subplot2grid(shape, loc, opts \\ [rowspan: 1, colspan: 1], kwargs \\ [])](#subplot2grid/4)

Create a subplot in a grid. The grid is specified by *shape*, at location of *loc*, spanning *rowspan, colspan* cells in each direction.

The index for loc is 0-based

[subplot\_tool(opts \\ [targetfig: nil], kwargs \\ [])](#subplot_tool/2)

Launch a subplot tool window for a figure

[subplots(opts \\ [nrows: 1, ncols: 1, sharex: false, sharey: false, squeeze: true, subplot\_kw: nil, gridspec\_kw: nil], kwargs \\ [])](#subplots/2)

Create a figure and a set of subplots

[subplots\_adjust(opts \\ [], kwargs \\ [])](#subplots_adjust/2)

Tune the subplot layout

[summer()](#summer/0)

Set the default colormap to summer and apply to current image if any

[suptitle(opts \\ [], kwargs \\ [])](#suptitle/2)

Add a centered title to the figure

[table(kwargs \\ [])](#table/1)

Add a table to the current axes

[text(x, y, s, opts \\ [fontdict: nil, withdash: false], kwargs \\ [])](#text/5)

Add text to the axes

[thetagrids(opts \\ [], kwargs \\ [])](#thetagrids/2)

Get or set the theta locations of the gridlines in a polar plot

[tick\_parameters(opts \\ [axis: :both], kwargs \\ [])](#tick_parameters/2)

Change the appearance of ticks and tick labels

[ticklabel\_format(kwargs \\ [])](#ticklabel_format/1)

Change the ScalarFormatter used by default for linear axes

[tight\_layout(opts \\ [pad: 1.08, h\_pad: nil, w\_pad: nil, rect: nil])](#tight_layout/1)

Automatically adjust subplot parameters to give specified padding

[title(s, opts \\ [], kwargs \\ [])](#title/3)

Set a title of the current axes

[tricontour(opts \\ [], kwargs \\ [])](#tricontour/2)

Draw contours on an unstructured triangular grid tricontour() and tricontourf() draw contour lines and filled contours,

respectively

[tricontourf(opts \\ [], kwargs \\ [])](#tricontourf/2)

Draw contours on an unstructured triangular grid tricontour() and tricontourf() draw contour lines and filled contours,

respectively

[tripcolor(opts \\ [], kwargs \\ [])](#tripcolor/2)

Create a pseudocolor plot of an unstructured triangular grid

[triplot(opts \\ [], kwargs \\ [])](#triplot/2)

Draw an unstructured triangular grid as lines and/or markers

[twinx(opts \\ [ax: nil])](#twinx/1)

Make a second axes that shares the *x*-axis. The new axes will overlay *ax* (or the current axes if *ax* is nil). The ticks for

*ax2* will be placed on the right, and the *ax2* instance is returned

[twiny(opts \\ [ax: nil])](#twiny/1)

Make a second axes that shares the *y*-axis. The new axis will overlay *ax* (or the current axes if *ax* is nil). The ticks for

*ax2* will be placed on the top, and the *ax2* instance is returned

[uninstall\_repl\_displayhook()](#uninstall_repl_displayhook/0)

Uninstalls the matplotlib display hook

[violinplot(dataset, opts \\ [positions: nil, vert: true, widths: 0.5, showmeans: false, showextrema: true, showmedians: false, points: 100, bw\_method: nil, hold: nil, data: nil])](#violinplot/2)

Make a violin plot

[viridis()](#viridis/0)

Set the default colormap to viridis and apply to current image if any

[vlines(x, ymin, ymax, opts \\ [colors: :k, linestyles: :solid, label: "", hold: nil, data: nil], kwargs \\ [])](#vlines/5)

Plot vertical lines

[waitforbuttonpress(opts \\ [], kwargs \\ [])](#waitforbuttonpress/2)

Blocking call to interact with the figure

[winter()](#winter/0)

Set the default colormap to winter and apply to current image if any

[xcorr(x, y, opts \\ [normed: true, usevlines: true, maxlags: 10, hold: nil, data: nil], kwargs \\ [])](#xcorr/4)

Plot the cross correlation between *x* and *y*

[xkcd(opts \\ [scaled: 1, length: 100, randomness: 2], kwargs \\ [])](#xkcd/2)

Turns xkcd sketch-style drawing mode. This will only have effect on things drawn after this function is called

[xlabel(s, opts \\ [], kwargs \\ [])](#xlabel/3)

Set the x axis label of the current axis

[xlim(opts \\ [], kwargs \\ [])](#xlim/2)

Get or set the *x* limits of the current axes

[xscale(opts \\ [], kwargs \\ [])](#xscale/2)

Set the scaling of the x-axis

[xticks(opts \\ [], kwargs \\ [])](#xticks/2)

Get or set the x-limits of the current tick locations and labels

[ylabel(s, opts \\ [], kwargs \\ [])](#ylabel/3)

Set the y-axis label of the current axis

[ylim(opts \\ [], kwargs \\ [])](#ylim/2)

Get or set the y-limits of the current axes

[yscale(opts \\ [], kwargs \\ [])](#yscale/2)

Set the scaling of the y-axis

[yticks(opts \\ [], kwargs \\ [])](#yticks/2)

Get or set the y-limits of the current tick locations and labels

 Functions

============

acorr(x, opts \\ [hold: nil, data: nil], kwargs \\ [])

Plot the autocorrelation of x.

angle\_spectrum(x, opts \\ [\_Fs: 2, \_Fc: 0, pad\_to: nil, sides: :default], kwargs \\ [])

Plot the angle spectrum.

Compute the angle spectrum (wrapped phase spectrum) of x. Data is padded to a length of pad\_to and the windowing function *window* **Not used yet

in Expyplot** is applied to the signal.

Example call:

```

1..1_000_000 |> Enum.to_list |> Expyplot.Plot.angle_spectrum(x, [_Fs: 2, _Fc: 0, pad_to: nil, sides: "default"])

```

annotate(opts \\ [], kwargs \\ [])

Annotate the point xy with text s.

Additional kwargs are passed to Text.

arrow(x, y, dx, dy, opts \\ [hold: nil], kwargs \\ [])

Add an arrow to the axes.

Draws arrow on specified axis from (x, y) to (x + dx, y + dy). Uses FancyArrow patch to construct the arrow.

autoscale(opts \\ [enable: true, axis: :both, tight: nil])

Autoscale the axis view to the data (toggle).

Convenience method for simple axis view autoscaling. It turns autoscaling on or off, and then, if autoscaling for either axis is on, it

performs the autoscaling on the specified axis or axes.

autumn()

Set the default colormap to autumn and apply to current image if any. See help(colormaps) for more information

axes(opts \\ [], kwargs \\ [])

Add an axes to the figure.

The axes is added at position rect specified by:

* axes() by itself creates a default full subplot(111) window axis.

* axes(rect, [facecolor: :w]), where rect = [left, bottom, width, height] in normalized (0, 1) units. facecolor is the background

 color for the axis, default white.

* axes(h) where h is an axes instance makes h the current axis.

axhline(opts \\ [y: 0, xmin: 0, xmax: 1, hold: nil], kwargs \\ [])

Add a horizontal line across the axis.

Typical calls:

```

Expyplot.Plot.axhline(linewidth: 4, color: :r)           # Draw a thick red hline at 'y'=0 that spans the xrange

Expyplot.Plot.axhline(y: 1)                              # Draw a default hline at 'y'=1 that spans the xrange

Expyplot.Plot.axhline(y: 0.5, xmin: 0.25, xmax: 0.75)    # Draw a default hline at 'y'=0.5 that spans the middle half of the xrange

```

axhspan(ymin, ymax, opts \\ [xmin: 0, xmax: 1, hold: nil], kwargs \\ [])

Add a horizontal span (rectangle) across the axis.

Draw a horizontal span (rectangle) from ymin to ymax. With the default values of xmin = 0 and xmax = 1, this always spans the xrange,

regardless of the xlim settings, even if you change them, e.g., with the set\_xlim() command. That is, the horizontal extent is in axes

coords: 0=left, 0.5=middle, 1.0=right but the y location is in data coordinates.

axis\_get(kwargs \\ [])

**This is how *axis* has been implemented in this library: as two functions - a get and a set, rather than just the one**Convenience method to get or set axis properties.

This function is of limited usefulness at this stage, as it simply returns the string representation of the current axis.

```

iex> Expyplot.Plot.axis_get()

"(0.0, 1.0, 0.0, 1.0)"

```

axis\_set(v, kwargs \\ [])

**This is how *axis* has been implemented in this library: as two functions - a get and a set, rather than just the one**Convenience method to get or set axis properties.

Some examples:

--------------

```

iex> Expyplot.Plot.axis_set("off")  # Turn off the axis lines and labels

"(0.0, 1.0, 0.0, 1.0)"

iex> Expyplot.Plot.axis_set("equal") # Changes limits of x and y axis so that equal increments of x and y have the same length

"(-0.055, 0.055, -0.055, 0.055)"

```

axvline(opts \\ [x: 0, ymin: 0, ymax: 1, hold: nil], kwargs \\ [])

Add a vertical line across the axes.

Examples

--------

* Draw a thick read vline at *x* = 0 that spans the yrange:

```

  Expyplot.Plot.axvline(linewidth: 4, color: :r)

```

* Draw a default vline at *x* = 1 that spans the yrange:

```

  Expyplot.Plot.axvline(x: 1)

```

* Draw a default vline at *x* = 0.5 that spans the middle half of the yrange

```

  Expyplot.Plot.axvline(x: 0.5, ymin: 0.25, ymax: 0.75)

```

axvspan(xmin, xmax, opts \\ [ymin: 0, ymax: 1, hold: nil], kwargs \\ [])

Add a vertical span (rectangle) across the axes.

Draw a vertical span (rectangle) from xmin to xmax. With the default values of ymin = 0 and ymax = 1. This always spans the yrange,

regardless of the ylim settings, even if you change them, e.g., with the set\_ylim() command. That is, the vertical extent is in axes

coords: 0=bottom, 0.5=middle, 1.0=top but the y location is in data coordinates.

Examples

--------

Draw a vertical, green, translucent rectangle from x = 1.25 to x = 1.55 that spans the yrange of the axes.

```

iex> Expyplot.Plot.axvspan(1.25, 1.55, facecolor: :g, alpha: 0.5)

```

bar(left, height, opts \\ [width: 0.8, bottom: nil, hold: nil, data: nil], kwargs \\ [])

Make a bar plot.

Make a bar plot with rectangles bounded by: *left*, *left + width*, *bottom*, *bottom + height*

(left, right, bottom and top edges).

barbs(opts \\ [], kwargs \\ [])

Plot a 2-D field of barbs.

barh(bottom, width, opts \\ [height: 0.8, left: nil, hold: nil], kwargs \\ [])

Make a horizontal bar plot.

Make a horizontal bar plot with rectangles bounded by: *left*, *left + width*, *bottom*, *bottom + height*

(lft, right, bottom and top edges).

*bottom, width, height*, and *left* can be either scalars or sequences

 

bone()

Set the default colormap to bone and apply to current image if any.

boxplot(x, opts \\ [notch: nil, sym: nil, vert: nil, whis: nil, positions: nil, widths: nil, patch\_artist: nil, bootstrap: nil, usermedians: nil, conf\_intervals: nil, meanline: nil, showmeans: nil, showcaps: nil, showbox: nil, showfliers: nil, boxprops: nil, labels: nil, flierprops: nil, medianprops: nil, meanprops: nil, capprops: nil, whiskerprops: nil, manage\_xticks: true, autorange: false, zorder: nil, hold: nil, data: nil])

Make a box and whisker plot.

Make a box and whisker plot for each column of *x* or each vector in sequence *x*. The box extends from the lower to upper quartile values

of the data, with a line at the median. The whiskers extend from the box to show the range of the data. Flier points are those past the end

of the whiskers.

broken\_barh(xranges, yrange, opts \\ [hold: nil, data: nil], kwargs \\ [])

Plot horizontal bars.

A collection of horizontal bars spanning *yrange* with a sequence of *xranges*.

cla()

Clear the current axes.

clabel(cs, opts \\ [], kwargs \\ [])

Label a contour plot.

clf()

Clear the current figure.

clim(opts \\ [vmin: nil, vmax: nil])

Set the color limits of the current image.

To apply clim to all axes images do:

```

clim(vmin: 0, vmax: 0.5)

```

If either *vmin* or *vmax* is nil, the image min/max respectively will be used for color scaling.

close(opts \\ [])

Close a figure window.

*close()* by itself closes the current figure*close(num)* closes figure number *num**close(name)* where *name* is a string, closes figure with that label*close(:all)* closes all the figure windows

 

cohere(x, y, opts \\ [nfft: 256, \_Fs: 2, \_Fc: 0, noverlap: 0, pad\_to: nil, sides: :default, scale\_by\_freq: nil, hold: nil, data: nil], kwargs \\ [])

Plot the coherence between *x* and *y*.

Plot the coherence between *x* and *y*. Coherence is the normalized cross spectral density.

colorbar(opts \\ [mappable: nil, cax: nil, ax: nil], kwargs \\ [])

Add a colorbar to a plot.

colors()

This is a do-nothing function to provide you with help on how matplotlib handles colors.

contour(opts \\ [], kwargs \\ [])

Plot contours.

contour() and contourf() draw contour lines and filled contours, respectively. Except as noted, function signatures and return values

are the same for both versions.

contourf() differs from the MATLAB version in that it does not draw the polygon edges. To draw edges, add line contours with calls to contour().

contourf(opts \\ [], kwargs \\ [])

Plot contours.

contour() and contourf() draw contour lines and filled contours, respectively. Except as noted, function signatures and return values

are the same for both versions.

contourf() differs from the MATLAB version in that it does not draw the polygon edges. To draw edges, add line contours with calls to contour().

cool()

Set the default colormap to cool and apply to current image if any.

copper()

Set the default colormap to copper and apply to current image if any.

csd(x, y, opts \\ [nfft: 256, \_Fs: 2, \_Fc: 0, noverlap: 0, pad\_to: nil, sides: :default, scale\_by\_freq: nil, return\_line: nil], kwargs \\ [])

Plot the cross-spectral density.

delaxes(opts \\ [])

Remove an axes from the current figure. If *ax* doesn’t exist, an error will be raised.

draw()

Redraw the current figure.

This is used to update a figure that has been altered, but not automatically re-drawn. If interactive mode is on (ion()), this should be only

rarely needed, but there may be ways to modify the state of a figure without marking it as *stale*.

errorbar(x, y, opts \\ [yerr: nil, xerr: nil, fmt: "", ecolor: nil, elinewidth: nil, capsize: nil, barsabove: false, lolims: false, uplims: false, xlolims: false, xuplims: false, errorevery: 1, capthick: nil, hold: nil, data: nil], kwargs \\ [])

Plot an errorbar graph.

Plot x versus y with error deltas in yerr and xerr. Vertical errorbars are plotted if yerr is not nil. Horizontal errorbars are plotted if xerr is

not nil.

x, y, xerr, and yerr can all be scalars, which plots a single error bar at x, y.

eventplot(positions, opts \\ [orientation: :horizontal, lineoffsets: 1, linelengths: 1, linewidths: nil, colors: nil, linestyles: :solid, hold: nil, data: nil], kwargs \\ [])

Plot identical parallel lines at specific positions.

Plot parallel lines at the given *positions*. *positions* should be a 1D or 2D array-like object, with each row corresponding to a row or

column of lines.

This type of plot is commonly used in neuroscience for representing neural events, where it is commonly called a spike raster, dot raster, or raster plot.

However, it is useful in any situation where you wish to show the timing or position of multiple sets of discrete events, such as the arrival

times of people to a business on each day of the month or the date of hurricanes each year of the last century.

figimage(opts \\ [], kwargs \\ [])

Adds a non-resampled image to the figure.

figlegend(handles, labels, loc, kwargs \\ [])

Place a legend in the figure.

fignum\_exists(num)

figtext(opts \\ [], kwargs \\ [])

Add text to figure.

Add text to figure at location *x, y* (relative 0-1 coords).

figure(opts \\ [num: nil, figsize: nil, dpi: nil, facecolor: nil, edgecolor: nil, frameon: true], kwargs \\ [])

Creates a new figure.

fill(opts \\ [], kwargs \\ [])

Plot filled polygons.

fill\_between\_horizontal(y, x1, opts \\ [x2: 0, where: nil, step: nil, hold: nil, data: nil], kwargs \\ [])

Make filled polygons between two horizontal curves.

fill\_between\_vertical(x, y1, opts \\ [y2: 0, where: nil, interpolate: false, step: nil, hold: nil, data: nil], kwargs \\ [])

Make filled polygons between two curves.

findobj(opts \\ [o: nil, match: nil, include\_self: true])

Find artist objects.

Recursively find all Artist instances contained in self.

flag()

Set the default colormap to flag and apply to current image if any.

gca(kwargs \\ [])

Get the current Axes instance on the current figure matching the given keyword args, or create one.

gcf()

Get a reference to the current figure.

gci()

Get the current colorable artist. Specifically, returns the current ScalarMappable instance (image or patch collection), or “Nothing” if no

images or patch collections have been defined. The commands imshow() and figimage() create Image instances, and the commands

pcolor() and scatter() create Collection instances. The current image is an attribute of the current axes, or the nearest earlier axes

in the current figure that contains an image.

get\_current\_fig\_manager()

get\_figlabels()

Return a list of existing figure labels.

get\_fignums()

Return a list of existing figure numbers.

get\_plot\_commands()

Get a sorted list of all of the plotting commands.

ginput(opts \\ [], kwargs \\ [])

This will wait for *n* clicks from the user and return a list of the coordinates of each click.

If *timeout* is zero or negative, does not timeout.

If *n* is zero or negative, accumulated clicks until a middle click (or potentially both mouse buttons at once) terminates the input.

Right clicking cancels last input.

The buttons used for the various actions (adding points, removing points, terminating the inputs) can be overriden via the arguments

*mouse\_add, mouse\_pop* and *mouse\_stop*, that give the associated mouse button: 1 for left, 2 for middle, 3 for right.The keyboard can also be used to select points in case your mouse does not have one or more of the buttons. The delete and backspace

keys act like right clicking (i.e., remove last point), the enter key terminates input and any other key (not already used by the window

manager) selects a point.

gray()

Set the default colormap to gray and apply to current image if any.

grid(opts \\ [b: nil, which: :major, axis: :both], kwargs \\ [])

Turn the axes grids on or off.

Set the axes grids on or off; *b* is a boolean. (For MATLAB compatibility, *b* may also be an atom :on or :off.)

hexbin(x, y, opts \\ [c: nil, gridsize: 100, bins: nil, xscale: :linear, yscale: :linear, extent: nil, cmap: nil, norm: nil, vmin: nil, vmax: nil, alpha: nil, linewidths: nil, edgecolors: :none, mincnt: nil, marginals: false, hold: nil, data: nil], kwargs \\ [])

Make a hexagonal binning plot.

Make a hexagonal binning plot of *x* versus *y*, where *x, y* are 1-D sequences of the same length, *N*. If *C* is

nil (the default), this is a histogram of the number of occurrences of the observations at (x[i], y[i]).

If *C* is specified, it specifies values at the coordinate (x[i], y[i]). These values are accumulated for each hexagonal bin and then reduced

according to *reduce\_C\_function*, which defaults to numpy’s mean function (np.mean). (If *C* is specified, it must also be a 1-D sequence

of the same length as *x* and *y*.)

hist(x, opts \\ [bins: nil, range: nil, normed: false, weights: nil, cumulative: false, bottom: nil, histtype: :bar, align: :mid, orientation: :vertical, rwidth: nil, log: false, color: nil, label: nil, stacked: false, hold: nil, data: nil], kwargs \\ [])

Plot a histogram.

Compute and draw the histogram of *x*. The return value is a tuple (*n, bins, patches*) or (*[n0, n1, ...], bins, [patches0, patches1, ...]*)

if the input contains multiple data.

Multiple data can be provided via *x* as a list of datasets of potentially different length, or as a 2-D ndarray in which each column is a dataset.

Note that the ndarray form is transposed relative to the list form.

Masked arrays are not supported at present.

hist2d(x, y, opts \\ [bins: 10, range: nil, normed: false, weights: nil, cmin: nil, cmax: nil, hold: nil, data: nil], kwargs \\ [])

Make a 2D histogram plot.

hlines(y, xmin, xmax, opts \\ [colors: :k, linestyles: :solid, label: "", hold: nil, data: nil], kwargs \\ [])

Plot horizontal lines at each *y* from *xmin* to *xmax*.

hot()

Set the default colormap to hot and apply to current image if any.

hsv()

Set the default colormap to hsv and apply to current image if any.

imread(opts \\ [], kwargs \\ [])

Read an image from a file into an array.

*fname* may be a string path, or a valid URL.If *format* is provided, will try to read file of that type, otherwise the format is deduced from the filename. If nothing can be deduced, PNG

is tried.

Return value is a numpy.array **But in expyplot, this will return a string, and it probably won’t work**. For grayscale images, the return array is MxN.

For RGB images, the return value is MxNx4.

matplotlib can only read PNGs natively, but if PIL is installed, it will use it to load the image and return an array (if possible) which can

be used with imshow(). Note, URL strings may not be compatible with PIL. Check the PIL documentation for more information.

imsave(opts \\ [], kwargs \\ [])

Save an array as an image file.

The output formats available depend on the backend being used.

imshow(x, opts \\ [cmap: nil, norm: nil, aspect: nil, interpolation: nil, alpha: nil, vmin: nil, vmax: nil, origin: nil, extent: nil, shape: nil, filternorm: 1, filterrad: 4.0, imlim: nil, resample: nil, url: nil, hold: nil, data: nil], kwargs \\ [])

Display an image on the axes.

inferno()

Set the default colormap to inferno and apply to current image if any.

ioff()

Turn interactive mode off.

ion()

Turn interactive mode on.

isinteractive()

Return status of interactive mode.

jet()

Set the default coormap to jet and apply to current image if any.

legend(opts \\ [], kwargs \\ [])

Places a legend on the axes.

locator\_params(opts \\ [axis: :both, tight: nil], kwargs \\ [])

Control behavior of tick locators.

loglog(opts \\ [], kwargs \\ [])

Make a plot with log scaling on both the *x* and *y* axis.

loglog() supports all the keyword arguments of plot() and matplotlib.axes.Axes.set\_xscale() / matplotlib.axes.Axes.set\_yscale().

magma()

Set the default colormap to magma and apply to current image if any.

magnitude\_spectrum(x, opts \\ [\_Fs: nil, \_Fc: nil, window: nil, pad\_to: nil, sides: nil, scale: nil, hold: nil, data: nil], kwargs \\ [])

Plot the magnitude spectrum.

margins(opts \\ [], kwargs \\ [])

Set or retrieve autoscaling margins.

matshow(a, opts \\ [fignum: nil], kwargs \\ [])

Display an array as a matrix in a new figure window.

The origin is set at the upper left hand corner and rows (first dimension of the array) are displayed horizontally. The aspect ratio of the

figure window is that of the array, unless this would make an excessively short or narrow figure.

Tick labels for the xaxis are placed on top.

minorticks\_off()

Remove minor ticks from the current plot.

nipy\_spectral()

Set the default colormap to nipy\_spectral and apply to current image if any.

pause(interval)

Pause for *interval* seconds.

If there is an active figure it will be updated and displayed, and the GUI event loop will run during the pause.

If there is no active figure, or if a non-interactive backend is in use, this executes time.sleep(interval).

This can be used for crude animation.

pcolor(opts \\ [], kwargs \\ [])

Create a pseudocolor plot of a 2-D array.

pcolormesh(opts \\ [], kwargs \\ [])

Plot a quadrilateral mesh.

phase\_spectrum(x, opts \\ [\_Fs: nil, \_Fc: nil, window: nil, pad\_to: nil, sides: nil, hold: nil, data: nil], kwargs \\ [])

Plot the phase spectrum.

pie(x, opts \\ [explode: nil, labels: nil, colors: nil, autopct: nil, pctdistance: 0.6, shadow: false, labeldistance: 1.1, startangle: nil, radius: nil, counterclock: true, wedgeprops: nil, textprops: nil, center: {0, 0}, frame: false, hold: nil, data: nil])

Plot a pie chart.

Make a pie chart of array x. The fractional area of each wedge is given by x / sum(x). If sum(x) <= 1, then the values of x give the fractional

area directly and the array will not be normalized. The wedges are plotted counterclockwise, by default starting from the x-axis.

pink()

Set the default colormap to pink and apply to current image if any.

plasma()

Set the default colormap to plasma and apply to current image if any.

plot(opts \\ [], kwargs \\ [])

Plot lines and/or markers to the Axes. *args* is a variable length argument, allowing for multiple *x, y* pairs with an optional format string.

Each of the following is legal:

```

x = 1..10 |> Enum.to_list

y = 11..20 |> Enum.to_list

Expyplot.Plot.plot([x, y])          # plot x and y using default line style and color

Expyplot.Plot.plot([x, y, "bo"])    # plot x and y using blue circle markers

Expyplot.Plot.plot([y])             # plot y using x as index array 0..N-1

Expyplot.Plot.plot([y, "r+"])       # ditto, but with red plusses

x2 = 1..5 |> Enum.to_list

y2 = 3..7 |> Enum.to_list

Expyplot.Plot.plot([x, y, "g^", x2, y2, "g-"])

```

Due to the differences between function signatures in Python and Elixir, the typical usage of this function is a little different than what you would

expect:

```

iex> Expyplot.Plot.plot([[1, 2, 3, 4, 5]])

or

iex> Expyplot.Plot.plot([1..5])

```

Notice the nesting of the list or range.

Examples with keyword args

--------------------------

```

Expyplot.Plot.plot([[1, 2, 3], [1, 2, 3], "go-"], label: "line 1", linewidth: 2)

Expyplot.Plot.plot([[1, 2, 3], [1, 4, 9], "rs"], label: "line 2")

Expyplot.Plot.axis_set([0, 4, 0, 10])  # Notice that this signature is 'axis_set', not 'axis' as in matplotlib

Expyplot.Plot.legend()

```

plot\_date(x, y, opts \\ [fmt: :o, tz: nil, xdate: true, ydate: false, hold: nil, data: nil], kwargs \\ [])

A plot with data that contains dates.

plotfile(fname, opts \\ [cols: {0}, plotfuncs: nil, comments: "#", skiprows: 0, checkrows: 5, delimiter: ",", names: nil, subplots: true, newfig: true], kwargs \\ [])

Plot the data in a file.

polar(opts \\ [], kwargs \\ [])

make a polar plot.

prism()

Set the default colormap to prism and apply to current image if any.

psd(x, opts \\ [nfft: nil, \_Fs: nil, \_Fc: nil, detrend: nil, window: nil, noverlap: nil, pad\_to: nil, sides: nil, scale\_by\_freq: nil, return\_line: nil, hold: nil, data: nil], kwargs \\ [])

Plot the power spectral density.

quiver(opts \\ [], kwargs \\ [])

Plot a 2-D field of arrows.

quiverkey(opts \\ [], kwargs \\ [])

Add a key to a quiver plot.

rc(opts \\ [], kwargs \\ [])

Set the current rc params. Group is the grouping for the rc.

rcdefaults()

Restore the default rc params. These are not the params loaded by the rc file, but mpl’s internal params. See rc\_file\_defaults for reloading

the default params from the rc file.

rgrids(opts \\ [], kwargs \\ [])

Get or set the radial gridlines on a polar plot.

savefig(opts \\ [], kwargs \\ [])

Save the current figure.

scatter(x, y, opts \\ [s: nil, c: nil, marker: nil, cmap: nil, norm: nil, vmin: nil, vmax: nil, alpha: nil, linewidths: nil, verts: nil, edgecolors: nil, hold: nil, data: nil], kwargs \\ [])

Make a scatter plot of x vs y.

Marker size is scaled by s and marker color is mapped to c.

semilogx(opts \\ [], kwargs \\ [])

Make a plot with log scaling on the x axis.

semilogy(opts \\ [], kwargs \\ [])

Make a plot with log scaling on the y axis.

set\_cmap(cmap)

Set the default colormap. Applies to the current image if any.

*cmap* must be the name of a registered colormap.

 

show(opts \\ [], kwargs \\ [])

Display a figure.

specgram(x, opts \\ [nfft: nil, \_Fs: nil, \_Fc: nil, detrend: nil, window: nil, noverlap: nil, cmap: nil, xextent: nil, pad\_to: nil, sides: nil, scale\_by\_freq: nil, mode: nil, scale: nil, vmin: nil, vmax: nil, hold: nil, data: nil], kwargs \\ [])

Plot a spectrogram.

spectral()

Set the default colormap to spectral and apply to current image if any.

spring()

Set the default colormap to spring and apply to current image if any.

spy(z, opts \\ [precision: 0, marker: nil, markersize: nil, aspect: :equal], kwargs \\ [])

Plot the sparsity pattern on a 2-D array.

spy(z) plots the sparsity pattern of the 2-D array *z*.

stackplot(x, opts \\ [], kwargs \\ [])

Draws a stacked area plot.

stem(opts \\ [], kwargs \\ [])

Create a stem plot.

step(x, y, opts \\ [], kwargs \\ [])

Make a step plot.

streamplot(x, y, u, v, opts \\ [density: 1, linewidth: nil, color: nil, cmap: nil, norm: nil, arrowsize: 1, arrowstyle: "-|>", minlength: 0.1, transform: nil, zorder: nil, start\_points: nil, hold: nil, data: nil])

Draws streamlinkes of a vector flow.

subplot(opts \\ [], kwargs \\ [])

Return a subplot axes positioned by the given grid definition.

subplot2grid(shape, loc, opts \\ [rowspan: 1, colspan: 1], kwargs \\ [])

Create a subplot in a grid. The grid is specified by *shape*, at location of *loc*, spanning *rowspan, colspan* cells in each direction.

The index for loc is 0-based.

subplot\_tool(opts \\ [targetfig: nil], kwargs \\ [])

Launch a subplot tool window for a figure.

subplots(opts \\ [nrows: 1, ncols: 1, sharex: false, sharey: false, squeeze: true, subplot\_kw: nil, gridspec\_kw: nil], kwargs \\ [])

Create a figure and a set of subplots.

This utility wrapper makes it convenient to create common layouts of subplots, including the enclosing figure object, in a single call.

subplots\_adjust(opts \\ [], kwargs \\ [])

Tune the subplot layout.

summer()

Set the default colormap to summer and apply to current image if any.

suptitle(opts \\ [], kwargs \\ [])

Add a centered title to the figure.

table(kwargs \\ [])

Add a table to the current axes.

text(x, y, s, opts \\ [fontdict: nil, withdash: false], kwargs \\ [])

Add text to the axes.

Add text in string *s* to axis at location *x, y* data coordinates.

thetagrids(opts \\ [], kwargs \\ [])

Get or set the theta locations of the gridlines in a polar plot.

If no arguments are passed, return a tuple (*lines, labels*) where *lines* is an array of radial gridlines (Line2D instances) and *labels*

is an array of tick labels (Text instances).

tick\_parameters(opts \\ [axis: :both], kwargs \\ [])

Change the appearance of ticks and tick labels.

ticklabel\_format(kwargs \\ [])

Change the ScalarFormatter used by default for linear axes.

tight\_layout(opts \\ [pad: 1.08, h\_pad: nil, w\_pad: nil, rect: nil])

Automatically adjust subplot parameters to give specified padding.

title(s, opts \\ [], kwargs \\ [])

Set a title of the current axes.

Set one of hte three available axes titles. The available titles are positioned above the aces in the center, flush with the left edge, and flush

with the right edge.

tricontour(opts \\ [], kwargs \\ [])

Draw contours on an unstructured triangular grid tricontour() and tricontourf() draw contour lines and filled contours,

respectively.

tricontourf(opts \\ [], kwargs \\ [])

Draw contours on an unstructured triangular grid tricontour() and tricontourf() draw contour lines and filled contours,

respectively.

tripcolor(opts \\ [], kwargs \\ [])

Create a pseudocolor plot of an unstructured triangular grid.

triplot(opts \\ [], kwargs \\ [])

Draw an unstructured triangular grid as lines and/or markers.

twinx(opts \\ [ax: nil])

Make a second axes that shares the *x*-axis. The new axes will overlay *ax* (or the current axes if *ax* is nil). The ticks for

*ax2* will be placed on the right, and the *ax2* instance is returned.

 

twiny(opts \\ [ax: nil])

Make a second axes that shares the *y*-axis. The new axis will overlay *ax* (or the current axes if *ax* is nil). The ticks for

*ax2* will be placed on the top, and the *ax2* instance is returned.

 

uninstall\_repl\_displayhook()

Uninstalls the matplotlib display hook.

violinplot(dataset, opts \\ [positions: nil, vert: true, widths: 0.5, showmeans: false, showextrema: true, showmedians: false, points: 100, bw\_method: nil, hold: nil, data: nil])

Make a violin plot.

Make a violin plot for each column of *dataset* or each vector in sequence *dataset*. Each filled area extends to represent the entire data

range, with optional lines at the mean, the median, the minimum, and the maximum.

viridis()

Set the default colormap to viridis and apply to current image if any.

vlines(x, ymin, ymax, opts \\ [colors: :k, linestyles: :solid, label: "", hold: nil, data: nil], kwargs \\ [])

Plot vertical lines.

Plot vertical lines at each *x* from *ymin* to *ymax*.

waitforbuttonpress(opts \\ [], kwargs \\ [])

Blocking call to interact with the figure.

This will return “True” if a key was pressed, “False” if a mouse button was pressed and “None” if timeout was reached without either being pressed.

If *timeout* is negative, does not timeout.

winter()

Set the default colormap to winter and apply to current image if any.

xcorr(x, y, opts \\ [normed: true, usevlines: true, maxlags: 10, hold: nil, data: nil], kwargs \\ [])

Plot the cross correlation between *x* and *y*.

xkcd(opts \\ [scaled: 1, length: 100, randomness: 2], kwargs \\ [])

Turns xkcd sketch-style drawing mode. This will only have effect on things drawn after this function is called.

For best results, the “Humor Sans” font should be indstalled: it is not included with matplotlib.

xlabel(s, opts \\ [], kwargs \\ [])

Set the x axis label of the current axis.

xlim(opts \\ [], kwargs \\ [])

Get or set the *x* limits of the current axes.

xscale(opts \\ [], kwargs \\ [])

Set the scaling of the x-axis.

xticks(opts \\ [], kwargs \\ [])

Get or set the x-limits of the current tick locations and labels.

ylabel(s, opts \\ [], kwargs \\ [])

Set the y-axis label of the current axis.

ylim(opts \\ [], kwargs \\ [])

Get or set the y-limits of the current axes.

yscale(opts \\ [], kwargs \\ [])

Set the scaling of the y-axis.

yticks(opts \\ [], kwargs \\ [])

Get or set the y-limits of the current tick locations and labels.



 

Codebuilder – expyplot v1.2.2

expyplot v1.2.2

 Codebuilder

=============================

This module holds the functions that translate Elixir function calls into Python function calls.

 Summary

==========

[Functions](#functions)

------------------------

[build\_code(list)](#build_code/1)

 Functions

============

build\_code(list)



 

Expyplot – expyplot v1.2.2

expyplot v1.2.2

 Expyplot

==========================

This is the supervisor that runs the application.

For now, this module doesn’t really do anything else.

 Summary

==========

[Functions](#functions)

------------------------

[start(type, args)](#start/2)

 Functions

============

start(type, args)



 

Server.Commapi – expyplot v1.2.2

expyplot v1.2.2

 Server.Commapi

================================

This is the API for the pycomm server. Don’t call anything in there except through here.

This is also its supervisor.

 Summary

==========

[Functions](#functions)

------------------------

[add\_code(code)](#add_code/1)

[start\_link()](#start_link/0)

 Functions

============

add\_code(code)

start\_link()



 

Server.Pycomm – expyplot v1.2.2

expyplot v1.2.2

 Server.Pycomm

===============================

This module is a GenServer that manages the Python code that will be executed.

The general idea is that you will call functions in the library’s API and this will usually add

code here. Then when you call Expyplot.Plot.show(), it will flush the code to the Python3

interpretor, thus making the plot.

 Summary

==========

[Functions](#functions)

------------------------

[eval\_code(pid, code)](#eval_code/2)

Adds the given code to the buffer

[start\_link(name)](#start_link/1)

Starts the server

 Functions

============

eval\_code(pid, code)

Adds the given code to the buffer.

start\_link(name)

Starts the server.



 

Server.Pyserver – expyplot v1.2.2

expyplot v1.2.2

 Server.Pyserver

=================================

 Summary

==========

[Functions](#functions)

------------------------

[start\_link(name)](#start_link/1)

Starts the server

 Functions

============

start\_link(name)

Starts the server.



 

Server.Pysupervisor – expyplot v1.2.2

expyplot v1.2.2

 Server.Pysupervisor

=====================================

This is the Supervisor for the python code. It restarts it whenever it goes down.

 Summary

==========

[Functions](#functions)

------------------------

[start\_link()](#start_link/0)

 Functions

============

start\_link()

