SharedInteractiveOrbit.sagewsOpen in CoCalc
InteractiveCobweb
def cobweb(fcn, seed, iterations = 20, xmin = 0, xmax = 1):
    basic_plot = plot(fcn, xmin = xmin, xmax = xmax)
    id_plot = plot( x, xmin = xmin, xmax = xmax, aspect_ratio=1)
    iter_list = [seed,0]
    oldx = seed
    for i in range(0,iterations):
        newx = fcn(oldx)
        iter_list.append([oldx,newx])
        iter_list.append([newx,newx])
        oldx = newx
        cobweb =   line(iter_list, rgbcolor = (1,0,0))   \
            + points(iter_list,rgbcolor=(0.2,0, 0), pointsize=20) 
    return  cobweb + basic_plot + id_plot
var('x')
@interact
def cobwebber(f_text = input_box(default = "3.8*x*(1-x)",label = "function", type=str), \
              seed = slider(-0,1,.01,.5, label = 'seed'), \
              its = slider([2^i for i in range(0,12)],default = 16, label="iterations")):
    def f(x):
        return eval(f_text)
    show(cobweb(f, seed, iterations = its))
x
Interact: please open in CoCalc
def cobweb(fcn, seed, mask = 2, iterations = 20, xmin = -2, xmax = 2):
    basic_plot = plot(fcn, xmin = xmin, xmax = xmax)
    id_plot = plot( x, xmin = xmin, xmax = xmax, aspect_ratio=1)
    iter_list = [[seed,0]]
    iter_list1 = []
    iter_list2 = []
    oldx = seed
    for i in range(mask):
        newx = fcn(oldx)
        iter_list.append([oldx,newx])
        iter_list.append([newx,newx])
        oldx = newx
    for i in range(mask, iterations):
        newx = fcn(oldx)
        iter_list.append([oldx,newx])
        iter_list.append([newx,newx])
        iter_list1.append([oldx,newx])
        iter_list2.append([newx,newx])
        oldx = newx
        cobweb =  line(iter_list, rgbcolor = (1,0,0)) \
            + points(iter_list1,rgbcolor=(0.2,0, 0), pointsize=20) \
            + points(iter_list2,rgbcolor=(0,0.6, 0.1), pointsize=20)
    return  cobweb + basic_plot + id_plot
var('x')
@interact
def cobwebber(f_text = input_box(default = "x**2-1.75",label = "function", type=str), \
              seed = slider(-2,2,.01,-.5, label = 'seed'), \
              mask = slider([2**i for i in range(0,8)], default = 0, label = "mask"), \
              its = slider([2**i for i in range(0,12)],default = 16, label="iterations")):
    def f(x):
        return eval(f_text)
    show(cobweb(f, seed, iterations = its))
def cobweb(fcn, seed, mask = 2, iterations = 20, xmin = 0, xmax = 1):
    basic_plot = plot(fcn, xmin = xmin, xmax = xmax)
    id_plot = plot( x, xmin = xmin, xmax = xmax, aspect_ratio=1)
    iter_list_mask = [[seed,0]]
    iter_list = []
    iter_list1 = []
    iter_list2 = []
    oldx = seed
    for i in range(mask):
        newx = fcn(oldx)
        iter_list_mask.append([oldx,newx])
        iter_list_mask.append([newx,newx])
        oldx = newx
    newx = fcn(oldx); iter_list_mask.append([oldx,newx])
    for i in range(0,iterations):
        newx = fcn(oldx)
        iter_list.append([oldx,newx])
        iter_list.append([newx,newx])
        iter_list1.append([oldx,newx])
        iter_list2.append([newx,newx])
        oldx = newx
        cobweb =  line(iter_list_mask, linestyle = 'dashed', rgbcolor = (0,1,0)) \
            + line(iter_list, rgbcolor = (1,0,0))   \
            + points(iter_list1,rgbcolor=(0.2,0, 0), pointsize=20) \
            + points(iter_list2,rgbcolor=(0,0.6, 0.1), pointsize=20)
    return  cobweb + basic_plot + id_plot
# var('x')
@interact
def cobwebber(f_text = input_box(default = "3.8*x*(1-x)",label = "function", type=str), \
              seed = slider(0,1,.01,.5, label = 'seed'), \
              xmin = slider(0,1,.01,0, label = 'min x value'), \
              xmax = slider(0,1,.01,1, label = 'max x value'), \
              mask = slider([2^i for i in range(0,10)], default = 0, label = 'mask'), \
              its = slider([2^i for i in range(0,12)],default = 16, label="iterations")):
    def f(x):
        return eval(f_text)
    show(cobweb(f, seed, iterations = its, xmin, xmax))

File: /ext/sage/sage-8.1/local/lib/python2.7/site-packages/sage/misc/decorators.py
Signature : plot(funcs, exclude=None, fillalpha=0.5, detect_poles=False, plot_points=200, thickness=1, adaptive_tolerance=0.01, fillcolor='automatic', adaptive_recursion=5, aspect_ratio='automatic', alpha=1, legend_label=None, fill=False, *args, **kwds)
Docstring :
Use plot by writing

"plot(X, ...)"

where X 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:

* "plot_points" - (default: 200) the minimal number of plot
  points.

* "adaptive_recursion" - (default: 5) how many levels of
  recursion to go before giving up when doing adaptive refinement.
  Setting this to 0 disables adaptive refinement.

* "adaptive_tolerance" - (default: 0.01) how large a difference
  should be before the adaptive refinement code considers it
  significant.  See the documentation further below for more
  information, starting at "the algorithm used to insert".

* "base" - (default: 10) the base of the logarithm if a
  logarithmic scale is set. This must be greater than 1. The base
  can be also given as a list or tuple "(basex, basey)". "basex"
  sets the base of the logarithm along the horizontal axis and
  "basey" sets the base along the vertical axis.

* "scale" -- (default: ""linear"") string. The scale of the axes.
  Possible values are ""linear"", ""loglog"", ""semilogx"",
  ""semilogy"".

  The scale can be also be given as single argument that is a list
  or tuple "(scale, base)" or "(scale, basex, basey)".

  The ""loglog"" scale sets both the horizontal and vertical axes
  to logarithmic scale. The ""semilogx"" scale sets the horizontal
  axis to logarithmic scale. The ""semilogy"" scale sets the
  vertical axis to logarithmic scale. The ""linear"" scale is the
  default value when "Graphics" is initialized.

* "xmin" - starting x value in the rendered figure. This
  parameter is passed directly to the "show" procedure and it could
  be overwritten.

* "xmax" - ending x value in the rendered figure. This parameter
  is passed directly to the "show" procedure and it could be
  overwritten.

* "ymin" - starting y value in the rendered figure. This
  parameter is passed directly to the "show" procedure and it could
  be overwritten.

* "ymax" - ending y value in the rendered figure. This parameter
  is passed directly to the "show" procedure and it could be
  overwritten.

* "detect_poles" - (Default: False) If set to True poles are
  detected. If set to "show" vertical asymptotes are drawn.

* "legend_label" - a (TeX) string serving as the label for X in
  the legend. If X is a list, then this option can be a single
  string, or a list or dictionary with strings as entries/values.
  If a dictionary, then keys are taken from "range(len(X))".

Note:

  * If the "scale" is ""linear"", then irrespective of what
    "base" is set to, it will default to 10 and will remain unused.

  * If you want to limit the plot along the horizontal axis in
    the final rendered figure, then pass the "xmin" and "xmax"
    keywords to the "show()" method. To limit the plot along the
    vertical axis, "ymin" and "ymax" keywords can be provided to
    either this "plot" command or to the "show" command.

  * This function does NOT simply sample equally spaced points
    between xmin and xmax. Instead it computes equally spaced
    points and adds small perturbations to them. This reduces the
    possibility of, e.g., sampling sin only at multiples of 2pi,
    which would yield a very misleading graph.

  * If there is a range of consecutive points where the function
    has no value, then those points will be excluded from the plot.
    See the example below on automatic exclusion of points.

  * For the other keyword options that the "plot" function can
    take, refer to the method "show()" and the further options
    below.

COLOR OPTIONS:

* "color" - (Default: 'blue') One of:

  * an RGB tuple (r,g,b) with each of r,g,b between 0 and 1.

  * a color name as a string (e.g., 'purple').

  * an HTML color such as '#aaff0b'.

  * a list or dictionary of colors (valid only if X is a list):
    if a dictionary, keys are taken from "range(len(X))"; the
    entries/values of the list/dictionary may be any of the options
    above.

  * 'automatic' -- maps to default ('blue') if X is a single Sage
    object; and maps to a fixed sequence of regularly spaced colors
    if X is a list.

* "legend_color" - the color of the text for X (or each item in
  X) in the legend.

     Default color is 'black'. Options are as in "color" above,
     except that the choice 'automatic' maps to 'black' if X is a
     single Sage object.

* "fillcolor" - The color of the fill for the plot of X (or each
  item in X).

     Default color is 'gray' if X is a single Sage object or if
     "color" is a single color. Otherwise, options are as in
     "color" above.

APPEARANCE OPTIONS:

The following options affect the appearance of the line through the
points on the graph of X (these are the same as for the line
function):

INPUT:

* "alpha" - How transparent the line is

* "thickness" - How thick the line is

* "rgbcolor" - The color as an RGB tuple

* "hue" - The color given as a hue

LINE OPTIONS:

Any MATPLOTLIB line option may also be passed in.  E.g.,

* "linestyle" - (default: "-") The style of the line, which is
  one of

  * ""-"" or ""solid""

  * ""--"" or ""dashed""

  * ""-."" or ""dash dot""

  * "":"" or ""dotted""

  * ""None"" or "" "" or """" (nothing)

  * a list or dictionary (see below)

  The linestyle can also be prefixed with a drawing style (e.g.,
  ""steps--"")

  * ""default"" (connect the points with straight lines)

  * ""steps"" or ""steps-pre"" (step function; horizontal line is
    to the left of point)

  * ""steps-mid"" (step function; points are in the middle of
    horizontal lines)

  * ""steps-post"" (step function; horizontal line is to the
    right of point)

  If X is a list, then "linestyle" may be a list (with entries
  taken from the strings above) or a dictionary (with keys in
  "range(len(X))" and values taken from the strings above).

* "marker"  - The style of the markers, which is one of

  * ""None"" or "" "" or """" (nothing) -- default

  * "","" (pixel), ""."" (point)

  * ""_"" (horizontal line), ""|"" (vertical line)

  * ""o"" (circle), ""p"" (pentagon), ""s"" (square), ""x"" (x),
    ""+"" (plus), ""*"" (star)

  * ""D"" (diamond), ""d"" (thin diamond)

  * ""H"" (hexagon), ""h"" (alternative hexagon)

  * ""<"" (triangle left), "">"" (triangle right), ""^""
    (triangle up), ""v"" (triangle down)

  * ""1"" (tri down), ""2"" (tri up), ""3"" (tri left), ""4""
    (tri right)

  * "0" (tick left), "1" (tick right), "2" (tick up), "3" (tick
    down)

  * "4" (caret left), "5" (caret right), "6" (caret up), "7"
    (caret down), "8" (octagon)

  * ""$...$"" (math TeX string)

  * "(numsides, style, angle)" to create a custom, regular symbol

    * "numsides" -- the number of sides

    * "style" -- "0" (regular polygon), "1" (star shape), "2"
      (asterisk), "3" (circle)

    * "angle" -- the angular rotation in degrees

* "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:

* "fill" - (Default: False) One of:

  * "axis" or True: Fill the area between the function and the
    x-axis.

  * "min": Fill the area between the function and its minimal
    value.

  * "max": Fill the area between the function and its maximal
    value.

  * a number c: Fill the area between the function and the
    horizontal line y = c.

  * a function g: Fill the area between the function that is
    plotted and g.

  * a dictionary "d" (only if a list of functions are plotted):
    The keys of the dictionary should be integers. The value of
    "d[i]" specifies the fill options for the i-th function in the
    list. If "d[i] == [j]": Fill the area between the i-th and the
    j-th function in the list.  (But if "d[i] == j": Fill the area
    between the i-th function in the list and the horizontal line y
    = j.)

* "fillalpha" - (default: 0.5) How transparent the fill is. A
  number between 0 and 1.

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
   Graphics object consisting of 1 graphics primitive

   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
   Graphics object consisting of 1 graphics primitive

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')
   Graphics object consisting of 1 graphics primitive

   sage: plot(sin, 0, 10, color='#ff00ff')
   Graphics object consisting of 1 graphics primitive

We plot several functions together by passing a list of functions
as input:

   sage: plot([x*exp(-n*x^2)/.4 for n in [1..5]], (0, 2), aspect_ratio=.8)
   Graphics object consisting of 5 graphics primitives

By default, color will change from one primitive to the next. This
may be controlled by modifying "color" option:

   sage: g1 = plot([x*exp(-n*x^2)/.4 for n in [1..3]], (0, 2), color='blue', aspect_ratio=.8); g1
   Graphics object consisting of 3 graphics primitives
   sage: g2 = plot([x*exp(-n*x^2)/.4 for n in [1..3]], (0, 2), color=['red','red','green'], linestyle=['-','--','-.'], aspect_ratio=.8); g2
   Graphics object consisting of 3 graphics primitives

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)
   Graphics object consisting of 0 graphics primitives
   sage: a += plot(x**2); a    # append another plot
   Graphics object consisting of 1 graphics primitive

   sage: a += plot(x**3); a    # append yet another plot
   Graphics object consisting of 2 graphics primitives

The function sin(1/x) wiggles wildly near 0. Sage adapts to this
and plots extra points near the origin.

   sage: plot(sin(1/x), (x, -1, 1))
   Graphics object consisting of 1 graphics primitive

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
   Graphics object consisting of 1 graphics primitive

   sage: plot(x^3,(x,1,2))  # this one does not
   Graphics object consisting of 1 graphics primitive

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 e notation for powers of ten) is used:

   sage: plot(x^2,(x,480,500))  # this one has no scientific notation
   Graphics object consisting of 1 graphics primitive

   sage: plot(x^2,(x,300,500))  # this one has scientific notation on y-axis
   Graphics object consisting of 1 graphics primitive

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$')
   Graphics object consisting of 1 graphics primitive

Sage understands TeX, so these all are slightly different, and you
can choose one based on your needs:

   sage: plot(sin, legend_label='sin')
   Graphics object consisting of 1 graphics primitive

   sage: plot(sin, legend_label='$sin$')
   Graphics object consisting of 1 graphics primitive

   sage: plot(sin, legend_label='$sin$')
   Graphics object consisting of 1 graphics primitive

It is possible to use a different color for the text of each label:

   sage: p1 = plot(sin, legend_label='sin', legend_color='red')
   sage: p2 = plot(cos, legend_label='cos', legend_color='green')
   sage: p1 + p2
   Graphics object consisting of 2 graphics primitives

Prior to https://trac.sagemath.org/19485, legends by default had a
shadowless gray background. This behavior can be recovered by
setting the legend options on your plot object:

   sage: p = plot(sin(x), legend_label='$sin(x)$')
   sage: p.set_legend_options(back_color=(0.9,0.9,0.9), shadow=False)

If X is a list of Sage objects and "legend_label" is 'automatic',
then Sage will create labels for each function according to their
internal representation:

   sage: plot([sin(x), tan(x), 1-x^2], legend_label='automatic')
   Graphics object consisting of 3 graphics primitives

If "legend_label" is any single string other than 'automatic', then
it is repeated for all members of X:

   sage: plot([sin(x), tan(x)], color='blue', legend_label='trig')
   Graphics object consisting of 2 graphics primitives

Note that the independent variable may be omitted if there is no
ambiguity:

   sage: plot(sin(1.0/x), (-1, 1))
   Graphics object consisting of 1 graphics primitive

Plotting in logarithmic scale is possible for 2D plots.  There are
two different syntaxes supported:

   sage: plot(exp, (1, 10), scale='semilogy') # log axis on vertical
   Graphics object consisting of 1 graphics primitive

   sage: plot_semilogy(exp, (1, 10)) # same thing
   Graphics object consisting of 1 graphics primitive

   sage: plot_loglog(exp, (1, 10))   # both axes are log
   Graphics object consisting of 1 graphics primitive

   sage: plot(exp, (1, 10), scale='loglog', base=2) # long time # base of log is 2
   Graphics object consisting of 1 graphics primitive

We can also change the scale of the axes in the graphics just
before displaying:

   sage: G = plot(exp, 1, 10) # long time
   sage: G.show(scale=('semilogy', 2)) # long time

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
   Graphics object consisting of 2 graphics primitives

It is important to mention that when we draw several graphs at the
same time, parameters "xmin", "xmax", "ymin" and "ymax" are just
passed directly to the "show" procedure. In fact, these parameters
would be overwritten:

   sage: p=plot(x^3, x, xmin=-1, xmax=1,ymin=-1, ymax=1)
   sage: q=plot(exp(x), x, xmin=-2, xmax=2, ymin=0, ymax=4)
   sage: (p+q).show()

As a workaround, we can perform the trick:

   sage: p1 = line([(a,b) for a,b in zip(p[0].xdata,p[0].ydata) if (b>=-1 and b<=1)])
   sage: q1 = line([(a,b) for a,b in zip(q[0].xdata,q[0].ydata) if (b>=0 and b<=4)])
   sage: (p1+q1).show()

We can also directly plot the elliptic curve:

   sage: E = EllipticCurve([0,-1])
   sage: plot(E, (1, 4), color=hue(0.6))
   Graphics object consisting of 1 graphics primitive

We can change the line style as well:

   sage: plot(sin(x), (x, 0, 10), linestyle='-.')
   Graphics object consisting of 1 graphics primitive

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='.')
   Graphics object consisting of 1 graphics primitive

The marker can be a TeX symbol as well:

   sage: plot(sin(x), (x,0,10), plot_points=20, linestyle='', marker=r'$checkmark$')
   Graphics object consisting of 1 graphics primitive

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.
   Graphics object consisting of 1 graphics primitive
   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))
   Graphics object consisting of 1 graphics primitive
   sage: set_verbose(0)

Plotting the real cube root function for negative input requires
avoiding the complex numbers one would usually get. The easiest way
is to use absolute value:

   sage: plot(sign(x)*abs(x)^(1/3), (x,-1,1))
   Graphics object consisting of 1 graphics primitive

We can also use the following:

   sage: plot(sign(x)*(x*sign(x))^(1/3), (x,-4,4))
   Graphics object consisting of 1 graphics primitive

A way that points to how to plot other functions without symbolic
variants is using lambda functions:

   sage: plot(lambda x : RR(x).nth_root(3), (x,-1, 1))
   Graphics object consisting of 1 graphics primitive

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', fillalpha=1)
   sage: p3 = plot(sin(x), -pi, pi, fill='max')
   sage: p4 = plot(sin(x), -pi, pi, fill=(1-x)/3, fillcolor='blue', fillalpha=.2)
   sage: graphics_array([[p1, p2], [p3, p4]]).show(frame=True, axes=False) # long time

The basic options for filling a list of plots:

   sage: (f1, f2) = x*exp(-1*x^2)/.35, x*exp(-2*x^2)/.35
   sage: p1 = plot([f1, f2], -pi, pi, fill={1: [0]}, fillcolor='blue', fillalpha=.25, color='blue')
   sage: p2 = plot([f1, f2], -pi, pi, fill={0: x/3, 1:[0]}, color=['blue'])
   sage: p3 = plot([f1, f2], -pi, pi, fill=[0, [0]], fillcolor=['orange','red'], fillalpha=1, color={1: 'blue'})
   sage: p4 = plot([f1, f2], (x,-pi, pi), fill=[x/3, 0], fillcolor=['grey'], color=['red', 'blue'])
   sage: graphics_array([[p1, p2], [p3, p4]]).show(frame=True, axes=False) # long time

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')
   Graphics object consisting of 2 graphics primitives

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')
   Graphics object consisting of 10 graphics primitives

Note that to fill between the ith and jth functions, you must use
the dictionary key-value syntax "i:[j]"; using 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, 20, fill={i:[i-1] for i in [1..4]}, color={i:'blue' for i in [1..5]}, aspect_ratio=3, ymax=3);
   Graphics object consisting of 9 graphics primitives
   sage: plot([b(c) for c in [1..5]], 0, 20, fill={i:i-1 for i in [1..4]}, color='blue', aspect_ratio=3) # long time
   Graphics object consisting of 9 graphics primitives

Extra options will get passed on to "show()", as long as they are
valid:

   sage: plot(sin(x^2), (x, -3, 3), title='Plot of $sin(x^2)$', axes_labels=['$x$','$y$']) # These labels will be nicely typeset
   Graphics object consisting of 1 graphics primitive

   sage: plot(sin(x^2), (x, -3, 3), title='Plot of sin(x^2)', axes_labels=['x','y']) # These will not
   Graphics object consisting of 1 graphics primitive

   sage: plot(sin(x^2), (x, -3, 3), axes_labels=['x','y'], axes_labels_size=2.5) # Large axes labels (w.r.t. the tick marks)
   Graphics object consisting of 1 graphics primitive

   sage: plot(sin(x^2), (x, -3, 3), figsize=[8,2])
   Graphics object consisting of 1 graphics primitive
   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]])
   Graphics object consisting of 1 graphics primitive

   sage: plot(2*x+1,(x,0,5),ticks=[[0,1,e,pi,sqrt(20)],2],tick_formatter="latex")
   Graphics object consisting of 1 graphics primitive

This is particularly useful when setting custom ticks in multiples
of pi.

   sage: plot(sin(x),(x,0,2*pi),ticks=pi/3,tick_formatter=pi)
   Graphics object consisting of 1 graphics primitive

You can even have custom tick labels along with custom positioning.

   sage: plot(x**2, (x,0,3), ticks=[[1,2.5],[0.5,1,2]], tick_formatter=[["$x_1$","$x_2$"],["$y_1$","$y_2$","$y_3$"]])
   Graphics object consisting of 1 graphics primitive

You can force Type 1 fonts in your figures by providing the
relevant option as shown below. This also requires that LaTeX,
dvipng and Ghostscript be installed:

   sage: plot(x, typeset='type1') # optional - latex
   Graphics object consisting of 1 graphics primitive

A example with excluded values:

   sage: plot(floor(x), (x, 1, 10), exclude=[1..10])
   Graphics object consisting of 11 graphics primitives

We exclude all points where "PrimePi" 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)
   Graphics object consisting of 26 graphics primitives

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) # long time
   Graphics object consisting of 3 graphics primitives

"exclude" and "detect_poles" can be used together:

   sage: f(x) = (floor(x)+0.5) / (1-(x-0.5)^2)
   sage: plot(f, (x, -3.5, 3.5), detect_poles='show', exclude=[-3..3], ymin=-5, ymax=5)
   Graphics object consisting of 12 graphics primitives

Regions in which the plot has no values are automatically excluded.
The regions thus excluded are in addition to the exclusion points
present in the "exclude" keyword argument.:

   sage: set_verbose(-1)
   sage: plot(arcsec, (x, -2, 2))  # [-1, 1] is excluded automatically
   Graphics object consisting of 2 graphics primitives

   sage: plot(arcsec, (x, -2, 2), exclude=[1.5])  # x=1.5 is also excluded
   Graphics object consisting of 3 graphics primitives

   sage: plot(arcsec(x/2), -2, 2)  # plot should be empty; no valid points
   Graphics object consisting of 0 graphics primitives
   sage: plot(sqrt(x^2-1), -2, 2)  # [-1, 1] is excluded automatically
   Graphics object consisting of 2 graphics primitives

   sage: plot(arccsc, -2, 2)       # [-1, 1] is excluded automatically
   Graphics object consisting of 2 graphics primitives
   sage: set_verbose(0)

   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 f(x)=x (see
https://trac.sagemath.org/10246):

   sage: f(x)=x; f
   x |--> x
   sage: plot(f,(x,-1,1))
   Graphics object consisting of 1 graphics primitive

Check that https://trac.sagemath.org/15030 is fixed:

   sage: plot(abs(log(x)), x)
   Graphics object consisting of 1 graphics primitive

Check that if excluded points are less than xmin then the exclusion
still works for polar and parametric plots. The following should
show two excluded points:

   sage: set_verbose(-1)
   sage: polar_plot(sin(sqrt(x^2-1)), (x,0,2*pi), exclude=[1/2,2,3])
   Graphics object consisting of 3 graphics primitives

   sage: parametric_plot((sqrt(x^2-1),sqrt(x^2-1/2)), (x,0,5), exclude=[1,2,3])
   Graphics object consisting of 3 graphics primitives

   sage: set_verbose(0)

Legends can contain variables with long names,
https://trac.sagemath.org/13543:

   sage: hello = var('hello')
   sage: label = '$' + latex(hello) + '$'
   sage: plot(x, x, 0, 1, legend_label=label)
   Graphics object consisting of 1 graphics primitive

Extra keywords should be saved if object has a plot method,
https://trac.sagemath.org/20924:

   sage: G = graphs.PetersenGraph()
   sage: p = G.plot()
   sage: p.aspect_ratio()
   1.0
   sage: pp = plot(G)
   sage: pp.aspect_ratio()
   1.0