Soit l'équation différentielle du premier ordre avec condition initiale $\begin{array}{ccl} y'(x) &= &f(x,y)\\ y(x_0) & = &y_0 \end{array}$

Si les fonctions $f(x,y)$ et $\frac{\partial f}{\partial y} f(x,y)$ sont continues dans un rectangle contenant $(x_0,y_0)$ en son intérieur, alors il esiste un réel $\delta > 0$ et une fonction $y(x)$ ayant une dérivée continue dans $]x_0-\delta,\ x_0 + \delta[$ qui satisfait l'équation (et la condition initiale donnée) sur $]x_0-\delta,\ x_0 + \delta[$

Considérons le problème à valeur initiale

(Share server only supports KaTeX; open in CoCalc to see this formula.)

Les courbes solution de l'Équation différentielle, sans conditions initiale sont données par $y^2 - 2y = x^3 + 2x^2+2x+c$, $c$ étant une constante (c'est une équation à variables séparables). Si on tient compte de la condition initiale on trouve $c=3$.

- Cette relation definit deux fonctions $y = 1 \pm \sqrt{x^3+2x^2+2x+4}$ tant que $x>-2$ (pour que l'expression sous la racine soit positive)
- Noter qu'une seule des deux fonctions satisfait à la condition initiale donnée (avec le signe $-$).

On considère maintenant la condition initiale $y(0)=1$

- On peut résoudre comme avant (séparation des variables)
- Cette fois on a bel et bien
**deux**solutions. - Remarquons que sur la droite $y=1$, la fonction $f(x,y)$ n'est pas continue, il n'y a donc pas de contradiciton au théorème d'existence unicité.

var('y,x') f(y) = (3*x^2 + 4 *x + 2)/(2*(y-1)) courbes = [implicit_plot(y^2 - 2*y == x^3 +2*x^2 +2*x +k , (x,-3,3),(y,-3,3), color='grey') for k in sxrange(-20,20,2) ] Sol = implicit_plot(y^2 - 2*y == x^3 +2*x^2 +2*x +3 , (x,-3,3),(y,-3,3), color='red') Sol2= implicit_plot(y^2 - 2*y == x^3 +2*x^2 +2*x -1 , (x,-3,3),(y,-3,3), color='green') show(sum(courbes)+Sol+Sol2, figsize=6, aspect_ratio=1, axes_labels=['$x$','$y(x)$'], axes = True)

(y, x)

On considère maintenant la problème

(Share server only supports KaTeX; open in CoCalc to see this formula.)

Il se trouve que **toute** fonction de la forme
\[y_a(x) = \left{\begin{array}{ll}0 & \text{ pour } 0\leqslant x

Encore une fois, la fonction $f(x,y)= y^{1/3}$ ne vérifie pas les conditions du théorème lorsque $y_0 = 0$. Par contre, si $y_0 \ne 0$, on voit bien l'unicité de la solution.

︠88a8b7cb-fdef-4b6e-ba64-f02c867c50fbs︠ var('y,x') f(x,y) = sign(y)*abs(y)^(1/3) Champ = plot_slope_field(f(x,y), (x, 0, 2), (y, -1, 1)) Courbes0 = [plot(0,(x,0,k), color="red", thickness=2) for k in sxrange(0.3,2,0.2) ] Courbes1 = [plot(((2/3)*(x-k))^(3/2), (x,k,2), color="red", thickness=2) for k in sxrange(0.2,2,0.2) ] Courbes2 = [plot(-((2/3)*(x-k))^(3/2), (x,k,2), color="red", thickness=2) for k in sxrange(0.2,2,0.2) ] show(Champ + sum(Courbes0) +sum(Courbes1) + sum(Courbes2),ymin=-1, ymax=1,figsize=8)

(y, x)

xrange?

File: Unable to read docstring (source code not available)

plot?

File: /projects/sage/sage-6.9/local/lib/python2.7/site-packages/sage/misc/decorators.py Signature : plot(funcs, exclude=None, fillalpha=0.5, fillcolor='automatic', detect_poles=False, plot_points=200, thickness=1, adaptive_tolerance=0.01, rgbcolor=(0, 0, 1), 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. * "color" - an RGB tuple (r,g,b) with each of r,g,b between 0 and 1, or a color name as a string (e.g., 'purple'), or an HTML color such as '#aaff0b'. * "detect_poles" - (Default: False) If set to True poles are detected. If set to "show" vertical asymptotes are drawn. * "legend_color" - the color of the text for this item in the legend * "legend_label" - the label for this item in the legend 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. * For the other keyword options that the "plot" function can take, refer to the method "show()". 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 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) 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) * "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.) * "fillcolor" - (default: 'automatic') The color of the fill. Either 'automatic' or a color. * "fillalpha" - (default: 0.5) How transparent the fill is. A number between 0 and 1. Note: * 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. 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([sin(n*x) for n in [1..4]], (0, pi)) Graphics object consisting of 4 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 Note that the independent variable may be omitted if there is no ambiguity: sage: plot(sin(1/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') 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) # long time sage: plot([sin(x), cos(2*x)*sin(4*x)], -pi, pi, fill = {0: 1}, fillcolor = 'red', fillalpha = 1) Graphics object consisting of 3 graphics primitives 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 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]])) Graphics object consisting of 9 graphics primitives sage: plot([b(c) for c in [1..5]], 0, 40, fill = dict([(i, i+1) for i in [0..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 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) 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 f(x)=x (see http://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 http://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)

(-8)^(1/3).n()

1.00000000000000 + 1.73205080756888*I