\hSrSSKJr SSKJr SSKJr SSKJrJ r SSK J r J r J r SSKJr SSKJr SS KJr SS KJr SS KJr SS KJrJrJrJrJrJr SS KJ r J!r! SSK"J#r# SSK$J%r% SSKJ&r& SSKJ'r' SSKJ(r( SSKJ)r) SSKJ*r* SSKJ+r+ SSKJ,r, SSKJ-r- SSKJ.r. SSKJ/r/ SSKJ0r0 SSK1J2r2 S/S/S.r3Sr4Sr5S r6S!r7S"r8\\S#.r9S$S%.S&jr:S$S%.S'jr;S$S%.S(jrS$S%.S+jr?S$S%.S,jr@S-rAg.)/aPlotting module for SymPy. A plot is represented by the ``Plot`` class that contains a reference to the backend and a list of the data series to be plotted. The data series are instances of classes meant to simplify getting points and meshes from SymPy expressions. ``plot_backends`` is a dictionary with all the backends. This module gives only the essential. For all the fancy stuff use directly the backend. You can get the backend wrapper for every plot from the ``_backend`` attribute. Moreover the data series classes have various useful methods like ``get_points``, ``get_meshes``, etc, that may be useful if you wish to use another plotting library. Especially if you need publication ready graphs and this module is not enough for you - just get the ``_backend`` attribute and add whatever you want directly to it. In the case of matplotlib (the common way to graph data in python) just copy ``_backend.fig`` which is the figure and ``_backend.ax`` which is the axis and work on them as you would on any other matplotlib object. Simplicity of code takes much greater importance than performance. Do not use it if you care at all about performance. A new backend instance is initialized every time you call ``show()`` and the old one is left to the garbage collector. )Sum)Tuple)Expr)Function AppliedUndef)DummySymbolWild) import_module)sign)Plot)MatplotlibBackend) TextBackend)LineOver1DRangeSeriesParametric2DLineSeriesParametric3DLineSeriesParametricSurfaceSeriesSurfaceOver2DRangeSeries ContourSeries)_check_arguments _plot_sympify)Indexed)PlotGrid) BaseSeries)Line2DBaseSeries)Line3DBaseSeries)SurfaceBaseSeries) List2DSeries)GenericDataSeries)centers_of_faces)centers_of_segments)flat) unset_show)_matplotlib_list)textplot matplotlib))plot3dplot3d_parametric_lineplot3d_parametric_surfaceplot_parametric)plotcbSn[U5nUSn[SSS/S9n[URU55Hkn[UR5n[ U5H+upxUS:dM USU"USU5U"USU54Xg'M- [ U6n UR XY5nMm X1S'U$) aSubstitute oo (infinity) in the lower/upper bounds of a summation with some integer number. Parameters ========== sum_bound : int oo will be substituted with this integer number. *args : list/tuple pre-processed arguments of the form (expr, range, ...) Notes ===== Let's consider the following summation: ``Sum(1 / x**2, (x, 1, oo))``. The current implementation of lambdify (SymPy 1.12 at the time of writing this) will create something of this form: ``sum(1 / x**2 for x in range(1, INF))`` The problem is that ``type(INF)`` is float, while ``range`` requires integers: the evaluation fails. Instead of modifying ``lambdify`` (which requires a deep knowledge), just replace it with some integer number. crUR(aUR(aU$[U5S:aU$U*$)Nr) is_number is_finiter )tbounds K/var/www/auris/envauris/lib/python3.13/site-packages/sympy/plotting/plot.py new_bound&_process_summations..new_boundZs+  H 7a<Lv rwc"[U[5$N) isinstancerr0s r2%_process_summations..fs *Q$r5cL[S[UR555$)Nc3# UH>upUS:dM USR(+=(d USR(+v M@ g7f)rN)r/).0ias r2 8_process_summations....gs>jO`tqdehidiB1Q4>>)B1Q4>>/ABO`s A6A)any enumerateargsr:s r2r;r<gs#jyYZY_Y_O`jjr5) propertiesr?r@)listr findrHrGrsubs) sum_boundrHr3exprr6r0 sums_argsrBrCss r2_process_summationsrQCs. :D 7D S$j A $))A, L i(DA1u !!i!i&@adI. 0 ) Oyy G Kr5c/n[URSS55nUHXnUupVpxUR5n UbXS'[U5(d [ U/UQ76nUR [ USS0U D65 MZ U$)zKLoop over the provided arguments and create the necessary line series. rMiN rendering_kw)intgetcopycallablerQappendr) rHkwargsseriesrMargrNrlabelrSkws r2_build_line_seriesr`vsFFJJ{D12I'*$ [[]  #!-~ ~~%i6#6C +S"X<<= Mr5c /nUH;nUR5nUSbUSUS'URU"USS0UD65 M= U$)zgExtract the rendering_kw dictionary from the provided arguments and create an appropriate data series. rTNrS)rWrY) series_type plot_exprrZr[rHr_s r2_create_seriesrdsYF [[] 8 !%bB~  k49334  Mr5c[U[[45(dU/n[U5S:a[U5S:Xa[U5S:aU[U5-n[U5[U5:wa$[ S[U5S[U5S35e[ X5H up4XClM U(a[U[5(aU/n[U5S:XaU[U5-nO<[U5[U5:wa$[ S[U5S[U5S35e[ X5H up5XSlM gg)zJApply the `label` and `rendering_kw` keyword arguments to the series. rr?zXThe number of labels must be equal to the number of expressions being plotted. Received z expressions and z labelszhThe number of rendering dictionaries must be equal to the number of expressions being plotted. Received N) r9rJtuplelen ValueErrorzipr^dictrS)r[labelsrSrPlr]s r2 _set_labelsrms9 ftUm , , 6{Q v;! F a c&k !F v;#f+ %Bv;-0V WFG G'DAG( lD ) )(>L |  ! CK 'L [C - -Ov;-0V WFG G-DAN.r5cJURSS5n[U[5(aBUS:Xa-[SS[4S9nU(a [ U0UD6$[ U0UD6$[U"U0UD6$[U5[:Xa[U[5(aU"U0UD6$[S5e)Nbackenddefaultr&z1.1.0)min_module_versioncatchz:backend must be either a string or a subclass of ``Plot``.) popr9strr RuntimeErrorrr plot_backendstype issubclassr TypeError)rHrZror&s r2 plot_factoryrzsjjI.G'3 i &|#*%>'''TUUr5)r&textT)showc[U5n[USS40UD6nURSS5n[5nUH@n[ USS[ 5(d XVSS1-nM+U[ USS51-nMB U(aURUR55nU(aUR5O [ S5nURSU5 URS[S5"U55 URS /5nURS S5n [U0UD6n [XU 5 [U 0UD6n U(aU R5 U $) aPlots a function of a single variable as a curve. Parameters ========== args : The first argument is the expression representing the function of single variable to be plotted. The last argument is a 3-tuple denoting the range of the free variable. e.g. ``(x, 0, 5)`` Typical usage examples are in the following: - Plotting a single expression with a single range. ``plot(expr, range, **kwargs)`` - Plotting a single expression with the default range (-10, 10). ``plot(expr, **kwargs)`` - Plotting multiple expressions with a single range. ``plot(expr1, expr2, ..., range, **kwargs)`` - Plotting multiple expressions with multiple ranges. ``plot((expr1, range1), (expr2, range2), ..., **kwargs)`` It is best practice to specify range explicitly because default range may change in the future if a more advanced default range detection algorithm is implemented. show : bool, optional The default value is set to ``True``. Set show to ``False`` and the function will not display the plot. The returned instance of the ``Plot`` class can then be used to save or display the plot by calling the ``save()`` and ``show()`` methods respectively. line_color : string, or float, or function, optional Specifies the color for the plot. See ``Plot`` to see how to set color for the plots. Note that by setting ``line_color``, it would be applied simultaneously to all the series. title : str, optional Title of the plot. It is set to the latex representation of the expression, if the plot has only one expression. label : str, optional The label of the expression in the plot. It will be used when called with ``legend``. Default is the name of the expression. e.g. ``sin(x)`` xlabel : str or expression, optional Label for the x-axis. ylabel : str or expression, optional Label for the y-axis. xscale : 'linear' or 'log', optional Sets the scaling of the x-axis. yscale : 'linear' or 'log', optional Sets the scaling of the y-axis. axis_center : (float, float), optional Tuple of two floats denoting the coordinates of the center or {'center', 'auto'} xlim : (float, float), optional Denotes the x-axis limits, ``(min, max)```. ylim : (float, float), optional Denotes the y-axis limits, ``(min, max)```. annotations : list, optional A list of dictionaries specifying the type of annotation required. The keys in the dictionary should be equivalent to the arguments of the :external:mod:`matplotlib`'s :external:meth:`~matplotlib.axes.Axes.annotate` method. markers : list, optional A list of dictionaries specifying the type the markers required. The keys in the dictionary should be equivalent to the arguments of the :external:mod:`matplotlib`'s :external:func:`~matplotlib.pyplot.plot()` function along with the marker related keyworded arguments. rectangles : list, optional A list of dictionaries specifying the dimensions of the rectangles to be plotted. The keys in the dictionary should be equivalent to the arguments of the :external:mod:`matplotlib`'s :external:class:`~matplotlib.patches.Rectangle` class. fill : dict, optional A dictionary specifying the type of color filling required in the plot. The keys in the dictionary should be equivalent to the arguments of the :external:mod:`matplotlib`'s :external:meth:`~matplotlib.axes.Axes.fill_between` method. adaptive : bool, optional The default value for the ``adaptive`` parameter is now ``False``. To enable adaptive sampling, set ``adaptive=True`` and specify ``n`` if uniform sampling is required. The plotting uses an adaptive algorithm which samples recursively to accurately plot. The adaptive algorithm uses a random point near the midpoint of two points that has to be further sampled. Hence the same plots can appear slightly different. depth : int, optional Recursion depth of the adaptive algorithm. A depth of value `n` samples a maximum of `2^{n}` points. If the ``adaptive`` flag is set to ``False``, this will be ignored. n : int, optional Used when the ``adaptive`` is set to ``False``. The function is uniformly sampled at ``n`` number of points. If the ``adaptive`` flag is set to ``True``, this will be ignored. This keyword argument replaces ``nb_of_points``, which should be considered deprecated. size : (float, float), optional A tuple in the form (width, height) in inches to specify the size of the overall figure. The default value is set to ``None``, meaning the size will be set by the default backend. Examples ======== .. plot:: :context: close-figs :format: doctest :include-source: True >>> from sympy import symbols >>> from sympy.plotting import plot >>> x = symbols('x') Single Plot .. plot:: :context: close-figs :format: doctest :include-source: True >>> plot(x**2, (x, -5, 5)) Plot object containing: [0]: cartesian line: x**2 for x over (-5.0, 5.0) Multiple plots with single range. .. plot:: :context: close-figs :format: doctest :include-source: True >>> plot(x, x**2, x**3, (x, -5, 5)) Plot object containing: [0]: cartesian line: x for x over (-5.0, 5.0) [1]: cartesian line: x**2 for x over (-5.0, 5.0) [2]: cartesian line: x**3 for x over (-5.0, 5.0) Multiple plots with different ranges. .. plot:: :context: close-figs :format: doctest :include-source: True >>> plot((x**2, (x, -6, 6)), (x, (x, -5, 5))) Plot object containing: [0]: cartesian line: x**2 for x over (-6.0, 6.0) [1]: cartesian line: x for x over (-5.0, 5.0) No adaptive sampling by default. If adaptive sampling is required, set ``adaptive=True``. .. plot:: :context: close-figs :format: doctest :include-source: True >>> plot(x**2, adaptive=True, n=400) Plot object containing: [0]: cartesian line: x**2 for x over (-10.0, 10.0) See Also ======== Plot, LineOver1DRangeSeries r?paramsNrxxlabelylabelfr^rS)rrrVsetr9rtr differencekeysrs setdefaultrr`rmrzr|) r|rHrZrcr~freeprrkrSr[plotss r2r+r+s1z  D q!6v6I ZZ$ 'F 5D !A$q'3'' qT!WI D VAaDG_% %D  v{{}- s A h" h a 01 ZZ $F::nd3L  5f 5F - & +F +E  Lr5c[U5n[USS40UD6nURS/5nURSS5n[[U40UD6n[ XdU5 [ U0UD6nU(aUR5 U$)a Plots a 2D parametric curve. Parameters ========== args Common specifications are: - Plotting a single parametric curve with a range ``plot_parametric((expr_x, expr_y), range)`` - Plotting multiple parametric curves with the same range ``plot_parametric((expr_x, expr_y), ..., range)`` - Plotting multiple parametric curves with different ranges ``plot_parametric((expr_x, expr_y, range), ...)`` ``expr_x`` is the expression representing $x$ component of the parametric function. ``expr_y`` is the expression representing $y$ component of the parametric function. ``range`` is a 3-tuple denoting the parameter symbol, start and stop. For example, ``(u, 0, 5)``. If the range is not specified, then a default range of (-10, 10) is used. However, if the arguments are specified as ``(expr_x, expr_y, range), ...``, you must specify the ranges for each expressions manually. Default range may change in the future if a more advanced algorithm is implemented. adaptive : bool, optional Specifies whether to use the adaptive sampling or not. The default value is set to ``True``. Set adaptive to ``False`` and specify ``n`` if uniform sampling is required. depth : int, optional The recursion depth of the adaptive algorithm. A depth of value $n$ samples a maximum of $2^n$ points. n : int, optional Used when the ``adaptive`` flag is set to ``False``. Specifies the number of the points used for the uniform sampling. This keyword argument replaces ``nb_of_points``, which should be considered deprecated. line_color : string, or float, or function, optional Specifies the color for the plot. See ``Plot`` to see how to set color for the plots. Note that by setting ``line_color``, it would be applied simultaneously to all the series. label : str, optional The label of the expression in the plot. It will be used when called with ``legend``. Default is the name of the expression. e.g. ``sin(x)`` xlabel : str, optional Label for the x-axis. ylabel : str, optional Label for the y-axis. xscale : 'linear' or 'log', optional Sets the scaling of the x-axis. yscale : 'linear' or 'log', optional Sets the scaling of the y-axis. axis_center : (float, float), optional Tuple of two floats denoting the coordinates of the center or {'center', 'auto'} xlim : (float, float), optional Denotes the x-axis limits, ``(min, max)```. ylim : (float, float), optional Denotes the y-axis limits, ``(min, max)```. size : (float, float), optional A tuple in the form (width, height) in inches to specify the size of the overall figure. The default value is set to ``None``, meaning the size will be set by the default backend. Examples ======== .. plot:: :context: reset :format: doctest :include-source: True >>> from sympy import plot_parametric, symbols, cos, sin >>> u = symbols('u') A parametric plot with a single expression: .. plot:: :context: close-figs :format: doctest :include-source: True >>> plot_parametric((cos(u), sin(u)), (u, -5, 5)) Plot object containing: [0]: parametric cartesian line: (cos(u), sin(u)) for u over (-5.0, 5.0) A parametric plot with multiple expressions with the same range: .. plot:: :context: close-figs :format: doctest :include-source: True >>> plot_parametric((cos(u), sin(u)), (u, cos(u)), (u, -10, 10)) Plot object containing: [0]: parametric cartesian line: (cos(u), sin(u)) for u over (-10.0, 10.0) [1]: parametric cartesian line: (u, cos(u)) for u over (-10.0, 10.0) A parametric plot with multiple expressions with different ranges for each curve: .. plot:: :context: close-figs :format: doctest :include-source: True >>> plot_parametric((cos(u), sin(u), (u, -5, 5)), ... (cos(u), u, (u, -5, 5))) Plot object containing: [0]: parametric cartesian line: (cos(u), sin(u)) for u over (-5.0, 5.0) [1]: parametric cartesian line: (cos(u), u) for u over (-5.0, 5.0) Notes ===== The plotting uses an adaptive algorithm which samples recursively to accurately plot the curve. The adaptive algorithm uses a random point near the midpoint of two points that has to be further sampled. Hence, repeating the same plot command can give slightly different results because of the random sampling. If there are multiple plots, then the same optional arguments are applied to all the plots drawn in the same canvas. If you want to set these options separately, you can index the returned ``Plot`` object and set it. For example, when you specify ``line_color`` once, it would be applied simultaneously to both series. .. plot:: :context: close-figs :format: doctest :include-source: True >>> from sympy import pi >>> expr1 = (u, cos(2*pi*u)/2 + 1/2) >>> expr2 = (u, sin(2*pi*u)/2 + 1/2) >>> p = plot_parametric(expr1, expr2, (u, 0, 1), line_color='blue') If you want to specify the line color for the specific series, you should index each item and apply the property manually. .. plot:: :context: close-figs :format: doctest :include-source: True >>> p[0].line_color = 'red' >>> p.show() See Also ======== Plot, Parametric2DLineSeries r@r?r^rSN)rrrsrdrrmrzr|r|rHrZrcrkrSr[rs r2r*r*s~j  D q!6v6I ZZ $F::nd3L 2I H HF - & +F +E  Lr5cj[U5n[USS40UD6nURSS5 URSS5 URSS5 URS /5nURS S 5n[ [ U40UD6n[ XdU5 [U0UD6nU(aUR5 U$) a Plots a 3D parametric line plot. Usage ===== Single plot: ``plot3d_parametric_line(expr_x, expr_y, expr_z, range, **kwargs)`` If the range is not specified, then a default range of (-10, 10) is used. Multiple plots. ``plot3d_parametric_line((expr_x, expr_y, expr_z, range), ..., **kwargs)`` Ranges have to be specified for every expression. Default range may change in the future if a more advanced default range detection algorithm is implemented. Arguments ========= expr_x : Expression representing the function along x. expr_y : Expression representing the function along y. expr_z : Expression representing the function along z. range : (:class:`~.Symbol`, float, float) A 3-tuple denoting the range of the parameter variable, e.g., (u, 0, 5). Keyword Arguments ================= Arguments for ``Parametric3DLineSeries`` class. n : int The range is uniformly sampled at ``n`` number of points. This keyword argument replaces ``nb_of_points``, which should be considered deprecated. Aesthetics: line_color : string, or float, or function, optional Specifies the color for the plot. See ``Plot`` to see how to set color for the plots. Note that by setting ``line_color``, it would be applied simultaneously to all the series. label : str The label to the plot. It will be used when called with ``legend=True`` to denote the function with the given label in the plot. If there are multiple plots, then the same series arguments are applied to all the plots. If you want to set these options separately, you can index the returned ``Plot`` object and set it. Arguments for ``Plot`` class. title : str Title of the plot. size : (float, float), optional A tuple in the form (width, height) in inches to specify the size of the overall figure. The default value is set to ``None``, meaning the size will be set by the default backend. Examples ======== .. plot:: :context: reset :format: doctest :include-source: True >>> from sympy import symbols, cos, sin >>> from sympy.plotting import plot3d_parametric_line >>> u = symbols('u') Single plot. .. plot:: :context: close-figs :format: doctest :include-source: True >>> plot3d_parametric_line(cos(u), sin(u), u, (u, -5, 5)) Plot object containing: [0]: 3D parametric cartesian line: (cos(u), sin(u), u) for u over (-5.0, 5.0) Multiple plots. .. plot:: :context: close-figs :format: doctest :include-source: True >>> plot3d_parametric_line((cos(u), sin(u), u, (u, -5, 5)), ... (sin(u), u**2, u, (u, -5, 5))) Plot object containing: [0]: 3D parametric cartesian line: (cos(u), sin(u), u) for u over (-5.0, 5.0) [1]: 3D parametric cartesian line: (sin(u), u**2, u) for u over (-5.0, 5.0) See Also ======== Plot, Parametric3DLineSeries r?rrryzlabelzr^rSN) rrrrsrdrrmrzr|rs r2r(r(jsd  D q!6v6I h$ h$ h$ ZZ $F::nd3L 2I H HF - & +F +E  Lr5cSSKJn [U5n[USS40UD6n[ 5n[ 5n[ U[ [4nUHmnU[USSU5(a USS1O[ USS51-nU[USSU5(a USS1O[ USS51-nMo U(aUR5O [ S5n U(aUR5O [ S5n URSU 5 URSU 5 URS [S 5"X55 URS S 5(a0[US5(aS US'[US5(aS US'URS/5n URSS5n [X40UD6n [XU 5 [!U 0UD6nURSS5(aUR#5 U$)zRplot3d and plot_contour are structurally identical. Let's reduce code repetition. r) BaseScalarr?r@rrrrrris_polarFr^rSNr|T) sympy.vectorrrrrr rrr9rsrrrVrXrdrmrzr|)SeriesrHrZrrcfree_xfree_y_typesrrrrkrSr[rs r2_plot3d_plot_contour_helperrs (  D q!6v6I UF UFj'< 8F z!A$q'6::1Q47)!Q@QQz!A$q'6::1Q47)!Q@QQ F3KA F3KA h" h" h a 34zz*e$$ F8$ % %!F8  F8$ % %!F8  ZZ $F::nd3L F 8 8F - & +F +E zz&$ Lr5cLURSU5 [[/UQ70UD6$)a Plots a 3D surface plot. Usage ===== Single plot ``plot3d(expr, range_x, range_y, **kwargs)`` If the ranges are not specified, then a default range of (-10, 10) is used. Multiple plot with the same range. ``plot3d(expr1, expr2, range_x, range_y, **kwargs)`` If the ranges are not specified, then a default range of (-10, 10) is used. Multiple plots with different ranges. ``plot3d((expr1, range_x, range_y), (expr2, range_x, range_y), ..., **kwargs)`` Ranges have to be specified for every expression. Default range may change in the future if a more advanced default range detection algorithm is implemented. Arguments ========= expr : Expression representing the function along x. range_x : (:class:`~.Symbol`, float, float) A 3-tuple denoting the range of the x variable, e.g. (x, 0, 5). range_y : (:class:`~.Symbol`, float, float) A 3-tuple denoting the range of the y variable, e.g. (y, 0, 5). Keyword Arguments ================= Arguments for ``SurfaceOver2DRangeSeries`` class: n1 : int The x range is sampled uniformly at ``n1`` of points. This keyword argument replaces ``nb_of_points_x``, which should be considered deprecated. n2 : int The y range is sampled uniformly at ``n2`` of points. This keyword argument replaces ``nb_of_points_y``, which should be considered deprecated. Aesthetics: surface_color : Function which returns a float Specifies the color for the surface of the plot. See :class:`~.Plot` for more details. If there are multiple plots, then the same series arguments are applied to all the plots. If you want to set these options separately, you can index the returned ``Plot`` object and set it. Arguments for ``Plot`` class: title : str Title of the plot. size : (float, float), optional A tuple in the form (width, height) in inches to specify the size of the overall figure. The default value is set to ``None``, meaning the size will be set by the default backend. Examples ======== .. plot:: :context: reset :format: doctest :include-source: True >>> from sympy import symbols >>> from sympy.plotting import plot3d >>> x, y = symbols('x y') Single plot .. plot:: :context: close-figs :format: doctest :include-source: True >>> plot3d(x*y, (x, -5, 5), (y, -5, 5)) Plot object containing: [0]: cartesian surface: x*y for x over (-5.0, 5.0) and y over (-5.0, 5.0) Multiple plots with same range .. plot:: :context: close-figs :format: doctest :include-source: True >>> plot3d(x*y, -x*y, (x, -5, 5), (y, -5, 5)) Plot object containing: [0]: cartesian surface: x*y for x over (-5.0, 5.0) and y over (-5.0, 5.0) [1]: cartesian surface: -x*y for x over (-5.0, 5.0) and y over (-5.0, 5.0) Multiple plots with different ranges. .. plot:: :context: close-figs :format: doctest :include-source: True >>> plot3d((x**2 + y**2, (x, -5, 5), (y, -5, 5)), ... (x*y, (x, -3, 3), (y, -3, 3))) Plot object containing: [0]: cartesian surface: x**2 + y**2 for x over (-5.0, 5.0) and y over (-5.0, 5.0) [1]: cartesian surface: x*y for x over (-3.0, 3.0) and y over (-3.0, 3.0) See Also ======== Plot, SurfaceOver2DRangeSeries r|)rrrr|rHrZs r2r'r's5F fd# &  3#' 3+1 33r5cj[U5n[USS40UD6nURSS5 URSS5 URSS5 URS /5nURS S 5n[ [ U40UD6n[ XdU5 [U0UD6nU(aUR5 U$) a4 Plots a 3D parametric surface plot. Explanation =========== Single plot. ``plot3d_parametric_surface(expr_x, expr_y, expr_z, range_u, range_v, **kwargs)`` If the ranges is not specified, then a default range of (-10, 10) is used. Multiple plots. ``plot3d_parametric_surface((expr_x, expr_y, expr_z, range_u, range_v), ..., **kwargs)`` Ranges have to be specified for every expression. Default range may change in the future if a more advanced default range detection algorithm is implemented. Arguments ========= expr_x : Expression representing the function along ``x``. expr_y : Expression representing the function along ``y``. expr_z : Expression representing the function along ``z``. range_u : (:class:`~.Symbol`, float, float) A 3-tuple denoting the range of the u variable, e.g. (u, 0, 5). range_v : (:class:`~.Symbol`, float, float) A 3-tuple denoting the range of the v variable, e.g. (v, 0, 5). Keyword Arguments ================= Arguments for ``ParametricSurfaceSeries`` class: n1 : int The ``u`` range is sampled uniformly at ``n1`` of points. This keyword argument replaces ``nb_of_points_u``, which should be considered deprecated. n2 : int The ``v`` range is sampled uniformly at ``n2`` of points. This keyword argument replaces ``nb_of_points_v``, which should be considered deprecated. Aesthetics: surface_color : Function which returns a float Specifies the color for the surface of the plot. See :class:`~Plot` for more details. If there are multiple plots, then the same series arguments are applied for all the plots. If you want to set these options separately, you can index the returned ``Plot`` object and set it. Arguments for ``Plot`` class: title : str Title of the plot. size : (float, float), optional A tuple in the form (width, height) in inches to specify the size of the overall figure. The default value is set to ``None``, meaning the size will be set by the default backend. Examples ======== .. plot:: :context: reset :format: doctest :include-source: True >>> from sympy import symbols, cos, sin >>> from sympy.plotting import plot3d_parametric_surface >>> u, v = symbols('u v') Single plot. .. plot:: :context: close-figs :format: doctest :include-source: True >>> plot3d_parametric_surface(cos(u + v), sin(u - v), u - v, ... (u, -5, 5), (v, -5, 5)) Plot object containing: [0]: parametric cartesian surface: (cos(u + v), sin(u - v), u - v) for u over (-5.0, 5.0) and v over (-5.0, 5.0) See Also ======== Plot, ParametricSurfaceSeries rr@rrrrrrr^rSN) rrrrsrdrrmrzr|rs r2r)r)sR  D q!6v6I h$ h$ h$ ZZ $F::nd3L 3Y I& IF - & +F +E  Lr5cLURSU5 [[/UQ70UD6$)a Draws contour plot of a function Usage ===== Single plot ``plot_contour(expr, range_x, range_y, **kwargs)`` If the ranges are not specified, then a default range of (-10, 10) is used. Multiple plot with the same range. ``plot_contour(expr1, expr2, range_x, range_y, **kwargs)`` If the ranges are not specified, then a default range of (-10, 10) is used. Multiple plots with different ranges. ``plot_contour((expr1, range_x, range_y), (expr2, range_x, range_y), ..., **kwargs)`` Ranges have to be specified for every expression. Default range may change in the future if a more advanced default range detection algorithm is implemented. Arguments ========= expr : Expression representing the function along x. range_x : (:class:`Symbol`, float, float) A 3-tuple denoting the range of the x variable, e.g. (x, 0, 5). range_y : (:class:`Symbol`, float, float) A 3-tuple denoting the range of the y variable, e.g. (y, 0, 5). Keyword Arguments ================= Arguments for ``ContourSeries`` class: n1 : int The x range is sampled uniformly at ``n1`` of points. This keyword argument replaces ``nb_of_points_x``, which should be considered deprecated. n2 : int The y range is sampled uniformly at ``n2`` of points. This keyword argument replaces ``nb_of_points_y``, which should be considered deprecated. Aesthetics: surface_color : Function which returns a float Specifies the color for the surface of the plot. See :class:`sympy.plotting.Plot` for more details. If there are multiple plots, then the same series arguments are applied to all the plots. If you want to set these options separately, you can index the returned ``Plot`` object and set it. Arguments for ``Plot`` class: title : str Title of the plot. size : (float, float), optional A tuple in the form (width, height) in inches to specify the size of the overall figure. The default value is set to ``None``, meaning the size will be set by the default backend. See Also ======== Plot, ContourSeries r|)rrrrs r2 plot_contourrs*` fd# &} Ft Fv FFr5c U(d/$US:Ga`[US[5(GaG[U5U:a [S5e[ [U55Hn[X[ 5(dM O [U5S-n[ USU6n[ [5R"UVs/sHoURPM sn65n[U5X-:XaU[ XS6-/nU$[ SS5n/n UH n U R[ U 5U-5 M" [ [U5U- 5H(nU R[ [55U-5 M* U[ U 6-/nU$[US[5(d3[US[ 5(Ga[US5U:XGaUS:wGa[ [U55HUn[X[ 5(a[X5U:wa O:[X[ 5(aMF[ X5X'MW [U5S-nUSUn[SU55(de[ [5R"UV Vs/sHn U HnURPM M snn 65n[U5U:a[S U-5e[U5X2-:XaC[X[ 5(a,[ [ UX3U-56n UV s/sHoU -PM nn U$[ SS5n/n UH n U R[ U 5U-5 M" [ U[U5- 5H(nU R[ [55U-5 M* [ U 6n UV s/sHoU -PM nn U$[US[ 5(a[US5X-:XaUHn [ U5H3n[X[5(aM[S [X5-5e [ U5H3n[XU-5S:XaM[S [XU-5-5e M U$ggs snfs snn fs sn fs sn f) a Checks the arguments and converts into tuples of the form (exprs, ranges). Examples ======== .. plot:: :context: reset :format: doctest :include-source: True >>> from sympy import cos, sin, symbols >>> from sympy.plotting.plot import check_arguments >>> x = symbols('x') >>> check_arguments([cos(x), sin(x)], 2, 1) [(cos(x), sin(x), (x, -10, 10))] >>> check_arguments([x, x**2], 1, 1) [(x, (x, -10, 10)), (x**2, (x, -10, 10))] r?rz*len(args) should not be less than expr_lenNi rc3T# UHoHn[U[5v M M g7fr8)r9r)rArNes r2rD"check_arguments..s#G54$Q:a&&$&5s&(z?The number of free_symbols in the expression is greater than %dz Expected an expression, given %sz0The ranges should be a tuple of length 3, got %s)r9rrgrhrangerrJrunion free_symbolsrYrallrt) rHexpr_lennb_of_free_symbolsrBexprsrrr default_rangerangessymbolrNr\s r2check_argumentsrks3,  !| 47D11 t9x IJ Js4y!A$'5))"D A AtBQx CEKK%)H%Q..%)HIJ t95 5UDO445E "#rNMF& eFmm;<'3|,/AAB eEGn}<=CUF^+,E $q'4  ZQ%?%?%(a\X%=%-]s4y!A$'5))c$'lh.Fdgu--. " D A ARaG5GGGGGCEKKU*7UT15A+,..15+9U*789  | 1 124FGH H t9. .:dgu3M3MD!33"567F/45utF]uE5L"#rNMF& eFmm;<'-L0AAB eEGn}<=CF^F/45utF]uE5L DGU # #DG 8U(UC8_!#&$//$%G%([&122%-.38|,-2$&8:=ch,>O:P&QRR/  )V #o*I>*766s.Q 3 Q$;Q*Q/N)B__doc__sympy.concrete.summationsrsympy.core.containersrsympy.core.exprrsympy.core.functionrrsympy.core.symbolrr r sympy.externalr sympy.functionsr $sympy.plotting.backends.base_backendr )sympy.plotting.backends.matplotlibbackendr#sympy.plotting.backends.textbackendrsympy.plotting.seriesrrrrrrsympy.plotting.utilsrrsympy.tensor.indexedrsympy.plotting.plotgridrrrrrrrr r!r"r#r$sympy.plotting.textplotr%__doctest_requires__rQr`rdrmrzrvr+r*r(rr'r)rrr5r2rs0*' 633( 5G;FFA(,,223.325&;F,'~0f" @ V"$  Tn!%@F(,@F&RE3P+/wr"QGhgr5