def test_empty_Plot(): matplotlib = import_module('matplotlib', min_module_version='1.1.0', catch=(RuntimeError,)) if not matplotlib: skip("Matplotlib not the default backend") from sympy.plotting.plot import Plot p = Plot() # No exception showing an empty plot p.show()
def test_empty_Plot(): if not matplotlib: skip("Matplotlib not the default backend") # No exception showing an empty plot plot() p = Plot() p.show()
def plot_function3d(function_selected_object): if function_selected_object.dimensions == 2: plot_3d = plot3d(function_selected_object.expr, ('x', function_selected_object.domain[0][0], function_selected_object.domain[0][1]), ('y', function_selected_object.domain[1][0], function_selected_object.domain[1][1]), show=False) plot_contour = Plot( ContourSeries(function_selected_object.expr, ('x', function_selected_object.domain[0][0], function_selected_object.domain[0][1]), ('y', function_selected_object.domain[1][0], function_selected_object.domain[1][1]))) try: plot_3d.save(os.getcwd() + "/FrontEnd/static/image/results/function3d") plot_contour.save( os.getcwd() + "/FrontEnd/static/image/results/function_contour") except ZeroDivisionError: remove_fig('function3d.png') remove_fig('function_contour.png') else: x = list(range(-32, 32, 2)) y = list(range(-32, 32, 2)) x, y = np.meshgrid(x, y) z = [] for i in range(len(x)): for j in range(len(x[i])): z.append( function_selected_object.calculate_to_print_n( [x[i][j], y[i][j]])) x = np.array(x) y = np.array(y) z = np.array(z) z = z.reshape((len(x), len(y))) fig = plt.figure(figsize=(6.4, 4.8)) try: fig.gca(projection='3d').plot_surface(x, y, z, cmap=cm.viridis, linewidth=0, antialiased=False) save_fig('function3d') except: remove_fig('function3d.png') try: fig.gca(projection='3d').contour(x, y, z, cmap=cm.viridis, antialiased=False) save_fig('function_contour') except: remove_fig('function_contour.png')
def plot_polytope(poly): """Plots the 2D polytope using the functions written in plotting module which in turn uses matplotlib backend. Parameter ========= poly: Denotes a 2-Polytope """ from sympy.plotting.plot import Plot, List2DSeries xl = list(map(lambda vertex: vertex.x, poly.vertices)) yl = list(map(lambda vertex: vertex.y, poly.vertices)) xl.append(poly.vertices[0].x) # Closing the polygon yl.append(poly.vertices[0].y) l2ds = List2DSeries(xl, yl) p = Plot(l2ds, axes='label_axes=True') p.show()
def move_sympyplot_to_axes(p: Plot, ax) -> None: backend = p.backend(p) backend.ax = ax # Fix for > sympy v1.5 backend._process_series(backend.parent._series, ax, backend.parent) backend.ax.spines['right'].set_color('none') backend.ax.spines['bottom'].set_position('zero') backend.ax.spines['top'].set_color('none') pyplot.close(backend.fig)
def plot_polytope(poly): """Plots the 2D polytope using the functions written in plotting module which in turn uses matplotlib backend. Parameter ========= poly: Denotes a 2-Polytope """ from sympy.plotting.plot import Plot, List2DSeries xl = list(map(lambda vertex: vertex.x, poly.vertices)) yl = list(map(lambda vertex: vertex.y, poly.vertices)) xl.append(poly.vertices[0].x) # Closing the polygon yl.append(poly.vertices[0].y) l2ds = List2DSeries(xl, yl) p = Plot(l2ds, axes='label_axes=True') p.show()
def test_plotting2(): from sympy.plotting.color_scheme import ColorGradient, ColorScheme from sympy.plotting.managed_window import ManagedWindow from sympy.plotting.plot import Plot, ScreenShot from sympy.plotting.plot_axes import PlotAxes, PlotAxesBase, PlotAxesFrame, PlotAxesOrdinate from sympy.plotting.plot_camera import PlotCamera from sympy.plotting.plot_controller import PlotController from sympy.plotting.plot_curve import PlotCurve from sympy.plotting.plot_interval import PlotInterval from sympy.plotting.plot_mode import PlotMode from sympy.plotting.plot_modes import Cartesian2D, Cartesian3D, Cylindrical, \ ParametricCurve2D, ParametricCurve3D, ParametricSurface, Polar, Spherical from sympy.plotting.plot_object import PlotObject from sympy.plotting.plot_surface import PlotSurface from sympy.plotting.plot_window import PlotWindow check(ColorScheme("rainbow")) check(Plot(1, visible=False)) check(PlotAxes())
def draw_polygons(polygon_list, save_dir): p = Plot(axes='label_axes=True') c = Circle(Point(0, 0), 1) p[0] = c
def plot_point(expr, x_var=None, y_var=None, **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). - ``points`` integer. The number of points if adaptive mesh grid is not used. Default value is 200. - ``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. 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: >>> from sympy import plot_implicit, cos, sin, symbols, Eq, And >>> x, y = symbols('x y') Without any ranges for the symbols in the expression >>> p1 = plot_implicit(Eq(x**2 + y**2, 5)) With the range for the symbols >>> p2 = plot_implicit(Eq(x**2 + y**2, 3), ... (x, -3, 3), (y, -3, 3)) With depth of recursion as argument. >>> 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. >>> p4 = plot_implicit(Eq(x**2 + y**2, 5), ... (x, -5, 5), (y, -2, 2), adaptive=False) Using mesh grid with number of points as input. >>> p5 = plot_implicit(Eq(x**2 + y**2, 5), ... (x, -5, 5), (y, -2, 2), ... adaptive=False, points=400) Plotting regions. >>> p6 = plot_implicit(y > x**2) Plotting Using boolean conjunctions. >>> 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: >>> p8 = plot_implicit(y - 1, y_var=y) >>> p9 = plot_implicit(x - 1, x_var=x) """ has_equality = False # Represents whether the expression contains an Equality, #GreaterThan or LessThan def arg_expand(bool_expr): """ Recursively expands the arguments of an Boolean Function """ for arg in bool_expr.args: if isinstance(arg, BooleanFunction): arg_expand(arg) elif isinstance(arg, Relational): arg_list.append(arg) arg_list = [] x_list = [] y_list = [] if isinstance(expr, BooleanFunction): arg_expand(expr) #Check whether there is an equality in the expression provided. if any(isinstance(e, (Equality, GreaterThan, LessThan)) for e in arg_list): has_equality = True elif not isinstance(expr, Relational): for point in expr: if type(point) == Point2D: x_list.append(point[0]) y_list.append(point[1]) else: raise ValueError('tipo no esperado %s' % type(point)) expr = x_list,y_list #has_equality = True elif isinstance(expr, (Equality, GreaterThan, LessThan)): has_equality = True 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) > 1: # raise NotImplementedError("Point plotting is not implemented for " # "more than 1 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]) #use_interval = kwargs.pop('adaptive', True) #nb_of_points = kwargs.pop('points', 300) depth = kwargs.pop('depth', 0) line_color = kwargs.pop('tipomarca', "blue") #Check whether the depth is greater than 4 or less than 0. if depth > 4: depth = 4 elif depth < 0: depth = 0 series_argument = PlotSeries(expr, var_start_end_x, var_start_end_y, depth , line_color) show = kwargs.pop('show', True) #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].name) kwargs.setdefault('ylabel', var_start_end_y[0].name) p = Plot(series_argument, **kwargs) if show: p.show() return p