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