a RG5dO=@sdZddlmZmZddlmZmZddlmZddlm Z m Z m Z m Z m Z mZddlmZddlmZdd lmZmZdd lmZdd lmZdd lmZdd lmZddlmZddlm Z ddl!Z!GdddeZ"edddddZ#dS)aQImplicit plotting module for SymPy. Explanation =========== The module implements a data series called ImplicitSeries which is used by ``Plot`` class to plot implicit plots for different backends. The module, by default, implements plotting using interval arithmetic. It switches to a fall back algorithm if the expression cannot be plotted using interval arithmetic. It is also possible to specify to use the fall back algorithm for all plots. Boolean combinations of expressions cannot be plotted by the fall back algorithm. See Also ======== sympy.plotting.plot References ========== .. [1] Jeffrey Allen Tupper. Reliable Two-Dimensional Graphing Methods for Mathematical Formulae with Two Free Variables. .. [2] Jeffrey Allen Tupper. Graphing Equations with Generalized Interval Arithmetic. Master's thesis. University of Toronto, 1996 ) BaseSeriesPlot)experimental_lambdifyvectorized_lambdifyinterval)Equality GreaterThanLessThan RelationalStrictLessThanStrictGreaterThan)Tuple)Eq)DummySymbol)sympify) import_module)BooleanFunction) _sort_gens)doctest_depends_on)flattenNcsDeZdZdZdZfddZddZddZd d Zd d Z Z S) ImplicitSeriesz" Representation for Implicit plot Tc stt||_|j|_t|d|_t|d|_t|d|_t|d|_ t|d|_ t|d|_ |j |_ ||_||_||_d||_||_dS)Nrr)super__init__rexprlabelvar_xfloatstart_xend_xvar_ystart_yend_y get_raster get_points has_equality nb_of_pointsuse_interval_mathdepth line_color) selfrvar_start_end_xvar_start_end_yr)r+r,r*r- __class__X/var/www/html/django/DPS/env/lib/python3.9/site-packages/sympy/plotting/plot_implicit.pyr5s   zImplicitSeries.__init__cCs<dt|jt|jt|j|jft|jt|j|jffS)Nz3Implicit equation: %s for %s over %s and %s over %s)strrr r"r#r$r%r&)r.r3r3r4__str__IszImplicitSeries.__str__cCst|j|jf|jdd}t|j|j}t|j|j}z|||Wn,t yn|j rdt j dddd|_ Yn0|j r| |S|SdS)NT) use_intervalzOAdaptive meshing could not be applied to the expression. Using uniform meshing.) stacklevelF)rr r$rrr"r#r%r&AttributeErrorr+warningswarn_get_raster_interval_get_meshes_grid)r.funcZ xintervalZ yintervalr3r3r4r'Rs    zImplicitSeries.get_rastercs|j}g}td}||j|jd}||j|jd}|jt |dd|j|jd}|jt |dd|j|jd}||7}||7}ddt |dd |ddD} d dt |dd |ddDfd d| D}g} fd d } |dkr6t |r6| |\}} | | |d}q|j r|D]F} | d}| d}||}|drB|ddurB| ||gqB| dfS)z: Uses interval math to adaptively mesh and obtain the plotnumpy!rricSsg|]\}}t||qSr3r).0x1x2r3r3r4 zz7ImplicitSeries._get_raster_interval..NcSsg|]\}}t||qSr3r)rBy1y2r3r3r4rE|rFcsg|]}D] }||gq qSr3r3)rBxy)yinterr3r4rE~rFc sg}g}|D]}|d}|d}||}|ddus|ddurDq |dkr\|||gq |ddust|ddur |j}|j}t|j|} t||j} t|j|} t||j} || | g|| | g|| | g|| | gq ||fS)zj Evaluates the intervals and subdivides the interval if the expression is partially satisfied.rrF)TTN)appendmidrstartend) interval_listZtemp_interval_list plot_list intervals intervalx intervaly func_evalZavgxZavgyabcd)r?r3r4 refine_pixelss,     z:ImplicitSeries._get_raster_interval..refine_pixelsrFfill)r,rlinspacer"r#r%r&randomrandlenzipextendr)rM)r.r?krQnpZxsampleZysampleZjitterxZjitteryZxinterrRr[Zplot_list_temprSrTrUrVr3)r?rLr4r=gsd         z#ImplicitSeries._get_raster_intervalc Csd}t|jtr&|jj|jj}d}nLt|jttfrH|jj|jj}n*t|jttfrj|jj|jj}nt dt d}| |j |j |j}| |j|j|j}|||\}}t|j|jf|}|||} d| |j| dk<d| |j| dk<|r||| dfS||| d fSd S) zGenerates the mesh for generating a contour. In the case of equality, ``contour`` function of matplotlib can be used. In other cases, matplotlib's ``contourf`` is used. FTzDThe expression is not supported for plotting in uniform meshed plot.r@rGrrcontourcontourfN) isinstancerr lhsrhsr rr r NotImplementedErrorrr]r"r#r*r%r&meshgridrr r$mawhere) r.equalrrdxarrayyarrayZx_gridZy_gridr?Zz_gridr3r3r4r>s(   zImplicitSeries._get_meshes_grid) __name__ __module__ __qualname____doc__ is_implicitrr6r'r=r> __classcell__r3r3r1r4r1s  Lr) matplotlib)modulesT,bluec sd} fddgt|tr@|tddDrnd} n.t|tsZt|d}d} nt|tttfrnd} dd ||fD} |j} t t | j} | | } t | | @d krt d t d d fdd}t | dkrt t| } || d}|d}t | d kr8|| vs| s*| td|jn| | || d}|dkrTd}n|dkrbd}t|||| ||||}tdd|ddD|d<tdd|ddD|d<|d|d|d|dt|fi|}|r||S)a A plot function to plot implicit equations / inequalities. Arguments ========= - ``expr`` : The equation / inequality that is to be plotted. - ``x_var`` (optional) : symbol to plot on x-axis or tuple giving symbol and range as ``(symbol, xmin, xmax)`` - ``y_var`` (optional) : symbol to plot on y-axis or tuple giving symbol and range as ``(symbol, ymin, ymax)`` If neither ``x_var`` nor ``y_var`` are given then the free symbols in the expression will be assigned in the order they are sorted. The following keyword arguments can also be used: - ``adaptive`` Boolean. The default value is set to True. It has to be set to False if you want to use a mesh grid. - ``depth`` integer. The depth of recursion for adaptive mesh grid. Default value is 0. Takes value in the range (0, 4). - ``points`` integer. The number of points if adaptive mesh grid is not used. Default value is 300. - ``show`` Boolean. Default value is True. If set to False, the plot will not be shown. See ``Plot`` for further information. - ``title`` string. The title for the plot. - ``xlabel`` string. The label for the x-axis - ``ylabel`` string. The label for the y-axis Aesthetics options: - ``line_color``: float or string. Specifies the color for the plot. See ``Plot`` to see how to set color for the plots. Default value is "Blue" plot_implicit, by default, uses interval arithmetic to plot functions. If the expression cannot be plotted using interval arithmetic, it defaults to a generating a contour using a mesh grid of fixed number of points. By setting adaptive to False, you can force plot_implicit to use the mesh grid. The mesh grid method can be effective when adaptive plotting using interval arithmetic, fails to plot with small line width. Examples ======== Plot expressions: .. plot:: :context: reset :format: doctest :include-source: True >>> from sympy import plot_implicit, symbols, Eq, And >>> x, y = symbols('x y') Without any ranges for the symbols in the expression: .. plot:: :context: close-figs :format: doctest :include-source: True >>> p1 = plot_implicit(Eq(x**2 + y**2, 5)) With the range for the symbols: .. plot:: :context: close-figs :format: doctest :include-source: True >>> p2 = plot_implicit( ... Eq(x**2 + y**2, 3), (x, -3, 3), (y, -3, 3)) With depth of recursion as argument: .. plot:: :context: close-figs :format: doctest :include-source: True >>> p3 = plot_implicit( ... Eq(x**2 + y**2, 5), (x, -4, 4), (y, -4, 4), depth = 2) Using mesh grid and not using adaptive meshing: .. plot:: :context: close-figs :format: doctest :include-source: True >>> p4 = plot_implicit( ... Eq(x**2 + y**2, 5), (x, -5, 5), (y, -2, 2), ... adaptive=False) Using mesh grid without using adaptive meshing with number of points specified: .. plot:: :context: close-figs :format: doctest :include-source: True >>> p5 = plot_implicit( ... Eq(x**2 + y**2, 5), (x, -5, 5), (y, -2, 2), ... adaptive=False, points=400) Plotting regions: .. plot:: :context: close-figs :format: doctest :include-source: True >>> p6 = plot_implicit(y > x**2) Plotting Using boolean conjunctions: .. plot:: :context: close-figs :format: doctest :include-source: True >>> p7 = plot_implicit(And(y > x, y > -x)) When plotting an expression with a single variable (y - 1, for example), specify the x or the y variable explicitly: .. plot:: :context: close-figs :format: doctest :include-source: True >>> p8 = plot_implicit(y - 1, y_var=y) >>> p9 = plot_implicit(x - 1, x_var=x) Fcs8|jD],}t|tr|qt|tr|qdS)zJ Recursively expands the arguments of an Boolean Function N)argsrgrr rM)Z bool_exprarg) arg_expandarg_listr3r4r}hs     z!plot_implicit..arg_expandcss|]}t|tttfVqdSN)rgr r r )rBer3r3r4 wsz plot_implicit..TrcSsg|]}|dur|qSrr3)rBir3r3r4rErFz!plot_implicit..rz>Implicit plotting is not implemented for more than 2 variablescs:t|trt|St|dkr*t|Std|dS)Nz2symbol or `(symbol, min, max)` expected but got %s)rgrrr` ValueError)s) default_ranger3r4 _range_tuples    z#plot_implicit.._range_tuplezf(%s)rrcss|]}t|VqdSrr!)rBrJr3r3r4rrFNxlimcss|]}t|VqdSrr)rBrKr3r3r4rrFylimxlabelylabel)rgranyr rr r r free_symbolsrrr`rjlistrrMrnamepoprtuple setdefaultrshow)rx_vary_varadaptiver,pointsr-rkwargsr)ZxyvarrZ range_symbolsZ undeclaredrr/rJr0Zseries_argumentpr3)r}r~rr4 plot_implicits`            r)NNTrryrzT)$rtplotrrrr intervalmathrsympy.core.relationalr r r r r rsympy.core.containersrrsympy.core.symbolrrsympy.core.sympifyrsympy.externalrsympy.logic.boolalgrsympy.polys.polyutilsrsympy.utilities.decoratorrsympy.utilities.iterablesrr;rrr3r3r3r4s(          %