Navigation
- index
- modules |
- next |
- previous |
- Sage Reference v4.8 »
- 2D Graphics »
Sage provides extensive 2D plotting functionality. The underlying rendering is done using the matplotlib Python library.
The following graphics primitives are supported:
The following plotting functions are supported:
The following miscellaneous Graphics functions are included:
Type ? after each primitive in Sage for help and examples.
EXAMPLES:
We draw a curve:
sage: plot(x^2, (x,0,5))
We draw a circle and a curve:
sage: circle((1,1), 1) + plot(x^2, (x,0,5))
Notice that the aspect ratio of the above plot makes the plot very tall because the plot adopts the default aspect ratio of the circle (to make the circle appear like a circle). We can change the aspect ratio to be what we normally expect for a plot by explicitly asking for an ‘automatic’ aspect ratio:
sage: show(circle((1,1), 1) + plot(x^2, (x,0,5)), aspect_ratio='automatic')
The aspect ratio describes the apparently height/width ratio of a unit square. If you want the vertical units to be twice as big as the horizontal units, specify an aspect ratio of 2:
sage: show(circle((1,1), 1) + plot(x^2, (x,0,5)), aspect_ratio=2)
The figsize option adjusts the figure size. The default figsize is 4. To make a figure that is roughly twice as big, use figsize=8:
sage: show(circle((1,1), 1) + plot(x^2, (x,0,5)), figsize=8)
You can also give separate horizontal and vertical dimensions:
sage: show(circle((1,1), 1) + plot(x^2, (x,0,5)), figsize=[4,8])
Note that the axes will not cross if the data is not on both sides of both axes, even if it is quite close:
sage: plot(x^3,(x,1,10))
When the labels have quite different orders of magnitude or are very
large, scientific notation (the 
notation for powers of ten) is used:
sage: plot(x^2,(x,480,500)) # no scientific notation
sage: plot(x^2,(x,300,500)) # scientific notation on y-axis
But you can fix your own tick labels, if you know what to expect and have a preference:
sage: plot(x^2,(x,300,500),ticks=[None,50000])
We construct a plot involving several graphics objects:
sage: G = plot(cos(x), (x, -5, 5), thickness=5, color='green')
sage: P = polygon([[1,2], [5,6], [5,0]], color='red')
sage: G + P
Next we construct the reflection of the above polygon about the
-axis by iterating over the list of first-coordinates of
the first graphic element of 
(which is the actual
Polygon; note that is a Graphics object, which consists
of a single polygon):
sage: Q = polygon([(-x,y) for x,y in P[0]], color='blue')
sage: Q # show it
We combine together different graphics objects using “+”:
sage: H = G + P + Q
sage: print H
Graphics object consisting of 3 graphics primitives
sage: type(H)
<class 'sage.plot.plot.Graphics'>
sage: H[1]
Polygon defined by 3 points
sage: list(H[1])
[(1.0, 2.0), (5.0, 6.0), (5.0, 0.0)]
sage: H # show it
We can put text in a graph:
sage: L = [[cos(pi*i/100)^3,sin(pi*i/100)] for i in range(200)]
sage: p = line(L, rgbcolor=(1/4,1/8,3/4))
sage: t = text('A Bulb', (1.5, 0.25))
sage: x = text('x axis', (1.5,-0.2))
sage: y = text('y axis', (0.4,0.9))
sage: g = p+t+x+y
sage: g.show(xmin=-1.5, xmax=2, ymin=-1, ymax=1)
We plot the Riemann zeta function along the critical line and see the first few zeros:
sage: i = CDF.0 # define i this way for maximum speed.
sage: p1 = plot(lambda t: arg(zeta(0.5+t*i)), 1,27,rgbcolor=(0.8,0,0))
sage: p2 = plot(lambda t: abs(zeta(0.5+t*i)), 1,27,color=hue(0.7))
sage: print p1 + p2
Graphics object consisting of 2 graphics primitives
sage: p1 + p2 # display it
Many concentric circles shrinking toward the origin:
sage: show(sum(circle((i,0), i, hue=sin(i/10)) for i in [10,9.9,..,0]))
Here is a pretty graph:
sage: g = Graphics()
sage: for i in range(60):
... p = polygon([(i*cos(i),i*sin(i)), (0,i), (i,0)],\
... color=hue(i/40+0.4), alpha=0.2)
... g = g + p
...
sage: g.show(dpi=200, axes=False)
Another graph:
sage: x = var('x')
sage: P = plot(sin(x)/x, -4,4, color='blue') + \
... plot(x*cos(x), -4,4, color='red') + \
... plot(tan(x),-4,4, color='green')
...
sage: P.show(ymin=-pi,ymax=pi)
PYX EXAMPLES: These are some examples of plots similar to some of the plots in the PyX (http://pyx.sourceforge.net) documentation:
Symbolline:
sage: y(x) = x*sin(x^2)
sage: v = [(x, y(x)) for x in [-3,-2.95,..,3]]
sage: show(points(v, rgbcolor=(0.2,0.6, 0.1), pointsize=30) + plot(spline(v), -3.1, 3))
Cycliclink:
sage: x = var('x')
sage: g1 = plot(cos(20*x)*exp(-2*x), 0, 1)
sage: g2 = plot(2*exp(-30*x) - exp(-3*x), 0, 1)
sage: show(graphics_array([g1, g2], 2, 1), xmin=0)
Pi Axis:
sage: g1 = plot(sin(x), 0, 2*pi)
sage: g2 = plot(cos(x), 0, 2*pi, linestyle = "--")
sage: (g1+g2).show(ticks=pi/6, tick_formatter=pi) # show their sum, nicely formatted
An illustration of integration:
sage: f(x) = (x-3)*(x-5)*(x-7)+40
sage: P = line([(2,0),(2,f(2))], color='black')
sage: P += line([(8,0),(8,f(8))], color='black')
sage: P += polygon([(2,0),(2,f(2))] + [(x, f(x)) for x in [2,2.1,..,8]] + [(8,0),(2,0)], rgbcolor=(0.8,0.8,0.8),aspect_ratio='automatic')
sage: P += text("$\\int_{a}^b f(x) dx$", (5, 20), fontsize=16, color='black')
sage: P += plot(f, (1, 8.5), thickness=3)
sage: P # show the result
NUMERICAL PLOTTING:
Sage includes Matplotlib, which provides 2D plotting with an interface that is a likely very familiar to people doing numerical computation. For example,
sage: from pylab import *
sage: t = arange(0.0, 2.0, 0.01)
sage: s = sin(2*pi*t)
sage: P = plot(t, s, linewidth=1.0)
sage: xl = xlabel('time (s)')
sage: yl = ylabel('voltage (mV)')
sage: t = title('About as simple as it gets, folks')
sage: grid(True)
sage: savefig(os.path.join(SAGE_TMP, 'sage.png'))
We test that imshow works as well, verifying that Trac ticket 2900 is fixed in Matplotlib.
sage: imshow([[(0,0,0)]])
<matplotlib.image.AxesImage object at ...>
sage: savefig(os.path.join(SAGE_TMP, 'foo.png'))
Since the above overwrites many Sage plotting functions, we reset the state of Sage, so that the examples below work!
sage: reset()
See http://matplotlib.sourceforge.net for complete documentation about how to use Matplotlib.
TESTS: We test dumping and loading a plot.
sage: p = plot(sin(x), (x, 0,2*pi))
sage: Q = loads(dumps(p))
Verify that a clean sage startup does not import matplotlib:
sage: os.system("sage -c \"if 'matplotlib' in sys.modules: sys.exit(1)\"")
0
AUTHORS:
Bases: sage.structure.sage_object.SageObject
The Graphics object is an empty list of graphics objects It is useful to use this object when initializing a for loop where different graphics object will be added to the empty object.
EXAMPLES:
sage: G = Graphics(); print G
Graphics object consisting of 0 graphics primitives
sage: c = circle((1,1), 1)
sage: G+=c; print G
Graphics object consisting of 1 graphics primitive
Here we make a graphic of embedded isosceles triangles, coloring each one with a different color as we go:
sage: h=10; c=0.4; p=0.5;
sage: G = Graphics()
sage: for x in srange(1,h+1):
... l = [[0,x*sqrt(3)],[-x/2,-x*sqrt(3)/2],[x/2,-x*sqrt(3)/2],[0,x*sqrt(3)]]
... G+=line(l,color=hue(c + p*(x/h)))
sage: G.show(figsize=[5,5])
TESTS:
From trac #4604, ensure Graphics can handle 3d objects:
sage: g = Graphics()
sage: g += sphere((1, 1, 1), 2)
sage: g.show()
Adds a primitive to this graphics object.
Get the current aspect ratio, which is the ratio of height to width of a unit square, or ‘automatic’.
OUTPUT: a positive float (height/width of a unit square), or ‘automatic’ (expand to fill the figure).
EXAMPLES:
The default aspect ratio for a new blank Graphics object is ‘automatic’:
sage: P = Graphics()
sage: P.aspect_ratio()
'automatic'
The aspect ratio can be explicitly set different than the object’s default:
sage: P = circle((1,1), 1)
sage: P.aspect_ratio()
1.0
sage: P.set_aspect_ratio(2)
sage: P.aspect_ratio()
2.0
sage: P.set_aspect_ratio('automatic')
sage: P.aspect_ratio()
'automatic'
Set whether or not the 
and axes are shown
by default.
INPUT:
If called with no input, return the current axes setting.
EXAMPLES:
sage: L = line([(1,2), (3,-4), (2, 5), (1,2)])
By default the axes are displayed.
sage: L.axes()
True
But we turn them off, and verify that they are off
sage: L.axes(False)
sage: L.axes()
False
Displaying L now shows a triangle but no axes.
sage: L
Set the axes color.
If called with no input, return the current axes_color setting.
INPUT:
EXAMPLES: We create a line, which has like everything a default axes color of black.
sage: L = line([(1,2), (3,-4), (2, 5), (1,2)])
sage: L.axes_color()
(0, 0, 0)
We change the axes color to red and verify the change.
sage: L.axes_color((1,0,0))
sage: L.axes_color()
(1.0, 0.0, 0.0)
When we display the plot, we’ll see a blue triangle and bright red axes.
sage: L
Set the color of the axes labels.
The axes labels are placed at the edge of the x and y axes, and are not on by default (use the axes_labels command to set them; see the example below). This function just changes their color.
INPUT:
If called with no input, return the current axes_label_color setting.
EXAMPLES: We create a plot, which by default has axes label color black.
sage: p = plot(sin, (-1,1))
sage: p.axes_label_color()
(0, 0, 0)
We change the labels to be red, and confirm this:
sage: p.axes_label_color((1,0,0))
sage: p.axes_label_color()
(1.0, 0.0, 0.0)
We set labels, since otherwise we won’t see anything.
sage: p.axes_labels(['$x$ axis', '$y$ axis'])
In the plot below, notice that the labels are red:
sage: p
Set the axes labels.
INPUT:
OUTPUT: a 2-tuple of strings
If l is None, returns the current axes_labels, which is itself by default None. The default labels are both empty.
EXAMPLES: We create a plot and put x and y axes labels on it.
sage: p = plot(sin(x), (x, 0, 10))
sage: p.axes_labels(['$x$','$y$'])
sage: p.axes_labels()
('$x$', '$y$')
Now when you plot p, you see x and y axes labels:
sage: p
Notice that some may prefer axes labels which are not typeset:
sage: plot(sin(x), (x, 0, 10), axes_labels=['x','y'])
Set the ranges of the and axes.
INPUT:
EXAMPLES:
sage: L = line([(1,2), (3,-4), (2, 5), (1,2)])
sage: L.set_axes_range(-1, 20, 0, 2)
sage: d = L.get_axes_range()
sage: d['xmin'], d['xmax'], d['ymin'], d['ymax']
(-1.0, 20.0, 0.0, 2.0)
Set the axes width. Use this to draw a plot with really fat or really thin axes.
INPUT:
If called with no input, return the current axes_width setting.
EXAMPLE: We create a plot, see the default axes width (with funny Python float rounding), then reset the width to 10 (very fat).
sage: p = plot(cos, (-3,3))
sage: p.axes_width()
0.80000000000000004
sage: p.axes_width(10)
sage: p.axes_width()
10.0
Finally we plot the result, which is a graph with very fat axes.
sage: p
Set the font size of axes labels and tick marks.
INPUT:
If called with no input, return the current fontsize.
EXAMPLES:
sage: L = line([(1,2), (3,-4), (2, 5), (1,2)])
sage: L.fontsize()
10
sage: L.fontsize(20)
sage: L.fontsize()
20
All the numbers on the axes will be very large in this plot:
sage: L
Returns a dictionary of the range of the axes for this graphics object. This is fall back to the ranges in get_minmax_data() for any value which the user has not explicitly set.
Warning
Changing the dictionary returned by this function does not change the axes range for this object. To do that, use the set_axes_range() method.
EXAMPLES:
sage: L = line([(1,2), (3,-4), (2, 5), (1,2)])
sage: list(sorted(L.get_axes_range().items()))
[('xmax', 3.0), ('xmin', 1.0), ('ymax', 5.0), ('ymin', -4.0)]
sage: L.set_axes_range(xmin=-1)
sage: list(sorted(L.get_axes_range().items()))
[('xmax', 3.0), ('xmin', -1.0), ('ymax', 5.0), ('ymin', -4.0)]
Return a dictionary whose keys give the xmin, xmax, ymin, and ymax data for this graphic.
Warning
The returned dictionary is mutable, but changing it does not change the xmin/xmax/ymin/ymax data. The minmax data is a function of the primitives which make up this Graphics object. To change the range of the axes, call methods xmin(), xmax(), ymin(), ymax(), or set_axes_range().
EXAMPLES:
sage: g = line([(-1,1), (3,2)])
sage: list(sorted(g.get_minmax_data().items()))
[('xmax', 3.0), ('xmin', -1.0), ('ymax', 2.0), ('ymin', 1.0)]
Note that changing ymax doesn’t change the output of get_minmax_data:
sage: g.ymax(10)
sage: list(sorted(g.get_minmax_data().items()))
[('xmax', 3.0), ('xmin', -1.0), ('ymax', 2.0), ('ymin', 1.0)]
Set whether or not the legend is shown by default.
INPUT:
If called with no input, return the current legend setting.
EXAMPLES:
By default no legend is displayed:
sage: P = plot(sin)
sage: P.legend()
False
But if we put a label then the legend is shown:
sage: P = plot(sin, legend_label='sin')
sage: P.legend()
True
We can turn it on or off:
sage: P.legend(False)
sage: P.legend()
False
sage: P.legend(True)
sage: P # show with the legend
Return a matplotlib figure object representing the graphic
EXAMPLES:
sage: c = circle((1,1),1)
sage: print c.matplotlib()
Figure(640x480)
To obtain the first matplotlib axes object inside of the figure, you can do something like the following.
sage: p=plot(sin(x), (x, -2*pi, 2*pi))
sage: figure=p.matplotlib()
sage: axes=figure.axes[0]
For input parameters, see the documentation for the show() method (this function accepts all except the transparent argument).
TESTS:
We verify that #10291 is fixed:
sage: p = plot(sin(x), (x, -2*pi, 2*pi))
sage: figure = p.matplotlib()
sage: axes_range = p.get_axes_range()
sage: figure = p.matplotlib()
sage: axes_range2 = p.get_axes_range()
sage: axes_range == axes_range2
True
Draw a 2D plot of this graphics object, which just returns this object since this is already a 2D graphics object.
EXAMPLES:
sage: S = circle((0,0), 2)
sage: S.plot() is S
True
Returns an embedding of this 2D plot into the xy-plane of 3D space, as a 3D plot object. An optional parameter z can be given to specify the z-coordinate.
EXAMPLES:
sage: sum([plot(z*sin(x), 0, 10).plot3d(z) for z in range(6)]) # long time
Save the graphics to an image file.
INPUT:
filename – a string (default: autogenerated), the filename and the image format given by the extension, which can be one of the following:
- .eps,
- .pdf,
- .png,
- .ps,
- .sobj (for a Sage object you can load later),
- .svg,
- empty extension will be treated as .sobj.
All other keyword arguments will be passed to the plotter.
OUTPUT:
EXAMPLES:
sage: c = circle((1,1), 1, color='red')
sage: filename = os.path.join(SAGE_TMP, 'test.png')
sage: c.save(filename, xmin=-1, xmax=3, ymin=-1, ymax=3)
To make a figure bigger or smaller, use figsize:
sage: c.save(filename, figsize=5, xmin=-1, xmax=3, ymin=-1, ymax=3)
By default, the figure grows to include all of the graphics and text, so the final image may not be exactly the figure size you specified. If you want a figure to be exactly a certain size, specify the keyword fig_tight=False:
sage: c.save(filename, figsize=[8,4], fig_tight=False,
... xmin=-1, xmax=3, ymin=-1, ymax=3)
You can also pass extra options to the plot command instead of this method, e.g.
sage: plot(x^2 - 5, (x, 0, 5), ymin=0).save(
... sage.misc.misc.tmp_filename() + '.png')
will save the same plot as the one shown by this command:
sage: plot(x^2 - 5, (x, 0, 5), ymin=0)
(This test verifies that Trac #8632 is fixed.)
TESTS:
Legend labels should save correctly:
sage: P = plot(x,(x,0,1),legend_label='$xyz$')
sage: P.set_legend_options(back_color=(1,0,0))
sage: P.set_legend_options(loc=7)
sage: filename=os.path.join(SAGE_TMP, 'test.png')
sage: P.save(filename)
This plot should save with the frame shown, showing Trac #7524 is fixed (same issue as #7981 and #8632):
sage: var('x,y')
(x, y)
sage: a = plot_vector_field((x,-y),(x,-1,1),(y,-1,1))
sage: filename=os.path.join(SAGE_TMP, 'test2.png')
sage: a.save(filename)
Set the aspect ratio, which is the ratio of height and width of a unit square (i.e., height/width of a unit square), or ‘automatic’ (expand to fill the figure).
INPUT:
EXAMPLES: We create a plot of the upper half of a circle, but it doesn’t look round because the aspect ratio is off:
sage: P = plot(sqrt(1-x^2),(x,-1,1)); P
So we set the aspect ratio and now it is round:
sage: P.set_aspect_ratio(1)
sage: P.aspect_ratio()
1.0
sage: P
Note that the aspect ratio is inherited upon addition (which takes the max of aspect ratios of objects whose aspect ratio has been set):
sage: P + plot(sqrt(4-x^2),(x,-2,2))
In the following example, both plots produce a circle that looks twice as tall as wide:
sage: Q = circle((0,0), 0.5); Q.set_aspect_ratio(2)
sage: (P + Q).aspect_ratio(); P+Q
2.0
sage: (Q + P).aspect_ratio(); Q+P
2.0
Set the ranges of the and axes.
INPUT:
EXAMPLES:
sage: L = line([(1,2), (3,-4), (2, 5), (1,2)])
sage: L.set_axes_range(-1, 20, 0, 2)
sage: d = L.get_axes_range()
sage: d['xmin'], d['xmax'], d['ymin'], d['ymax']
(-1.0, 20.0, 0.0, 2.0)
Set various legend options.
INPUT:
title - (default: None) string, the legend title
ncol - (default: 1) positive integer, the number of columns
columnspacing - (default: None) the spacing between columns
borderaxespad - (default: None) float, length between the axes and the legend
back_color - (default: (0.9, 0.9, 0.9)) This parameter can be a string denoting a color or an RGB tuple. The string can be a color name as in (‘red’, ‘green’, ‘yellow’, ...) or a floating point number like ‘0.8’ which gets expanded to (0.8, 0.8, 0.8). The tuple form is just a floating point RGB tuple with all values ranging from 0 to 1.
handlelength - (default: 0.05) float, the length of the legend handles
handletextpad - (default: 0.5) float, the pad between the legend handle and text
labelspacing - (default: 0.02) float, vertical space between legend entries
integer inputs must be one of the following:
markerscale - (default: 0.6) float, how much to scale the markers in the legend.
numpoints - (default: 2) integer, the number of points in the legend for line
borderpad - (default: 0.6) float, the fractional whitespace inside the legend border (between 0 and 1)
font_family - (default: ‘sans-serif’) string, one of ‘serif’, ‘sans-serif’, ‘cursive’, ‘fantasy’, ‘monospace’
font_style - (default: ‘normal’) string, one of ‘normal’, ‘italic’, ‘oblique’
font_variant - (default: ‘normal’) string, one of ‘normal’, ‘small-caps’
font_weight - (default: ‘medium’) string, one of ‘black’, ‘extra bold’, ‘bold’, ‘semibold’, ‘medium’, ‘normal’, ‘light’
font_size - (default: ‘medium’) string, one of ‘xx-small’, ‘x-small’, ‘small’, ‘medium’, ‘large’, ‘x-large’, ‘xx-large’ or an absolute font size (e.g. 12)
shadow - (default: False) boolean - draw a shadow behind the legend
fancybox - (default: False) a boolean. If True, draws a frame with a round fancybox.
These are all keyword arguments.
OUTPUT: a dictionary of all current legend options
EXAMPLES:
By default, no options are set:
sage: p = plot(tan, legend_label='tan')
sage: p.set_legend_options()
{}
We build a legend with a shadow:
sage: p.set_legend_options(shadow=True)
sage: p.set_legend_options()['shadow']
True
To set the legend position to the center of the plot, all these methods are roughly equivalent:
sage: p.set_legend_options(loc='center'); p
sage: p.set_legend_options(loc=10); p
sage: p.set_legend_options(loc=(0.5,0.5)); p # aligns the bottom of the box to the center
Show this graphics image with the default image viewer.
OPTIONAL INPUT:
filename - (default: None) string
dpi - dots per inch
figsize - [width, height]
fig_tight - (default: True) whether to clip the drawing tightly around drawn objects. If True, then the resulting image will usually not have dimensions corresponding to figsize. If False, the resulting image will have dimensions corresponding to figsize.
aspect_ratio - the perceived height divided by the perceived width. For example, if the aspect ratio is set to 1, circles will look round and a unit square will appear to have sides of equal length, and if the aspect ratio is set 2, vertical units will be twice as long as horizontal units, so a unit square will be twice as high as it is wide. If set to 'automatic', the aspect ratio is determined by figsize and the picture fills the figure.
axes - (default: True)
axes_labels - (default: None) list (or tuple) of two strings; the first is used as the label for the horizontal axis, and the second for the vertical axis.
fontsize - (default: current setting – 10) positive integer; used for axes labels; if you make this very large, you may have to increase figsize to see all labels.
frame - (default: False) draw a frame around the image
gridlines - (default: None) can be any of the following:
gridlinesstyle, hgridlinesstyle, vgridlinesstyle - (default: None) a dictionary of MATPLOTLIB options for the rendering of the grid lines, the horizontal grid lines or the vertical grid lines, respectively.
to the produced file is returned.
transparent - (default: False) If True, make the background transparent.
axes_pad - (default: 0.02) The percentage of the axis range that is added to each end of each axis. This helps avoid problems like clipping lines because of line-width, etc. To get axes that are exactly the specified limits, set axes_pad to zero.
ticks_integer - (default: False) guarantee that the ticks are integers (the ticks option, if specified, will override this)
ticks - A matplotlib locator for the major ticks, or a number. There are several options. For more information about locators, type from matplotlib import ticker and then ticker?.
(something which can be coerced to a float), it will be
replaced by a MultipleLocator which places major ticks at
integer multiples of . See examples.tick_formatter - A matplotlib formatter for the major ticks. There are several options. For more information about formatters, type from matplotlib import ticker and then ticker?.
If the value of this keyword is a single item, then this will give the formatting for the horizontal axis only (except for the "latex" option). If it is a list or tuple, the first is for the horizontal axis, the second for the vertical axis. The options are below:
,
, or 
, ticks will be formatted nicely at rational
multiples of this constant.Warning
This should only be used with the ticks option using nice rational multiples of that constant!
show_legend - (default: None) If True, show the legend
legend_* - all the options valid for set_legend_options() prefixed with legend_
EXAMPLES:
sage: c = circle((1,1), 1, color='red')
sage: c.show(xmin=-1, xmax=3, ymin=-1, ymax=3)
You could also just make the picture larger by changing figsize:
sage: c.show(figsize=8, xmin=-1, xmax=3, ymin=-1, ymax=3)
You can turn off the drawing of the axes:
sage: show(plot(sin,-4,4), axes=False)
You can also label the axes. Putting something in dollar signs formats it as a mathematical expression:
sage: show(plot(sin,-4,4), axes_labels=('$x$','$y$'))
You can turn on the drawing of a frame around the plots:
sage: show(plot(sin,-4,4), frame=True)
You can make the background transparent:
sage: plot(sin(x), (x, -4, 4), transparent=True)
Add grid lines at the major ticks of the axes.
sage: c = circle((0,0), 1)
sage: c.show(gridlines=True)
sage: c.show(gridlines="automatic")
sage: c.show(gridlines="major")
Add grid lines at the major and minor ticks of the axes.
sage: u,v = var('u v')
sage: f = exp(-(u^2+v^2))
sage: p = plot_vector_field(f.gradient(), (u,-2,2), (v,-2,2))
sage: p.show(gridlines="minor")
Add only horizontal or vertical grid lines.
sage: p = plot(sin,-10,20)
sage: p.show(gridlines=[None, "automatic"])
sage: p.show(gridlines=["minor", False])
Add grid lines at specific positions (using lists/tuples).
sage: x, y = var('x, y')
sage: p = implicit_plot((y^2-x^2)*(x-1)*(2*x-3)-4*(x^2+y^2-2*x)^2, ... (x,-2,2), (y,-2,2), plot_points=1000)
sage: p.show(gridlines=[[1,0],[-1,0,1]])
Add grid lines at specific positions (using iterators).
sage: def maple_leaf(t):
... return (100/(100+(t-pi/2)^8))*(2-sin(7*t)-cos(30*t)/2)
sage: p = polar_plot(maple_leaf, -pi/4, 3*pi/2, color="red",plot_points=1000) # long time
sage: p.show(gridlines=( [-3,-2.75,..,3], xrange(-1,5,2) )) # long time
Add grid lines at specific positions (using functions).
sage: y = x^5 + 4*x^4 - 10*x^3 - 40*x^2 + 9*x + 36
sage: p = plot(y, -4.1, 1.1)
sage: xlines = lambda a,b: [z for z,m in y.roots()]
sage: p.show(gridlines=[xlines, [0]], frame=True, axes=False)
Change the style of all the grid lines.
sage: b = bar_chart([-3,5,-6,11], color='red')
sage: b.show(gridlines=([-1,-0.5,..,4],True),
... gridlinesstyle=dict(color="blue", linestyle=":"))
Change the style of the horizontal or vertical grid lines separately.
sage: p = polar_plot(2 + 2*cos(x), 0, 2*pi, color=hue(0.3))
sage: p.show(gridlines=True,
... hgridlinesstyle=dict(color="orange", linewidth=1.0),
... vgridlinesstyle=dict(color="blue", linestyle=":"))
Change the style of each grid line individually.
sage: x, y = var('x, y')
sage: p = implicit_plot((y^2-x^2)*(x-1)*(2*x-3)-4*(x^2+y^2-2*x)^2,
... (x,-2,2), (y,-2,2), plot_points=1000)
sage: p.show(gridlines=(
... [
... (1,{"color":"red","linestyle":":"}),
... (0,{"color":"blue","linestyle":"--"})
... ],
... [
... (-1,{"color":"red","linestyle":":"}),
... (0,{"color":"blue","linestyle":"--"}),
... (1,{"color":"red","linestyle":":"}),
... ]
... ),
... gridlinesstyle=dict(marker='x',color="black"))
Grid lines can be added to contour plots.
sage: f = sin(x^2 + y^2)*cos(x)*sin(y)
sage: c = contour_plot(f, (x, -4, 4), (y, -4, 4), plot_points=100)
sage: c.show(gridlines=True, gridlinesstyle={'linestyle':':','linewidth':1, 'color':'red'})
Grid lines can be added to matrix plots.
sage: M = MatrixSpace(QQ,10).random_element()
sage: matrix_plot(M).show(gridlines=True)
By default, Sage increases the horizontal and vertical axes limits by a certain percentage in all directions. This is controlled by the axes_pad parameter. Increasing the range of the axes helps avoid problems with lines and dots being clipped because the linewidth extends beyond the axes. To get axes limits that are exactly what is specified, set axes_pad to zero. Compare the following two examples
sage: plot(sin(x), (x, -pi, pi),thickness=2)+point((pi, -1), pointsize=15)
sage: plot(sin(x), (x, -pi, pi),thickness=2,axes_pad=0)+point((pi, -1), pointsize=15)
Via matplotlib, Sage allows setting of custom ticks. See above for more details.
sage: plot(sin(pi*x), (x, -8, 8)) # Labels not so helpful
sage: plot(sin(pi*x), (x, -8, 8), ticks=2) # Multiples of 2
sage: plot(sin(pi*x), (x, -8, 8), ticks=[[-7,-3,0,3,7],[-1/2,0,1/2]]) # Your choices
sage: plot(sin(pi*x), (x, -8, 8), ticks=[[],[]]) # No ticks at all!
This can be very helpful in showing certain features of plots.
sage: plot(1.5/(1+e^(-x)), (x, -10, 10)) # doesn't quite show value of inflection point
sage: plot(1.5/(1+e^(-x)), (x, -10, 10), ticks=[None, 1.5/4]) # It's right at f(x)=0.75!
But be careful to leave enough room for at least two major ticks, so that the user can tell what the scale is.
sage: plot(x^2,(x,1,8),ticks=6)
Traceback (most recent call last):
...
ValueError: Expand the range of the independent variable to allow two multiples of your tick locator (option `ticks`).
We can also do custom formatting if you need it. See above for full details.
sage: plot(2*x+1,(x,0,5),ticks=[[0,1,e,pi,sqrt(20)],2],tick_formatter="latex")
This is particularly useful when setting custom ticks in multiples
of .
sage: plot(sin(x),(x,0,2*pi),ticks=pi/3,tick_formatter=pi)
But keep in mind that you will get exactly the formatting you asked for if you specify both formatters. The first syntax is recommended for best style in that case.
sage: plot(arcsin(x),(x,-1,1),ticks=[None,pi/6],tick_formatter=["latex",pi]) # Nice-looking!
sage: plot(arcsin(x),(x,-1,1),ticks=[None,pi/6],tick_formatter=[None,pi]) # Not so nice-looking
Set the color of the axes tick labels.
INPUT:
If called with no input, return the current tick_label_color setting.
EXAMPLES:
sage: p = plot(cos, (-3,3))
sage: p.tick_label_color()
(0, 0, 0)
sage: p.tick_label_color((1,0,0))
sage: p.tick_label_color()
(1.0, 0.0, 0.0)
sage: p
EXAMPLES:
sage: g = line([(-1,1), (3,2)])
sage: g.xmax()
3.0
sage: g.xmax(10)
sage: g.xmax()
10.0
EXAMPLES:
sage: g = line([(-1,1), (3,2)])
sage: g.xmin()
-1.0
sage: g.xmin(-3)
sage: g.xmin()
-3.0
EXAMPLES:
sage: g = line([(-1,1), (3,2)])
sage: g.ymax()
2.0
sage: g.ymax(10)
sage: g.ymax()
10.0
EXAMPLES:
sage: g = line([(-1,1), (3,2)])
sage: g.ymin()
1.0
sage: g.ymin(-3)
sage: g.ymin()
-3.0
Bases: sage.structure.sage_object.SageObject
GraphicsArray takes a ( x 
) list of lists of
graphics objects and plots them all on one canvas.
x.__init__(...) initializes x; see x.__class__.__doc__ for signature
x.__init__(...) initializes x; see x.__class__.__doc__ for signature
x.__init__(...) initializes x; see x.__class__.__doc__ for signature
save the graphics_array to (for now) a png called ‘filename’.
Show this graphics array using the default viewer.
OPTIONAL INPUT:
EXAMPLES: This draws a graphics array with four trig plots and no axes in any of the plots.
sage: G = graphics_array([[plot(sin), plot(cos)], [plot(tan), plot(sec)]])
sage: G.show(axes=False)
This matplotlib formatter selectively omits some tick values and passes the rest on to a specified formatter.
EXAMPLES:
This example is almost straight from a matplotlib example.
sage: from sage.plot.plot import SelectiveFormatter
sage: import matplotlib.pyplot as plt
sage: import numpy
sage: fig=plt.figure()
sage: ax=fig.add_subplot(111)
sage: t = numpy.arange(0.0, 2.0, 0.01)
sage: s = numpy.sin(2*numpy.pi*t)
sage: p = ax.plot(t, s)
sage: formatter=SelectiveFormatter(ax.xaxis.get_major_formatter(),skip_values=[0,1])
sage: ax.xaxis.set_major_formatter(formatter)
sage: fig.savefig(os.path.join(SAGE_TMP, 'test.png'))
The adaptive refinement algorithm for plotting a function f. See the docstring for plot for a description of the algorithm.
INPUT:
OUTPUT:
TESTS:
sage: from sage.plot.plot import adaptive_refinement
sage: adaptive_refinement(sin, (0,0), (pi,0), adaptive_tolerance=0.01, adaptive_recursion=0)
[]
sage: adaptive_refinement(sin, (0,0), (pi,0), adaptive_tolerance=0.01)
[(0.125*pi, 0.38268343236508978), (0.1875*pi, 0.55557023301960218), (0.25*pi, 0.70710678118654746), (0.3125*pi, 0.83146961230254524), (0.375*pi, 0.92387953251128674), (0.4375*pi, 0.98078528040323043), (0.5*pi, 1.0), (0.5625*pi, 0.98078528040323043), (0.625*pi, 0.92387953251128674), (0.6875*pi, 0.83146961230254546), (0.75*pi, 0.70710678118654757), (0.8125*pi, 0.55557023301960218), (0.875*pi, 0.38268343236508989)]
This shows that lowering adaptive_tolerance and raising adaptive_recursion both increase the number of subdivision points, though which one creates more points is heavily dependent upon the function being plotted.
sage: x = var('x')
sage: f(x) = sin(1/x)
sage: n1 = len(adaptive_refinement(f, (0,0), (pi,0), adaptive_tolerance=0.01)); n1
15
sage: n2 = len(adaptive_refinement(f, (0,0), (pi,0), adaptive_recursion=10, adaptive_tolerance=0.01)); n2
79
sage: n3 = len(adaptive_refinement(f, (0,0), (pi,0), adaptive_tolerance=0.001)); n3
26
Calculate plot points for a function f in the interval xrange. The adaptive refinement algorithm is also automatically invoked with a relative adaptive tolerance of adaptive_tolerance; see below.
INPUT:
OUTPUT:
TESTS:
sage: from sage.plot.plot import generate_plot_points
sage: generate_plot_points(sin, (0, pi), plot_points=2, adaptive_recursion=0)
[(0.0, 0.0), (3.1415926535897931, 1.2246...e-16)]
sage: from sage.plot.plot import generate_plot_points
sage: generate_plot_points(lambda x: x^2, (0, 6), plot_points=2, adaptive_recursion=0, initial_points = [1,2,3])
[(0.0, 0.0), (1.0, 1.0), (2.0, 4.0), (3.0, 9.0), (6.0, 36.0)]
sage: generate_plot_points(sin(x).function(x), (-pi, pi), randomize=False)
[(-3.1415926535897931, -1.2246...e-16), (-2.748893571891069,
-0.3826834323650898...), (-2.3561944901923448, -0.707106781186547...),
(-2.1598449493429825, -0.831469612302545...), (-1.9634954084936207,
-0.92387953251128674), (-1.7671458676442586, -0.98078528040323043),
(-1.5707963267948966, -1.0), (-1.3744467859455345,
-0.98078528040323043), (-1.1780972450961724, -0.92387953251128674),
(-0.98174770424681035, -0.831469612302545...), (-0.78539816339744828,
-0.707106781186547...), (-0.39269908169872414, -0.38268343236508978),
(0.0, 0.0), (0.39269908169872414, 0.38268343236508978),
(0.78539816339744828, 0.707106781186547...), (0.98174770424681035,
0.831469612302545...), (1.1780972450961724, 0.92387953251128674),
(1.3744467859455345, 0.98078528040323043), (1.5707963267948966, 1.0),
(1.7671458676442586, 0.98078528040323043), (1.9634954084936207,
0.92387953251128674), (2.1598449493429825, 0.831469612302545...),
(2.3561944901923448, 0.707106781186547...), (2.748893571891069,
0.3826834323650898...), (3.1415926535897931, 1.2246...e-16)]
This shows that lowering adaptive_tolerance and raising adaptive_recursion both increase the number of subdivision points. (Note that which creates more points is heavily dependent on the particular function plotted.)
sage: x = var('x')
sage: f(x) = sin(1/x)
sage: [len(generate_plot_points(f, (-pi, pi), plot_points=16, adaptive_tolerance=i, randomize=False)) for i in [0.01, 0.001, 0.0001]]
[97, 161, 275]
sage: [len(generate_plot_points(f, (-pi, pi), plot_points=16, adaptive_recursion=i, randomize=False)) for i in [5, 10, 15]]
[97, 499, 2681]
graphics_array take a list of lists (or tuples) of graphics objects and plots them all on one canvas (single plot).
INPUT:
EXAMPLE: Make some plots of 
functions:
sage: f(x) = sin(x)
sage: g(x) = sin(2*x)
sage: h(x) = sin(4*x)
sage: p1 = plot(f,(-2*pi,2*pi),color=hue(0.5))
sage: p2 = plot(g,(-2*pi,2*pi),color=hue(0.9))
sage: p3 = parametric_plot((f,g),(0,2*pi),color=hue(0.6))
sage: p4 = parametric_plot((f,h),(0,2*pi),color=hue(1.0))
Now make a graphics array out of the plots; then you can type either: ga.show() or ga.save().
sage: graphics_array(((p1,p2),(p3,p4)))
Here we give only one row:
sage: p1 = plot(sin,(-4,4))
sage: p2 = plot(cos,(-4,4))
sage: g = graphics_array([p1, p2]); print g
Graphics Array of size 1 x 2
sage: g.show()
Return True if is a Graphics object.
EXAMPLES:
sage: from sage.plot.plot import is_Graphics
sage: is_Graphics(1)
False
sage: is_Graphics(disk((0.0, 0.0), 1, (0, pi/2)))
True
list_plot takes either a list of numbers, a list of tuples, or a dictionary and plots the corresponding points.
If given a list of numbers (that is, not a list of tuples or lists),
list_plot forms a list of tuples 
where 
goes from
0 to len(data)-1 and 
is the -th data value, and puts
points at those tuple values.
list_plot will plot a list of complex numbers in the obvious way; any numbers for which CC() makes sense will work.
list_plot also takes a list of tuples 
where
and 
are the -th values representing the - and
-values, respectively.
If given a dictionary, list_plot interprets the keys as
-values and the values as -values.
The plotjoined=True option tells list_plot to plot a line joining all the data.
It is possible to pass empty dictionaries, lists, or tuples to list_plot. Doing so will plot nothing (returning an empty plot).
EXAMPLES:
sage: list_plot([i^2 for i in range(5)])
Here are a bunch of random red points:
sage: r = [(random(),random()) for _ in range(20)]
sage: list_plot(r,color='red')
This gives all the random points joined in a purple line:
sage: list_plot(r, plotjoined=True, color='purple')
Plot a list of complex numbers:
sage: list_plot([1, I, pi + I/2, CC(.25, .25)])
sage: list_plot([exp(I*theta) for theta in [0, .2..pi]])
Note that if your list of complex numbers are all actually real, they get plotted as real values, so this
sage: list_plot([CDF(1), CDF(1/2), CDF(1/3)])
is the same as list_plot([1, 1/2, 1/3]) – it produces a plot of
the points 
, 
, and 
.
If you have separate lists of values and values which you
want to plot against each other, use the zip command to make a
single list whose entries are pairs of 
values, and feed
the result into list_plot:
sage: x_coords = [cos(t)^3 for t in srange(0, 2*pi, 0.02)]
sage: y_coords = [sin(t)^3 for t in srange(0, 2*pi, 0.02)]
sage: list_plot(zip(x_coords, y_coords))
If instead you try to pass the two lists as separate arguments, you will get an error message:
sage: list_plot(x_coords, y_coords)
Traceback (most recent call last):
...
TypeError: The second argument 'plotjoined' should be boolean (True or False). If you meant to plot two lists 'x' and 'y' against each other, use 'list_plot(zip(x,y))'.
Dictionaries with numeric keys and values can be plotted:
sage: list_plot({22: 3365, 27: 3295, 37: 3135, 42: 3020, 47: 2880, 52: 2735, 57: 2550})
TESTS:
We check to see that the x/y min/max data are set correctly.
sage: d = list_plot([(100,100), (120, 120)]).get_minmax_data()
sage: d['xmin']
100.0
sage: d['ymin']
100.0
Returns the minimums and maximums of xdata and ydata.
If dict is False, then minmax_data returns the tuple (xmin, xmax, ymin, ymax); otherwise, it returns a dictionary whose keys are ‘xmin’, ‘xmax’, ‘ymin’, and ‘ymax’ and whose values are the corresponding values.
EXAMPLES:
sage: from sage.plot.plot import minmax_data
sage: minmax_data([], [])
(-1, 1, -1, 1)
sage: minmax_data([-1, 2], [4, -3])
(-1, 2, -3, 4)
sage: d = minmax_data([-1, 2], [4, -3], dict=True)
sage: list(sorted(d.items()))
[('xmax', 2), ('xmin', -1), ('ymax', 4), ('ymin', -3)]
Plot a parametric curve or surface in 2d or 3d.
parametric_plot() takes two or three functions as a
list or a tuple and makes a plot with the first function giving the
coordinates, the second function giving the
coordinates, and the third function (if present) giving the
coordinates.
In the 2d case, parametric_plot() is equivalent to the plot() command with the option parametric=True. In the 3d case, parametric_plot() is equivalent to parametric_plot3d(). See each of these functions for more help and examples.
INPUT:
EXAMPLES: We draw some 2d parametric plots. Note that the default aspect ratio is 1, so that circles look like circles.
sage: t = var('t')
sage: parametric_plot( (cos(t), sin(t)), (t, 0, 2*pi))
sage: parametric_plot( (sin(t), sin(2*t)), (t, 0, 2*pi), color=hue(0.6) )
sage: parametric_plot((1, t), (t, 0, 4))
Note that in parametric_plot, there is only fill or no fill.
sage: parametric_plot((t, t^2), (t, -4, 4), fill = True)
A filled Hypotrochoid:
sage: parametric_plot([cos(x) + 2 * cos(x/4), sin(x) - 2 * sin(x/4)], (x,0, 8*pi), fill = True)
sage: parametric_plot( (5*cos(x), 5*sin(x), x), (x,-12, 12), plot_points=150, color="red")
sage: y=var('y')
sage: parametric_plot( (5*cos(x), x*y, cos(x*y)), (x, -4,4), (y,-4,4))
sage: t=var('t')
sage: parametric_plot( vector((sin(t), sin(2*t))), (t, 0, 2*pi), color='green')
sage: parametric_plot( vector([t, t+1, t^2]), (t, 0, 1))
TESTS:
sage: parametric_plot((x, t^2), (x, -4, 4))
Traceback (most recent call last):
...
ValueError: there are more variables than variable ranges
sage: parametric_plot((1, x+t), (x, -4, 4))
Traceback (most recent call last):
...
ValueError: there are more variables than variable ranges
sage: parametric_plot((-t, x+t), (x, -4, 4))
Traceback (most recent call last):
...
ValueError: there are more variables than variable ranges
sage: parametric_plot((1, x+t, y), (x, -4, 4), (t, -4, 4))
Traceback (most recent call last):
...
ValueError: there are more variables than variable ranges
sage: parametric_plot((1, x, y), 0, 4)
Traceback (most recent call last):
...
ValueError: there are more variables than variable ranges
Use plot by writing
plot(X, ...)
where 
is a Sage object (or list of Sage objects) that
either is callable and returns numbers that can be coerced to
floats, or has a plot method that returns a
GraphicPrimitive object.
There are many other specialized 2D plot commands available in Sage, such as plot_slope_field, as well as various graphics primitives like Arrow; type sage.plot.plot? for a current list.
Type plot.options for a dictionary of the default options for plots. You can change this to change the defaults for all future plots. Use plot.reset() to reset to the default options.
PLOT OPTIONS:
APPEARANCE OPTIONS:
The following options affect the appearance of
the line through the points on the graph of (these are
the same as for the line function):
INPUT:
Any MATPLOTLIB line option may also be passed in. E.g.,
The linestyle can also be prefixed with a drawing style (e.g., "steps--")
markersize - the size of the marker in points
markeredgecolor – the color of the marker edge
markerfacecolor – the color of the marker face
markeredgewidth - the size of the marker edge in points
exclude - (Default: None) values which are excluded from the plot range. Either a list of real numbers, or an equation in one variable.
FILLING OPTIONS:
Note that this function does NOT simply sample equally spaced
points between xmin and xmax. Instead it computes equally spaced
points and add small perturbations to them. This reduces the
possibility of, e.g., sampling sin only at multiples of
, which would yield a very misleading graph.
EXAMPLES: We plot the sin function:
sage: P = plot(sin, (0,10)); print P
Graphics object consisting of 1 graphics primitive
sage: len(P) # number of graphics primitives
1
sage: len(P[0]) # how many points were computed (random)
225
sage: P # render
sage: P = plot(sin, (0,10), plot_points=10); print P
Graphics object consisting of 1 graphics primitive
sage: len(P[0]) # random output
32
sage: P # render
We plot with randomize=False, which makes the initial sample points evenly spaced (hence always the same). Adaptive plotting might insert other points, however, unless adaptive_recursion=0.
sage: p=plot(1, (x,0,3), plot_points=4, randomize=False, adaptive_recursion=0)
sage: list(p[0])
[(0.0, 1.0), (1.0, 1.0), (2.0, 1.0), (3.0, 1.0)]
Some colored functions:
sage: plot(sin, 0, 10, color='purple')
sage: plot(sin, 0, 10, color='#ff00ff')
We plot several functions together by passing a list of functions as input:
sage: plot([sin(n*x) for n in [1..4]], (0, pi))
We can also build a plot step by step from an empty plot:
sage: a = plot([]); a # passing an empty list returns an empty plot (Graphics() object)
sage: a += plot(x**2); a # append another plot
sage: a += plot(x**3); a # append yet another plot
The function 
wiggles wildly near 
.
Sage adapts to this and plots extra points near the origin.
sage: plot(sin(1/x), (x, -1, 1))
Via the matplotlib library, Sage makes it easy to tell whether a graph is on both sides of both axes, as the axes only cross if the origin is actually part of the viewing area:
sage: plot(x^3,(x,0,2)) # this one has the origin
sage: plot(x^3,(x,1,2)) # this one does not
Another thing to be aware of with axis labeling is that when
the labels have quite different orders of magnitude or are very
large, scientific notation (the notation for powers of ten) is used:
sage: plot(x^2,(x,480,500)) # this one has no scientific notation
sage: plot(x^2,(x,300,500)) # this one has scientific notation on y-axis
You can put a legend with legend_label (the legend is only put once in the case of multiple functions):
sage: plot(exp(x), 0, 2, legend_label='$e^x$')
Sage understands TeX, so these all are slightly different, and you can choose one based on your needs:
sage: plot(sin, legend_label='sin')
sage: plot(sin, legend_label='$sin$')
sage: plot(sin, legend_label='$\sin$')
Note that the independent variable may be omitted if there is no ambiguity:
sage: plot(sin(1/x), (-1, 1))
The algorithm used to insert extra points is actually pretty simple. On the picture drawn by the lines below:
sage: p = plot(x^2, (-0.5, 1.4)) + line([(0,0), (1,1)], color='green')
sage: p += line([(0.5, 0.5), (0.5, 0.5^2)], color='purple')
sage: p += point(((0, 0), (0.5, 0.5), (0.5, 0.5^2), (1, 1)), color='red', pointsize=20)
sage: p += text('A', (-0.05, 0.1), color='red')
sage: p += text('B', (1.01, 1.1), color='red')
sage: p += text('C', (0.48, 0.57), color='red')
sage: p += text('D', (0.53, 0.18), color='red')
sage: p.show(axes=False, xmin=-0.5, xmax=1.4, ymin=0, ymax=2)
You have the function (in blue) and its approximation (in green) passing through the points A and B. The algorithm finds the midpoint C of AB and computes the distance between C and D. If that distance exceeds the adaptive_tolerance threshold (relative to the size of the initial plot subintervals), the point D is added to the curve. If D is added to the curve, then the algorithm is applied recursively to the points A and D, and D and B. It is repeated adaptive_recursion times (5, by default).
The actual sample points are slightly randomized, so the above plots may look slightly different each time you draw them.
We draw the graph of an elliptic curve as the union of graphs of 2 functions.
sage: def h1(x): return abs(sqrt(x^3 - 1))
sage: def h2(x): return -abs(sqrt(x^3 - 1))
sage: P = plot([h1, h2], 1,4)
sage: P # show the result
We can also directly plot the elliptic curve:
sage: E = EllipticCurve([0,-1])
sage: plot(E, (1, 4), color=hue(0.6))
We can change the line style as well:
sage: plot(sin(x), (x, 0, 10), linestyle='-.')
If we have an empty linestyle and specify a marker, we can see the points that are actually being plotted:
sage: plot(sin(x), (x,0,10), plot_points=20, linestyle='', marker='.')
The marker can be a TeX symbol as well:
sage: plot(sin(x), (x,0,10), plot_points=20, linestyle='', marker=r'$\checkmark$')
Sage currently ignores points that cannot be evaluated
sage: set_verbose(-1)
sage: plot(-x*log(x), (x,0,1)) # this works fine since the failed endpoint is just skipped.
sage: set_verbose(0)
This prints out a warning and plots where it can (we turn off the warning by setting the verbose mode temporarily to -1.)
sage: set_verbose(-1)
sage: plot(x^(1/3), (x,-1,1))
sage: set_verbose(0)
To plot the negative real cube root, use something like the following:
sage: plot(lambda x : RR(x).nth_root(3), (x,-1, 1))
We can detect the poles of a function:
sage: plot(gamma, (-3, 4), detect_poles = True).show(ymin = -5, ymax = 5)
We draw the Gamma-Function with its poles highlighted:
sage: plot(gamma, (-3, 4), detect_poles = 'show').show(ymin = -5, ymax = 5)
The basic options for filling a plot:
sage: p1 = plot(sin(x), -pi, pi, fill = 'axis')
sage: p2 = plot(sin(x), -pi, pi, fill = 'min')
sage: p3 = plot(sin(x), -pi, pi, fill = 'max')
sage: p4 = plot(sin(x), -pi, pi, fill = 0.5)
sage: graphics_array([[p1, p2], [p3, p4]]).show(frame=True, axes=False)
sage: plot([sin(x), cos(2*x)*sin(4*x)], -pi, pi, fill = {0: 1}, fillcolor = 'red', fillalpha = 1)
A example about the growth of prime numbers:
sage: plot(1.13*log(x), 1, 100, fill = lambda x: nth_prime(x)/floor(x), fillcolor = 'red')
Fill the area between a function and its asymptote:
sage: f = (2*x^3+2*x-1)/((x-2)*(x+1))
sage: plot([f, 2*x+2], -7,7, fill = {0: [1]}, fillcolor='#ccc').show(ymin=-20, ymax=20)
Fill the area between a list of functions and the x-axis:
sage: def b(n): return lambda x: bessel_J(n, x)
sage: plot([b(n) for n in [1..5]], 0, 20, fill = 'axis')
Note that to fill between the ith and jth functions, you must use dictionary key-value pairs i:[j]; key-value pairs like i:j will fill between the ith function and the line y=j:
sage: def b(n): return lambda x: bessel_J(n, x) + 0.5*(n-1)
sage: plot([b(c) for c in [1..5]], 0, 40, fill = dict([(i, [i+1]) for i in [0..3]]))
sage: plot([b(c) for c in [1..5]], 0, 40, fill = dict([(i, i+1) for i in [0..3]]))
Extra options will get passed on to show(), as long as they are valid:
sage: plot(sin(x^2), (x, -3, 3), axes_labels=['$x$','$y$']) # These labels will be nicely typeset
sage: plot(sin(x^2), (x, -3, 3), axes_labels=['x','y']) # These will not
sage: plot(sin(x^2), (x, -3, 3), figsize=[8,2])
sage: plot(sin(x^2), (x, -3, 3)).show(figsize=[8,2]) # These are equivalent
This includes options for custom ticks and formatting. See documentation for show() for more details.
sage: plot(sin(pi*x), (x, -8, 8), ticks=[[-7,-3,0,3,7],[-1/2,0,1/2]])
sage: plot(2*x+1,(x,0,5),ticks=[[0,1,e,pi,sqrt(20)],2],tick_formatter="latex")
This is particularly useful when setting custom ticks in multiples of 
.
sage: plot(sin(x),(x,0,2*pi),ticks=pi/3,tick_formatter=pi)
A example with excluded values:
sage: plot(floor(x), (x, 1, 10), exclude = [1..10])
We exclude all points where prime_pi makes a jump:
sage: jumps = [n for n in [1..100] if prime_pi(n) != prime_pi(n-1)]
sage: plot(lambda x: prime_pi(x), (x, 1, 100), exclude = jumps)
Excluded points can also be given by an equation:
sage: g(x) = x^2-2*x-2
sage: plot(1/g(x), (x, -3, 4), exclude = g(x) == 0, ymin = -5, ymax = 5)
TESTS:
We do not randomize the endpoints:
sage: p = plot(x, (x,-1,1))
sage: p[0].xdata[0] == -1
True
sage: p[0].xdata[-1] == 1
True
We check to make sure that the x/y min/max data get set correctly when there are multiple functions.
sage: d = plot([sin(x), cos(x)], 100, 120).get_minmax_data()
sage: d['xmin']
100.0
sage: d['xmax']
120.0
We check various combinations of tuples and functions, ending with tests that lambda functions work properly with explicit variable declaration, without a tuple.
sage: p = plot(lambda x: x,(x,-1,1))
sage: p = plot(lambda x: x,-1,1)
sage: p = plot(x,x,-1,1)
sage: p = plot(x,-1,1)
sage: p = plot(x^2,x,-1,1)
sage: p = plot(x^2,xmin=-1,xmax=2)
sage: p = plot(lambda x: x,x,-1,1)
sage: p = plot(lambda x: x^2,x,-1,1)
sage: p = plot(lambda x: 1/x,x,-1,1)
sage: f(x) = sin(x+3)-.1*x^3
sage: p = plot(lambda x: f(x),x,-1,1)
We check to handle cases where the function gets evaluated at a point which causes an ‘inf’ or ‘-inf’ result to be produced.
sage: p = plot(1/x, 0, 1)
sage: p = plot(-1/x, 0, 1)
Bad options now give better errors:
sage: P = plot(sin(1/x), (x,-1,3), foo=10)
Traceback (most recent call last):
...
RuntimeError: Error in line(): option 'foo' not valid.
sage: P = plot(x, (x,1,1)) # trac ticket #11753
Traceback (most recent call last):
...
ValueError: plot start point and end point must be different
We test that we can plot 
(see Trac 10246):
sage: f(x)=x; f
x |--> x
sage: plot(f,(x,-1,1))
polar_plot takes a single function or a list or tuple of functions and plots them with polar coordinates in the given domain.
This function is equivalent to the plot() command with the options polar=True and aspect_ratio=1. For more help on options, see the documentation for plot().
INPUT:
EXAMPLES:
Here is a blue 8-leaved petal:
sage: polar_plot(sin(5*x)^2, (x, 0, 2*pi), color='blue')
A red figure-8:
sage: polar_plot(abs(sqrt(1 - sin(x)^2)), (x, 0, 2*pi), color='red')
A green limacon of Pascal:
sage: polar_plot(2 + 2*cos(x), (x, 0, 2*pi), color=hue(0.3))
Several polar plots:
sage: polar_plot([2*sin(x), 2*cos(x)], (x, 0, 2*pi))
A filled spiral:
sage: polar_plot(sqrt, 0, 2 * pi, fill = True)
Fill the area between two functions:
sage: polar_plot(cos(4*x) + 1.5, 0, 2*pi, fill=0.5 * cos(4*x) + 2.5, fillcolor='orange')
Fill the area between several spirals:
sage: polar_plot([(1.2+k*0.2)*log(x) for k in range(6)], 1, 3 * pi, fill = {0: [1], 2: [3], 4: [5]})
Exclude points at discontinuities:
sage: polar_plot(log(floor(x)), (x, 1, 4*pi), exclude = [1..12])
x.__init__(...) initializes x; see x.__class__.__doc__ for signature
This function is deprecated. Please use sage.plot.misc.setup_for_eval_on_grid instead. Please note that that function has slightly different calling and return conventions which make it more generally applicable.
INPUT:
OUTPUT:
EXAMPLES:
sage: x,y = var('x,y')
sage: sage.plot.plot.setup_for_eval_on_grid([x^2 + y^2], (x,0,5), (y,0,pi), 11)
doctest:...: DeprecationWarning: sage.plot.plot.setup_for_eval_on_grid is deprecated. Please use sage.plot.misc.setup_for_eval_on_grid; note that that function has slightly different calling and return conventions which make it more generally applicable
([<sage.ext... object at ...>],
0.5,
0.31415926535897931,
(0.0, 5.0),
(0.0, 3.1415926535897931))
We always plot at least two points; one at the beginning and one at the end of the ranges.
sage: sage.plot.plot.setup_for_eval_on_grid([x^2+y^2], (x,0,1), (y,-1,1), 1)
([<sage.ext... object at ...>],
1.0,
2.0,
(0.0, 1.0),
(-1.0, 1.0))
Set the default for showing plots using any plot commands. If called with no arguments, returns the current default.
If this is True (the default) then any plot object when displayed will be displayed as an actual plot instead of text, i.e., the show command is not needed.
EXAMPLES: The default starts out as True:
sage: show_default()
True
We set it to False.
sage: show_default(False)
We see that it is False.
sage: show_default()
False
Now plot commands will not display their plots by default.
Turn back on default display.
sage: show_default(True)
Given a list or tuple or iterable v, coerce each element of v to a float and make a list out of the result.
EXAMPLES:
sage: from sage.plot.plot import to_float_list
sage: to_float_list([1,1/2,3])
[1.0, 0.5, 3.0]
INPUT:
OUTPUT:
EXAMPLES:
sage: from sage.plot.plot import var_and_list_of_values
sage: var_and_list_of_values((var('theta'), 2, 5), 5)
doctest:...: DeprecationWarning: var_and_list_of_values is deprecated. Please use sage.plot.misc.setup_for_eval_on_grid; note that that function has slightly different calling and return conventions which make it more generally applicable
(theta, [2.0, 2.75, 3.5, 4.25, 5.0])
sage: var_and_list_of_values((2, 5), 5)
(None, [2.0, 2.75, 3.5, 4.25, 5.0])
sage: var_and_list_of_values((var('theta'), 2, 5), 2)
(theta, [2.0, 5.0])
sage: var_and_list_of_values((2, 5), 2)
(None, [2.0, 5.0])
Returns two lists (xdata, ydata), each coerced to a list of floats, which correspond to the x-coordinates and the y-coordinates of the points.
The points parameter can be a list of 2-tuples or some object that yields a list of one or two numbers.
This function can potentially be very slow for large point sets.
TESTS:
sage: from sage.plot.plot import xydata_from_point_list
sage: xydata_from_point_list([CC(0), CC(1)]) # ticket 8082
([0.0, 1.0], [0.0, 0.0])
This function should work for anything than can be turned into a list, such as iterators and such (see ticket #10478):
sage: xydata_from_point_list(iter([(0,0), (sqrt(3), 2)]))
([0.0, 1.7320508075688772], [0.0, 2.0])
sage: xydata_from_point_list((x, x^2) for x in range(5))
([0.0, 1.0, 2.0, 3.0, 4.0], [0.0, 1.0, 4.0, 9.0, 16.0])
sage: xydata_from_point_list(enumerate(prime_range(1, 15)))
([0.0, 1.0, 2.0, 3.0, 4.0, 5.0], [2.0, 3.0, 5.0, 7.0, 11.0, 13.0])
sage: from itertools import izip; xydata_from_point_list(izip([2,3,5,7], [11, 13, 17, 19]))
([2.0, 3.0, 5.0, 7.0], [11.0, 13.0, 17.0, 19.0])