\h?:`SSKJrJr SSKJr SSKJr SS/0rSqSr Sr S r "S S 5r g ) ) BaseSeriesGenericDataSeriessympy_deprecation_warning) is_sequence)z Plot.appendz Plot.extend matplotlibTcSqg)z' Disable show(). For use in the tests. FN)_show\/var/www/auris/envauris/lib/python3.13/site-packages/sympy/plotting/backends/base_backend.py unset_showrs Er c*[SUSUS3SSSS9 g)NzThe `z` property is deprecated. The `z` keyword argument should be passed to a plotting function, which generates the appropriate data series. If needed, index the plot object to retrieve a specific data series.z1.13z.deprecated-markers-annotations-fill-rectangles)deprecated_since_versionactive_deprecations_target stacklevelr)attrs r _deprecation_msg_m_a_r_frs- v4TF;+ +"(#Sr c /SQn/nUHknURU/5nUc/n[U[5(aU/nUH3nURS/5nUR[ U/UQ70UD65 M5 Mm U$)N) annotationsmarkersfill rectanglesargs)pop isinstancedictappendr)kwargskeywordsserieskw dictionariesdrs r _create_generic_data_seriesr&"s?H Fzz"b)  L lD ) )(>LA55$D MM+B;;; <  Mr cr\rSrSrSrSSSSSSSSSSSSSSSSSSS SS .S jr\S 5r\S 5rSr Sr Sr Sr Sr SrSrSrSr\S5r\R&S5r\S5r\R&S5r\S5r\R&S5r\S5r\R&S5rSrg) Plot1aBase class for all backends. A backend represents the plotting library, which implements the necessary functionalities in order to use SymPy plotting functions. For interactive work the function :func:`plot` is better suited. This class permits the plotting of SymPy expressions using numerous backends (:external:mod:`matplotlib`, textplot, the old pyglet module for SymPy, Google charts api, etc). The figure can contain an arbitrary number of plots of SymPy expressions, lists of coordinates of points, etc. Plot has a private attribute _series that contains all data series to be plotted (expressions for lines or surfaces, lists of points, etc (all subclasses of BaseSeries)). Those data series are instances of classes not imported by ``from sympy import *``. The customization of the figure is on two levels. Global options that concern the figure as a whole (e.g. title, xlabel, scale, etc) and per-data series options (e.g. name) and aesthetics (e.g. color, point shape, line type, etc.). The difference between options and aesthetics is that an aesthetic can be a function of the coordinates (or parameters in a parametric plot). The supported values for an aesthetic are: - None (the backend uses default values) - a constant - a function of one variable (the first coordinate or parameter) - a function of two variables (the first and second coordinate or parameters) - a function of three variables (only in nonparametric 3D plots) Their implementation depends on the backend so they may not work in some backends. If the plot is parametric and the arity of the aesthetic function permits it the aesthetic is calculated over parameters and not over coordinates. If the arity does not permit calculation over parameters the calculation is done over coordinates. Only cartesian coordinates are supported for the moment, but you can use the parametric plots to plot in polar, spherical and cylindrical coordinates. The arguments for the constructor Plot must be subclasses of BaseSeries. Any global option can be specified as a keyword argument. The global options for a figure are: - title : str - xlabel : str or Symbol - ylabel : str or Symbol - zlabel : str or Symbol - legend : bool - xscale : {'linear', 'log'} - yscale : {'linear', 'log'} - axis : bool - axis_center : tuple of two floats or {'center', 'auto'} - xlim : tuple of two floats - ylim : tuple of two floats - aspect_ratio : tuple of two floats or {'auto'} - autoscale : bool - margin : float in [0, 1] - backend : {'default', 'matplotlib', 'text'} or a subclass of BaseBackend - size : optional tuple of two floats, (width, height); default: None The per data series options and aesthetics are: There are none in the base series. See below for options for subclasses. Some data series support additional aesthetics or options: :class:`~.LineOver1DRangeSeries`, :class:`~.Parametric2DLineSeries`, and :class:`~.Parametric3DLineSeries` support the following: Aesthetics: - line_color : string, or float, or function, optional Specifies the color for the plot, which depends on the backend being used. For example, if ``MatplotlibBackend`` is being used, then Matplotlib string colors are acceptable (``"red"``, ``"r"``, ``"cyan"``, ``"c"``, ...). Alternatively, we can use a float number, 0 < color < 1, wrapped in a string (for example, ``line_color="0.5"``) to specify grayscale colors. Alternatively, We can specify a function returning a single float value: this will be used to apply a color-loop (for example, ``line_color=lambda x: math.cos(x)``). Note that by setting line_color, it would be applied simultaneously to all the series. Options: - label : str - steps : bool - integers_only : bool :class:`~.SurfaceOver2DRangeSeries` and :class:`~.ParametricSurfaceSeries` support the following: Aesthetics: - surface_color : function which returns a float. Notes ===== How the plotting module works: 1. Whenever a plotting function is called, the provided expressions are processed and a list of instances of the :class:`~sympy.plotting.series.BaseSeries` class is created, containing the necessary information to plot the expressions (e.g. the expression, ranges, series name, ...). Eventually, these objects will generate the numerical data to be plotted. 2. A subclass of :class:`~.Plot` class is instantiaed (referred to as backend, from now on), which stores the list of series and the main attributes of the plot (e.g. axis labels, title, ...). The backend implements the logic to generate the actual figure with some plotting library. 3. When the ``show`` command is executed, series are processed one by one to generate numerical data and add it to the figure. The backend is also going to set the axis labels, title, ..., according to the values stored in the Plot instance. The backend should check if it supports the data series that it is given (e.g. :class:`TextBackend` supports only :class:`~sympy.plotting.series.LineOver1DRangeSeries`). It is the backend responsibility to know how to use the class of data series that it's given. Note that the current implementation of the ``*Series`` classes is "matplotlib-centric": the numerical data returned by the ``get_points`` and ``get_meshes`` methods is meant to be used directly by Matplotlib. Therefore, the new backend will have to pre-process the numerical data to make it compatible with the chosen plotting library. Keep in mind that future SymPy versions may improve the ``*Series`` classes in order to return numerical data "non-matplotlib-centric", hence if you code a new backend you have the responsibility to check if its working on each SymPy release. Please explore the :class:`MatplotlibBackend` source code to understand how a backend should be coded. In order to be used by SymPy plotting functions, a backend must implement the following methods: * show(self): used to loop over the data series, generate the numerical data, plot it and set the axis labels, title, ... * save(self, path): used to save the current plot to the specified file path. * close(self): used to close the current plot backend (note: some plotting library does not support this functionality. In that case, just raise a warning). NautoTlinearFrdefault)titlexlabelylabelzlabel aspect_ratioxlimylim axis_centeraxisxscaleyscalelegend autoscalemarginrrrrbackendsizec ^^^UTlUTlUTlUTlUTlUTlU TlU TlU TlU Tl U Tl UTl UTl UTl UTlUTl/TlTR R#U5 TR R#[%UUUUS95 SmSmUUU4SjnSTlU"SU5 STlU"SU5 STlU"SU5 g)N)rrrrc&[SU55$)Nc3<# UHn[USS5v M g7f)is_realTNgetattr.0is r 2Plot.__init__....sEAGAy$77alllims r Plot.__init__..sEEEr c&[SU55$)Nc3<# UHn[USS5v M g7f) is_finiteTNrArCs r rFrGsG3aGA{D993rHrIrKs r rMrNsG3GGr c >U(avT"U5(d[SRX55eT"U5(d[SRX55e[TU[US5[US545 gg)Nz#All numbers from {}={} must be realz%All numbers from {}={} must be finiter) ValueErrorformatsetattrfloat)t_nametrQr@selfs r check_and_set$Plot.__init__..check_and_setsxqzz$9@@KMM ||$;BB6MOOfuQqT{E!A$K&@Ar r2r3r<)r-r.r/r0r1r4r5r6r7r8r9r: _annotations_markers _rectangles_fill_seriesextendr&r2r3r<)rZr-r.r/r0r1r2r3r4r5r6r7r8r9r:rrrrr;r<rr r[rQr@s` @@r __init__ Plot.__init__s     (&    " ' %   D! 7#W  F  H  B fd# fd# fd#r cU$Nr rZs r _backend Plot._backends r c[U5$rf)typergs r r; Plot.backend s Dzr c[UR5VVs/sHupSU-[U5-PM nnnSSRU5-$s snnf)Nz[%d]: zPlot object containing:  ) enumeraterastrjoin)rZrEs series_strss r __str__ Plot.__str__sS#,T\\#:<#:41!1 A.#: <*TYY{-CCCja*=="&LL >>r cURU grfrwrxs r __delitem__Plot.__delitem__s LL r cz[U[5(aURRU5 g[ S5e)aAdds an element from a plot's series to an existing plot. Examples ======== Consider two ``Plot`` objects, ``p1`` and ``p2``. To add the second plot's first series object to the first, use the ``append`` method, like so: .. plot:: :format: doctest :include-source: True >>> from sympy import symbols >>> from sympy.plotting import plot >>> x = symbols('x') >>> p1 = plot(x*x, show=False) >>> p2 = plot(x, show=False) >>> p1.append(p2[0]) >>> p1 Plot object containing: [0]: cartesian line: x**2 for x over (-10.0, 10.0) [1]: cartesian line: x for x over (-10.0, 10.0) >>> p1.show() See Also ======== extend z'Must specify element of plot to append.N)rrrar TypeErrorrZargs r r Plot.appends0@ c: & & LL   $EF Fr c[U[5(a&URRUR5 g[ U5(aURRU5 g[ S5e)a{Adds all series from another plot. Examples ======== Consider two ``Plot`` objects, ``p1`` and ``p2``. To add the second plot to the first, use the ``extend`` method, like so: .. plot:: :format: doctest :include-source: True >>> from sympy import symbols >>> from sympy.plotting import plot >>> x = symbols('x') >>> p1 = plot(x**2, show=False) >>> p2 = plot(x, -x, show=False) >>> p1.extend(p2) >>> p1 Plot object containing: [0]: cartesian line: x**2 for x over (-10.0, 10.0) [1]: cartesian line: x for x over (-10.0, 10.0) [2]: cartesian line: -x for x over (-10.0, 10.0) >>> p1.show() z(Expecting Plot or sequence of BaseSeriesN)rr(rarbrrrs r rb Plot.extendDsP6 c4 LL   ,    LL   $FG Gr c[erfNotImplementedErrorrgs r show Plot.showf!!r c[erfr)rZpaths r save Plot.saveirr c[erfrrgs r close Plot.closelrr c0[S5 UR$).. deprecated:: 1.13r)rr^rgs r r Plot.markersqs !+}}r cj[S5 URR[US95 Xlg)rr)rN)rrarbr&r^rZvs r rrws) !+ 7BC r c0[S5 UR$)rr)rr]rgs r rPlot.annotations~s !/   r cj[S5 URR[US95 Xlg)rr)rN)rrarbr&r]rs r rrs* !/ 7AFGr c0[S5 UR$)rr)rr_rgs r rPlot.rectangless !.r cj[S5 URR[US95 Xlg)rr)rN)rrarbr&r_rs r rrs* !. 71EFr c0[S5 UR$)rr)rr`rgs r r Plot.fills !(zzr cj[S5 URR[US95 Xlg)rr)rN)rrarbr&r`rs r rrs) !( 7Q?@ r )r]r`r^r_rar1r9r5r4r8r:r<r-r.r2r6r/r3r7r0)__name__ __module__ __qualname____firstlineno____doc__rcpropertyrhr;rtrzr~rrrbrrrrsetterrrr__static_attributes__r r r r(r(1sLZz4T &t$dDT 94 8$tD #' #GJ HD"""   ^^ !!       [[r r(N) sympy.plotting.seriesrrsympy.utilities.exceptionsrsympy.utilities.iterablesr__doctest_requires__r rrr&r(r r r rsA?@1#\N  rrr