Spaces:
Sleeping
Sleeping
| """Implicit 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 | |
| """ | |
| from sympy.core.containers import Tuple | |
| from sympy.core.symbol import (Dummy, Symbol) | |
| from sympy.polys.polyutils import _sort_gens | |
| from sympy.plotting.series import ImplicitSeries, _set_discretization_points | |
| from sympy.plotting.plot import plot_factory | |
| from sympy.utilities.decorator import doctest_depends_on | |
| from sympy.utilities.iterables import flatten | |
| __doctest_requires__ = {'plot_implicit': ['matplotlib']} | |
| def plot_implicit(expr, x_var=None, y_var=None, adaptive=True, depth=0, | |
| n=300, line_color="blue", show=True, **kwargs): | |
| """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). | |
| - ``n`` integer. The number of points if adaptive mesh grid is not | |
| used. Default value is 300. This keyword argument replaces ``points``, | |
| which should be considered deprecated. | |
| - ``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, n=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) | |
| """ | |
| xyvar = [i for i in (x_var, y_var) if i is not None] | |
| free_symbols = expr.free_symbols | |
| range_symbols = Tuple(*flatten(xyvar)).free_symbols | |
| undeclared = free_symbols - range_symbols | |
| if len(free_symbols & range_symbols) > 2: | |
| raise NotImplementedError("Implicit plotting is not implemented for " | |
| "more than 2 variables") | |
| #Create default ranges if the range is not provided. | |
| default_range = Tuple(-5, 5) | |
| def _range_tuple(s): | |
| if isinstance(s, Symbol): | |
| return Tuple(s) + default_range | |
| if len(s) == 3: | |
| return Tuple(*s) | |
| raise ValueError('symbol or `(symbol, min, max)` expected but got %s' % s) | |
| if len(xyvar) == 0: | |
| xyvar = list(_sort_gens(free_symbols)) | |
| var_start_end_x = _range_tuple(xyvar[0]) | |
| x = var_start_end_x[0] | |
| if len(xyvar) != 2: | |
| if x in undeclared or not undeclared: | |
| xyvar.append(Dummy('f(%s)' % x.name)) | |
| else: | |
| xyvar.append(undeclared.pop()) | |
| var_start_end_y = _range_tuple(xyvar[1]) | |
| kwargs = _set_discretization_points(kwargs, ImplicitSeries) | |
| series_argument = ImplicitSeries( | |
| expr, var_start_end_x, var_start_end_y, | |
| adaptive=adaptive, depth=depth, | |
| n=n, line_color=line_color) | |
| #set the x and y limits | |
| kwargs['xlim'] = tuple(float(x) for x in var_start_end_x[1:]) | |
| kwargs['ylim'] = tuple(float(y) for y in var_start_end_y[1:]) | |
| # set the x and y labels | |
| kwargs.setdefault('xlabel', var_start_end_x[0]) | |
| kwargs.setdefault('ylabel', var_start_end_y[0]) | |
| p = plot_factory(series_argument, **kwargs) | |
| if show: | |
| p.show() | |
| return p | |