a RG5dh@sVdZddlmZddlmZddlmZddlmZddl m Z m Z ddl m Z mZddlmZdd lmZdd lmZdd lmZdd lmZd dlmZmZddlmZdaddZddZ GdddZ!GdddZ"GdddZ#Gddde#Z$Gddde$Z%Gdd d e$Z&Gd!d"d"e$Z'Gd#d$d$e$Z(Gd%d&d&e(Z)Gd'd(d(e#Z*Gd)d*d*e*Z+Gd+d,d,e*Z,Gd-d.d.e#Z-Gd/d0d0Z.Gd1d2d2e.Z/Gd3d4d4e.Z0Gd5d6d6e.Z1e/e0e1d7Z2d8d9Z3d:d;Z4dQd=d>Z5d?d@Z6ddAdBdCZ7ddAdDdEZ8ddAdFdGZ9ddAdHdIZ:ddAdJdKZ;ddAdLdMZ2Plot.__init__....alllimrrrr<zPlot.__init__..cSstdd|DS)Ncss|]}t|ddVqdS) is_finiteTNr6r8rrrr;r<r=r>r@rrrrBr<csX|rT|std|||s4td||t|t|dt|dfdS)Nz#All numbers from {}={} must be realz%All numbers from {}={} must be finiterr) ValueErrorformatsetattrfloat)Zt_nametrCr5selfrr check_and_sets  z$Plot.__init__..check_and_setr&r'r4)super__init__r!r"r#r$r%r(r)r*r+r,r-r.r/r0r1r2_seriesextendrr plot_backendsr3type issubclass BaseBackend TypeErrorr&r'r4)rJr!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4argskwargsrK __class__rIrrMsJ       z Plot.__init__cCs.t|dr|j|||_|jdSN_backendhasattrrZcloser3showrJrrrr^s   z Plot.showcCs0t|dr|j|||_|j|dSrYr\rZr]r3saverJpathrrrras   z Plot.savecCs"ddt|jD}dd|S)NcSs g|]\}}d|t|qS)z[%d]: r)r9r:srrr sz Plot.__str__..zPlot object containing:  ) enumeraterNjoin)rJZ series_strsrrr__str__sz Plot.__str__cCs |j|SNrNrJindexrrr __getitem__szPlot.__getitem__cGs(t|dkr$t|dtr$||j|<dS)Nrr)lenr BaseSeriesrN)rJrnrUrrr __setitem__ szPlot.__setitem__cCs |j|=dSrkrlrmrrr __delitem__szPlot.__delitem__cCs$t|tr|j|ntddS)aEAdds 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)rrqrNappendrTrJargrrrrts z Plot.appendcCs<t|tr|j|jnt|r0|j|ntddS)aAdds 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)rrrNrOrrTrurrrrO7s  z Plot.extend)__name__ __module__ __qualname____doc__rMr^rarjrorrrsrtrO __classcell__rrrWrrFsl D%rc@s8eZdZdZdddddZddZd d Zd d ZdS) PlotGrida This class helps to plot subplots from already created SymPy plots in a single figure. Examples ======== .. plot:: :context: close-figs :format: doctest :include-source: True >>> from sympy import symbols >>> from sympy.plotting import plot, plot3d, PlotGrid >>> x, y = symbols('x, y') >>> p1 = plot(x, x**2, x**3, (x, -5, 5)) >>> p2 = plot((x**2, (x, -6, 6)), (x, (x, -5, 5))) >>> p3 = plot(x**3, (x, -5, 5)) >>> p4 = plot3d(x*y, (x, -5, 5), (y, -5, 5)) Plotting vertically in a single line: .. plot:: :context: close-figs :format: doctest :include-source: True >>> PlotGrid(2, 1, p1, p2) PlotGrid object containing: Plot[0]: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) Plot[1]: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) Plotting horizontally in a single line: .. plot:: :context: close-figs :format: doctest :include-source: True >>> PlotGrid(1, 3, p2, p3, p4) PlotGrid object containing: Plot[0]: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) Plot[1]:Plot object containing: [0]: cartesian line: x**3 for x over (-5.0, 5.0) Plot[2]:Plot object containing: [0]: cartesian surface: x*y for x over (-5.0, 5.0) and y over (-5.0, 5.0) Plotting in a grid form: .. plot:: :context: close-figs :format: doctest :include-source: True >>> PlotGrid(2, 2, p1, p2, p3, p4) PlotGrid object containing: Plot[0]: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) Plot[1]: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) Plot[2]:Plot object containing: [0]: cartesian line: x**3 for x over (-5.0, 5.0) Plot[3]:Plot object containing: [0]: cartesian surface: x*y for x over (-5.0, 5.0) and y over (-5.0, 5.0) TN)r^r4cOsL||_||_g|_||_|D]}|j|jqt|_||_|rH|dS)a Parameters ========== nrows : The number of rows that should be in the grid of the required subplot. ncolumns : The number of columns that should be in the grid of the required subplot. nrows and ncolumns together define the required grid. Arguments ========= A list of predefined plot objects entered in a row-wise sequence i.e. plot objects which are to be in the top row of the required grid are written first, then the second row objects and so on Keyword arguments ================= show : Boolean The default value is set to ``True``. Set show to ``False`` and the function will not display the subplot. The returned instance of the ``PlotGrid`` class can then be used to save or display the plot by calling the ``save()`` and ``show()`` methods respectively. 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. N) nrowsncolumnsrNrUrtDefaultBackendr3r4r^)rJr}r~r^r4rUrVrvrrrrMs#zPlotGrid.__init__cCs.t|dr|j|||_|jdSrYr[r_rrrr^s   z PlotGrid.showcCs0t|dr|j|||_|j|dSrYr`rbrrrras   z PlotGrid.savecCs"ddt|jD}dd|S)NcSs g|]\}}d|t|qS)z Plot[%d]:rd)r9r:plotrrrrfsz$PlotGrid.__str__..zPlotGrid object containing: rg)rhrUri)rJZ plot_strsrrrrjszPlotGrid.__str__)rwrxryrzrMr^rarjrrrrr|Zs K.r|csPeZdZdZdZdZdZdZdZdZ fddZ e ddZ e ddZ ZS) rqaBase class for the data objects containing stuff to be plotted. Explanation =========== The backend should check if it supports the data series that is given. (e.g. TextBackend supports only LineOver1DRangeSeries). It is the backend responsibility to know how to use the class of data series that is given. Some data series classes are grouped (using a class attribute like is_2Dline) according to the api they present (based only on convention). The backend is not obliged to use that api (e.g. LineOver1DRangeSeries belongs to the is_2Dline group and presents the get_points method, but the TextBackend does not use the get_points method). FcstdSrkrLrMr_rWrrrM&szBaseSeries.__init__cCs|j|jg}t|Srk) is_3Dline is_3Dsurfaceany)rJZflags3Drrris_3D)szBaseSeries.is_3DcCs|j|jg}t|Srk) is_2Dlinerr)rJZ flagslinesrrris_line1szBaseSeries.is_line)rwrxryrzrrr is_contour is_implicit is_parametricrMpropertyrrr{rrrWrrqs  rqcs@eZdZdZdZdZfddZddZdd Zd d Z Z S) Line2DBaseSerieszA base class for 2D lines. - adding the label, steps and only_integers options - making is_2Dline true - defining get_segments and get_color_array Tcs&td|_d|_d|_d|_dS)NF)rLrMrsteps only_integers line_colorr_rWrrrMGs  zLine2DBaseSeries.__init__cCstd}|}|jdurt|dkrx||d|dfjdd}||d|dfjdd}||f}nR||dddd}||dddd }||dddd}|||f}|S) a2 Return lists of coordinates for plotting the line. Returns ======= x : list List of x-coordinates y : list List of y-coordinates z : list List of z-coordinates in case of Parametric3DLineSeries numpyTrrrN)r get_pointsrrparrayTflattenrepeat)rJnppointsxyzrrrget_dataNs  $$  zLine2DBaseSeries.get_datacCsbtddddtd}t||}|j|jdd|j}|jj |dd|ddgddS) Nz The Line2DBaseSeries.get_segments() method is deprecated. Instead, use the MatplotlibBackend.get_segments() method, or use The get_points() or get_data() methods. z1.9zdeprecated-get-segments)deprecated_since_versionactive_deprecations_targetrrrr)) r r rQrmarrreshape_dim concatenate)rJrrrrr get_segmentsjs zLine2DBaseSeries.get_segmentscCstd}|j}t|dr||}t|}|dkrL|jrL|}|t|Stt t| }|dkrr||dS|dkr||ddS||Sn|| |j SdS)Nr__call__rrr) r rr\ vectorizerrget_parameter_pointscenters_of_segmentslistmaprones nb_of_points)rJrcfnargsr variablesrrrget_color_arrayzs     z Line2DBaseSeries.get_color_array) rwrxryrzrrrMrrrr{rrrWrr;s rcs0eZdZdZfddZddZddZZS) List2DSeriesz7Representation for a line consisting of list of points.cs4td}t|||_|||_d|_dS)Nrr)r rLrMrlist_xlist_yr)rJrrrrWrrrMs    zList2DSeries.__init__cCsdS)Nz list plotrr_rrrrjszList2DSeries.__str__cCs |j|jfSrk)rrr_rrrrszList2DSeries.get_points)rwrxryrzrMrjrr{rrrWrrs rcs8eZdZdZfddZddZddZdd ZZS) LineOver1DRangeSerieszHRepresentation for a line consisting of a SymPy expression over a range.c stt||_|ddp$|j|_t|d|_t|d|_t|d|_ |dd|_ |dd|_ |d d |_ |d d|_ |d d |_dS)Nrrrrr,adaptiveTdepth rr*r)rLrMr exprgetrvarrGstartendrrrrr*)rJr var_start_endrVrWrrrMs  zLineOver1DRangeSeries.__init__cCs&dt|jt|jt|j|jffS)Nz!cartesian line: %s for %s over %s)rrrrrr_rrrrjszLineOver1DRangeSeries.__str__csjs jsStjgjggtdfddj}j} j | j|g j|gdfS)a Return lists of coordinates for plotting. Depending on the ``adaptive`` option, this function will either use an adaptive algorithm or it will uniformly sample the expression over the provided range. Returns ======= x : list List of x-coordinates y : list List of y-coordinates Explanation =========== The adaptive sampling is done by recursively checking if three points are almost collinear. If they are not collinear, then more points are added between those points. References ========== .. [1] Adaptive polygonal approximation of parametric curves, Luiz Henrique de Figueiredo. rc s4djd}jdkrPd|d||d|d}n|d||d|d}|}||g}|jkr|d|dn|dkr؈|||d|||dnX|ddur|ddurjdkr|d|dd}n|d|dd}t t |}t d d |Ds0t t |dD]V} || dur|| ddus`|| || g|| d|| dg|dq`nv|ddus|ddus|ddust|||s|||d|||dn|d|ddS) a Samples recursively if three points are almost collinear. For depth < 6, points are added irrespective of whether they satisfy the collinearity condition or not. The maximum depth allowed is 12. ?皙?log rrNcss|]}|duVqdSrkr)r9rrrrr;r<zCLineOver1DRangeSeries.get_points..sample..)randomrandr*log10rrrtlogspacelinspacerrr?rangerpflat) pqrrxnewynew new_pointxarrayyarrayr:rrsamplerJx_coordsy_coordsrrrs@      * z0LineOver1DRangeSeries.get_points..sampler) rr_uniform_samplingrrrr rrrtr)rJZf_startZf_endrrrrs 4    z LineOver1DRangeSeries.get_pointscCstd}|jdur|jdkrN|jt|jt|jt|jt|jdd}q|jt|jt|jt|jt|jdd}n8|jdkr|j|j|j|jd}n|j|j|j|jd}t |j g|j }||}||fS)NrTrrnum) r rr*rintrrrrrrr)rJrrrrrrrrs   z'LineOver1DRangeSeries._uniform_sampling) rwrxryrzrMrjrrr{rrrWrrs  `rcsDeZdZdZdZfddZddZddZd d Zd d Z Z S) Parametric2DLineSerieszZRepresentation for a line consisting of two parametric SymPy expressions over a range.Tc stt||_t||_|ddp6t|j|j|_t|d|_t |d|_ t |d|_ |dd|_ |dd|_ |d d |_|d d|_dS) NrrrrrrrTrrr)rLrMr expr_xexpr_yrrrrrGrrrrrr)rJrrrrVrWrrrM-s     zParametric2DLineSeries.__init__cCs.dt|jt|jt|jt|j|jffS)Nz2parametric cartesian line: (%s, %s) for %s over %s)rrrrrrr_rrrrj;szParametric2DLineSeries.__str__cCstd}|j|j|j|jdSNrrr rrrrrJrrrrr@sz+Parametric2DLineSeries.get_parameter_pointscCs@|}t|jg|j}t|jg|j}||}||}||fSrk)rrrrr)rJparamfxfyrrrrrrDs z(Parametric2DLineSeries._uniform_samplingcsjsStjgjtjgjggfddj}j}||g}j}j}||g}||jj||dfS)a Return lists of coordinates for plotting. Depending on the ``adaptive`` option, this function will either use an adaptive algorithm or it will uniformly sample the expression over the provided range. Returns ======= x : list List of x-coordinates y : list List of y-coordinates Explanation =========== The adaptive sampling is done by recursively checking if three points are almost collinear. If they are not collinear, then more points are added between those points. References ========== .. [1] Adaptive polygonal approximation of parametric curves, Luiz Henrique de Figueiredo. csLtd}d|jd}||||}|}|} ||| g} |jkrr|d|dn|dkr|||| |d||| ||dn|ddur|ddus|ddur|ddur|||d} tt| } tt| } t d d t | | DsHt t | dD]}| |durN| |dusr| |ddur.| |ddur.| || |g}| |d| |dg}| || ||||dq.n|ddus|ddus|ddus|ddust || |s,|||| |d||| ||dn|d|ddS) z Samples recursively if three points are almost collinear. For depth < 6, points are added irrespective of whether they satisfy the collinearity condition or not. The maximum depth allowed is 12. rrrrrrNrcss"|]\}}|duo|duVqdSrkr)r9rrrrrr;szDParametric2DLineSeries.get_points..sample..)r rrrrrtrrrr?ziprrpr)Zparam_pZparam_qrrrrrZ param_newrrrZ param_arrayx_arrayy_arrayr:Zpoint_aZpoint_bf_xZf_yrrJrrrrrpsZ        z1Parametric2DLineSeries.get_points..sampler) rrrrrrrrrt)rJZ f_start_xZ f_start_yrZf_end_xZf_end_yrrrrrLs"6      z!Parametric2DLineSeries.get_points) rwrxryrzrrMrjrrrr{rrrWrr's rcs,eZdZdZdZdZdZfddZZS)Line3DBaseSerieszSA base class for 3D lines. Most of the stuff is derived from Line2DBaseSeries.FTrcstdSrkrr_rWrrrMszLine3DBaseSeries.__init__) rwrxryrzrrrrMr{rrrWrrs rcs<eZdZdZdZfddZddZddZd d ZZ S) Parametric3DLineSeriesz^Representation for a 3D line consisting of three parametric SymPy expressions and a range.Tc stt||_t||_t||_|ddp@t|j|j|_t|d|_ t |d|_ t |d|_ |dd|_ |dd|_d|_d|_d|_dS)Nrrrrrrr)rLrMr rrexpr_zrrrrrGrrrr_xlim_ylim_zlim)rJrrrrrVrWrrrMs      zParametric3DLineSeries.__init__cCs6dt|jt|jt|jt|jt|j|jffS)Nz93D parametric cartesian line: (%s, %s, %s) for %s over %s)rrrrrrrr_rrrrjszParametric3DLineSeries.__str__cCstd}|j|j|j|jdSrrrrrrrsz+Parametric3DLineSeries.get_parameter_pointsc Cstd}|}t|jg|j}t|jg|j}t|jg|j}||}||}||}|j||jd}|j||jd}|j||jd}|j |}|j |}|j |}| || |f|_ | || |f|_| || |f|_|||fSNrdtype)r rrrrrrrfloat64rmasked_invalidaminamaxrrr) rJrrrrfzrrZlist_zrrrrs$   z!Parametric3DLineSeries.get_points) rwrxryrzrrMrjrrr{rrrWrrs  rcs,eZdZdZdZfddZddZZS)SurfaceBaseSerieszA base class for 3D surfaces.Tcstd|_dSrk)rLrM surface_colorr_rWrrrMs zSurfaceBaseSeries.__init__cCstd}|j}t|tr||}t|}|jrfttt | }|dkrV||dS|dkrf||Sttt | }|dkr||dS|dkr||ddS||Sn:t|t r|| t|j|jS|| t|j|jSdS)Nrrrr)r rrrrrrrrcenters_of_facesget_parameter_meshes get_meshesSurfaceOver2DRangeSeriesrminnb_of_points_xnb_of_points_ynb_of_points_unb_of_points_v)rJrrrrrrrrrs(      z!SurfaceBaseSeries.get_color_array)rwrxryrzrrMrr{rrrWrrs rcs0eZdZdZfddZddZddZZS)rzRRepresentation for a 3D surface consisting of a SymPy expression and 2D range.c stt||_t|d|_t|d|_t|d|_t|d|_t|d|_ t|d|_ | dd|_ | dd|_ | dd|_|j|jf|_|j |j f|_dS)Nrrrr2rr)rLrMr rvar_xrGstart_xend_xvar_ystart_yend_yrrrrrr)rJrvar_start_end_xvar_start_end_yrVrWrrrM s  z!SurfaceOver2DRangeSeries.__init__cCs<dt|jt|jt|j|jft|jt|j|jffS)Nz3cartesian surface: %s for %s over %s and %s over %srrrrrr r r r_rrrrj0sz SurfaceOver2DRangeSeries.__str__cCstd}||j|j|j|jd|j|j|j|jd\}}t |j |j f|j }|||}|j ||jd}|j|}||||f|_|||fS)Nrrr)r meshgridrrrrr r rrrr rrrrrrrr)rJrmesh_xmesh_yrmesh_zrrrr9s   z#SurfaceOver2DRangeSeries.get_meshes)rwrxryrzrMrjrr{rrrWrrs  rcs<eZdZdZdZfddZddZddZd d ZZ S) ParametricSurfaceSerieszaRepresentation for a 3D surface consisting of three parametric SymPy expressions and a range.Tc stt||_t||_t||_t|d|_t|d|_t|d|_ t|d|_ t|d|_ t|d|_ | dd|_| dd|_| dd|_dS)Nrrrrrrr)rLrMr rrrvar_urGstart_uend_uvar_vstart_vend_vrrrr)rJrrrZvar_start_end_uZvar_start_end_vrVrWrrrMMs    z ParametricSurfaceSeries.__init__c CsLdt|jt|jt|jt|jt|j|jft|jt|j|j ffS)NzHparametric cartesian surface: (%s, %s, %s) for %s over %s and %s over %s) rrrrrrrrrrr_rrrrj^szParametricSurfaceSeries.__str__cCs8td}||j|j|j|jd|j|j|j|jdSr) r rrrrrrrrrrrrris z,ParametricSurfaceSeries.get_parameter_meshesc Cstd}|\}}t|j|jf|j}t|j|jf|j}t|j|jf|j}|||}|||}|||} |j||j d}|j||j d}|j| |j d} |j |}|j |}|j | } | || |f|_| || |f|_| | | | f|_||| fSr)r rrrrrrrrrrrrrrrr) rJrZmesh_uZmesh_vrrrrrrrrrrps$       z"ParametricSurfaceSeries.get_meshes) rwrxryrzrrMrjrrr{rrrWrrGs   rcs4eZdZdZdZfddZddZddZZS) ContourSeriesz"Representation for a contour plot.Tcstd|_d|_t||_t|d|_t|d|_t|d|_ t|d|_ t|d|_ t|d|_ |j |_|j|j f|_|j |j f|_dS)Nrrrr)rLrMrrr rrrGrrr r r rrrr)rJrr r rWrrrMs  zContourSeries.__init__cCs<dt|jt|jt|j|jft|jt|j|jffS)Nz)contour: %s for %s over %s and %s over %srr_rrrrjszContourSeries.__str__cCs`td}||j|j|j|jd|j|j|j|jd\}}t |j |j f|j }|||||fSr) r rrrrrr r rrrr r)rJrrrrrrrrs zContourSeries.get_meshes) rwrxryrzrrMrjrr{rrrWrrs   rcs8eZdZdZfddZddZddZdd ZZS) rSa( Base class for all backends. A backend represents the plotting library, which implements the necessary functionalities in order to use SymPy plotting functions. 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:`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 :class:`~.Plot` object is instantiated, which stores the list of series and the main attributes of the plot (e.g. axis labels, title, ...). 3. When the ``show`` command is executed, a new backend is instantiated, which loops through each series object to generate and plot the numerical data. 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:`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. Methods ======= 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). See also ======== MatplotlibBackend cst||_dSrk)rLrMparentrJrrWrrrMs zBaseBackend.__init__cCstdSrkNotImplementedErrorr_rrrr^szBaseBackend.showcCstdSrkrrbrrrraszBaseBackend.savecCstdSrkrr_rrrr]szBaseBackend.close) rwrxryrzrMr^rar]r{rrrWrrSs 6 rScsVeZdZdZfddZedddZddZd d Zd d Z d dZ ddZ Z S)MatplotlibBackendzd This class implements the functionalities to use Matplotlib with SymPy plotting functions. c st|tddgdidtfd|_|jj|_|jj|_|jjj |_ t |j dd}|dkrrt |d|d }t |j trd \}}|j jg}n&t |j tr|j j|j j}}|j j}g|_|jj|jd |_t|D]\}}d d |D}t|rt|stdqt|rNtdddgid} |j|jj|||dd|dqt|s|j|jj|||d|d|j|jdd|j|jdd|j|jdd|j|jdd|j|j !d|j|j"!dqdS)N matplotlibfromlist)pyplotcm collections1.1.0) import_kwargsmin_module_versioncatchr%rrr)rr)figsizecSsg|] }|jqSr)r)r9rerrrrfr<z.MatplotlibBackend.__init__..z,The matplotlib backend cannot mix 2D and 3D. mpl_toolkitsmplot3dr&Z3d) projectionaspect)r.leftzerorightnonebottomtop)#rLrMr RuntimeErrorr r"pltr#r$LineCollectionr7rrGrrrNr|r}r~axfigurer4figrhrr?rDrt add_subplotspines set_position set_colorZxaxisZset_ticks_positionZyaxis) rJrr.r}r~ series_listr:seriesZare_3Dr*rWrrrMsH          $ zMatplotlibBackend.__init__NcCshtd}|dur d}|||f}n d}||f}|j|jdd|}|jj|dd|ddgddS)a Convert two list of coordinates to a list of segments to be used with Matplotlib's :external:class:`~matplotlib.collections.LineCollection`. Parameters ========== x : list List of x-coordinates y : list List of y-coordinates z : list List of z-coordinates for a 3D line. rNrrrrr)r rrrrr)rrrrdimrrrrr1s zMatplotlibBackend.get_segmentsc. Cstd}tdddgid}ggg}}}|D]} | jr| \} } t| jttfs`t| jr|| | } | | } | | | | n t | j}|j| | || jd\}q.| jr|j| q.| jrz| \} } }t| jttfst| jr4|jj}|| | |} || } | | | | n t | j}|j| | ||| jd|| j|| j|| jq.| jr| \} } }|j| | |t|jd|jjddd d } t| j ttt!fr| }|"|j#}| |n | $| j || j|| j|| jq.| j%r| &}t'|d kr`t(|d \} } |j)| | | jd dnT|j*j+j,}|d| jg}|\}}}}|dkr|j||||dn|j-||||dq.t.d/|q.|jj0}t||s|j1|2|3dn|r<|4|}|5|ddd f|6|dddff}|7|n|7d dg|r|4|}|5|ddd f|6|dddff}|8|n|8d dg|r|4|}|5|ddd f|6|dddff}|9|n|9d dg|j:rt||s|;|j:|j<r6t||s6|=|j<t||rP|j*j>dkr\|?|j@|jArD|jA}t||rxn|dkr|jBdCd|jBdCdn|dkr|D\}} |E\}!}"|| d krdnd}#|!|"d krdnd}$|jBdC|#|jBdC|$n0|jBdCd|d f|jBdCd|df|jFsT|G|jHrt|Hrt|jIJ|jH|jKr|L|jK|M|jK|jNr|O|jN|jPrt |jP}%|jQ|%dd|jRrt |jR}&|jS|&ddt||r|jTrt |jT}'|jU|'dd|jVr:|jVD]}(|jWfi|(q"|jXrr|jXD](})|)Y}*|*Zd}+|j|+i|*qH|j[r|j[D]$},|j*j\j]fi|,}-|^|-q|j)r|j_fi|j)|j`r|7|j`|jar|8|jadS)Nrr*r!r+r,)rcolorZviridisrr)cmaprstridecstride linewidthrrNone)Z facecolorZ edgecolorwhitecontour)rCzc{} is not supported in the SymPy plotting module with matplotlib backend. Please report this issue.)scalexZscaleyz1.2.0centerr/r3r)datarrL)rr)position)rrrU)br rrrrrrGcallablerr7Z set_arrayrZadd_collectionrrrrrIrrr+art3dZLine3DCollectionrtrrrr plot_surfacer7r#Zjetrrrr4r>rZ get_rasterrp_matplotlib_listr2r colorsListedColormapZcontourfrrEAxes3DZautoscale_viewZget_autoscalex_onZget_autoscaley_onrrrset_xlimset_ylimZset_zlimr*Z set_xscaler+Z set_yscale __version__Zset_autoscale_onr-r(r<r=Zget_xlimZget_ylimr)Z set_axis_offr,Zlegend_Z set_visibler.Z set_xmarginZ set_ymarginr!Z set_titler" set_xlabelr# set_ylabelr$ set_zlabelr/annotater0copypopr1ZpatchesZ RectangleZ add_patchZ fill_betweenr&r').rJr@r8rrr*ZxlimsZylimsZzlimsrerrsegmentsZ collectionlbllinerrOZ color_arrayrrScolormaprrZzarrayZ plot_typerTr&r'ZzlimvalxlxhZylZyhpos_leftZ pos_bottomZxlblZylblZzlblamarkermrUrrectrrr_process_seriesKs                         ,  ,  ,                     z!MatplotlibBackend._process_seriescCsh|j}t|tr|jg}n|j}tt||jD]2\}\}}t|jtrT|jj|}| |||q0dS)za Iterates over every ``Plot`` object and further calls _process_series() N) rrrrNrhrr8r|rUrk)rJrr?r:r@r8rrrprocess_seriess    z MatplotlibBackend.process_seriescCs.|tr"|j|jn|dSrk)rlrr:Z tight_layoutr6r^r]r_rrrr^ s   zMatplotlibBackend.showcCs||j|dSrk)rlr:savefigrbrrrraszMatplotlibBackend.savecCs|j|jdSrk)r6r]r:r_rrrr]szMatplotlibBackend.close)N) rwrxryrzrM staticmethodrrkrlr^rar]r{rrrWrrs + 2 rcs,eZdZfddZddZddZZS) TextBackendcst|dSrkrrrWrrrM szTextBackend.__init__cCs`tsdSt|jjdkr"tdn:t|jjdts>tdn|jjd}t|j|j |j dS)Nrz1The TextBackend supports only one graph per Plot.rz9The TextBackend supports only expressions over a 1D range) rrprrNrDrrrrrr)rJserrrrr^#s zTextBackend.showcCsdSrkrr_rrrr]0szTextBackend.close)rwrxryrMr^r]r{rrrWrros  roc@seZdZddZdS)rcCs(tddtfd}|rt|St|SdS)Nr r%)r'r()r r5rro)clsrr rrr__new__5szDefaultBackend.__new__N)rwrxryrrrrrrr4sr)r textr cCs.td}|||dd|ddfdS)Nrrrr)r meanvstackrrrrrrHsrc Csbtd}|||ddddf|ddddf|ddddf|ddddffdS)Nrrrr)r rtdstackrvrrrrMsrMbP?c Cshtd}|||j}|||j}|||}|j|}|j|} ||| } t| d|kS)z0Checks whether three points are almost collinearrr)r astyperdotlinalgnormabs) rrrepsrZvector_aZvector_bZ dot_productZ vector_a_normZ vector_b_normZ cos_thetarrrrVs    rcCsg}g}t|rd|D]L}|d}|d}||j|j|j|jdg||j|j|j|jdgqn|d|d||fS)zi Returns lists for matplotlib ``fill`` command from a list of bounding rectangular intervals rrN)NNNN)rprOrr)Z interval_listZxlistZylist intervalsZ intervalxZ intervalyrrrrQfs      rQ)r^c sttt|}t}|D],}t|tr||jO}t|dkrtdq|rR| nt d} d| dt d|g}t |dd}fdd|D}t|i}|r||S) aXPlots 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 followings: - 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 is set to ``True``. Set adaptive to ``False`` and specify ``nb_of_points`` 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. nb_of_points : int, optional Used when the ``adaptive`` is set to ``False``. The function is uniformly sampled at ``nb_of_points`` number of points. If the ``adaptive`` flag is set to ``True``, this will be ignored. 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. .. plot:: :context: close-figs :format: doctest :include-source: True >>> plot(x**2, adaptive=False, nb_of_points=400) Plot object containing: [0]: cartesian line: x**2 for x over (-10.0, 10.0) See Also ======== Plot, LineOver1DRangeSeries rzMThe same variable should be used in all univariate expressions being plotted.rr"r#rcsg|]}t|iqSr)rr9rvrVrrrfMr<zplot..)rrr setrr free_symbolsrprDr]r setdefaultrcheck_argumentsrr^) r^rUrVfreerfrr@ plot_exprplotsrrrrs(>     rcsNttt|}g}t|dd}fdd|D}t|i}|rJ||S)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 ``nb_of_points`` 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. nb_of_points : int, optional Used when the ``adaptive`` flag is set to ``False``. Specifies the number of the points used for the uniform sampling. 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 rrcsg|]}t|iqSr)rrrrrrf r<z#plot_parametric..)rrr rrr^r^rUrVr@rrrrrplot_parametricUs6 rcsrttt|}g}t|dd}fdd|D}ddddd d t|i}|rn||S) 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. nb_of_points : The range is uniformly sampled at ``nb_of_points`` number of points. 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 rrcsg|]}t|iqSr)rrrrrrfr<z*plot3d_parametric_line..r"rr#rr$rrrr rrrr^rrrrplot3d_parametric_linesp    rcsttt|}g}t|dd}fdd|D}d|djd|djdtd |dj|djt|i}|r| |S) aL 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: nb_of_points_x : int The x range is sampled uniformly at ``nb_of_points_x`` of points. nb_of_points_y : int The y range is sampled uniformly at ``nb_of_points_y`` of points. 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 rrcsg|]}t|iqSr)rrrrrrf r<zplot3d..r"rr#r$r) rrr rrrr rrr^rrrrplot3ds "rcsrttt|}g}t|dd}fdd|D}ddddd d t|i}|rn||S) a 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: nb_of_points_u : int The ``u`` range is sampled uniformly at ``nb_of_points_v`` of points nb_of_points_y : int The ``v`` range is sampled uniformly at ``nb_of_points_y`` of points 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 rrcsg|]}t|iqSr)rrrrrrf r<z-plot3d_parametric_surface..r"rr#rr$rrrrrrplot3d_parametric_surface se    rcOs`ttt|}t|dd}dd|D}t|i|}t|djdkrPtd|r\||S)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: nb_of_points_x : int The x range is sampled uniformly at ``nb_of_points_x`` of points. nb_of_points_y : int The y range is sampled uniformly at ``nb_of_points_y`` of points. 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 rrcSsg|] }t|qSr)rrrrrrf r<z plot_contour..rz5Contour Plot cannot Plot for more than two variables.) rrr rrrprrDr^)r^rUrVrr@Z plot_contoursrrr plot_contour sM rc s|sgS|dkrt|dtrt||kr6tdtt|D]}t||trBqfqBt|d}t|d|}ttjdd|D}t|||kr|t||dg}nbtdd}g|D]} t||qtt||D]} tt |q|tg}|St|dtsZt|dtrt|d|kr|d krtt|D]N}t||trt|||krqt||tsft||||<qft|d}|d|}t d d |DsJttjd d|D}t||krtd |t|||krpt||trptdd||||Dfdd|D}|Stdd}g|D]} t||qt|t|D]} tt |qtfdd|D}|Snt|dtrt|d||kr|D]x} t|D]*}t| |tstdt | |qt|D]4}t| ||d ksRtdt | ||qRq|SdS)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))] rrz*len(args) should not be less than expr_lenNcSsg|] }|jqSrr)r9errrrf r<z#check_arguments..irrcss"|]}|D]}t|tVq qdSrk)rrr9rrrrrr;) r<z"check_arguments..cSsg|]}|D] }|jq qSrrrrrrrf* sz?The number of free_symbols in the expression is greater than %dcSsg|]}|qSrr)r9Z range_exprrrrrf1 r<csg|] }|qSrrr9rrangesrrrf3 r<csg|] }|qSrrrrrrrf? r<z Expected an expression, given %sz0The ranges should be a tuple of length 3, got %s) rrrprDrrrrunionrtrr?r) rUZexpr_lenZnb_of_free_symbolsr:exprsrrZ default_rangesymbolrvrrrr s    "  "   &   rN)rx)>rzcollections.abcrsympy.core.basicrsympy.core.containersrsympy.core.exprrsympy.core.functionrrsympy.core.symbolrr sympy.core.sympifyr sympy.externalr sympy.printing.latexr sympy.utilities.exceptionsr sympy.utilities.iterablesrZexperimental_lambdifyrrZsympy.plotting.textplotrrrrrr|rqrrrrrrrrrrrSrrorrPrrrrQrrrrrrrrrrrst           NT 9#*E/G   T@}qW