"""

global _show

"""The central class of the plotting module.

def __init__(self, *args,

title=None, xlabel=None, ylabel=None, aspect_ratio='auto',

xlim=None, ylim=None, axis_center='auto', axis=True,

xscale='linear', yscale='linear', legend=False, autoscale=True,

margin=0, annotations=None, markers=None, rectangles=None,

fill=None, backend='default', **kwargs):

super().__init__()

# Options for the graph as a whole.

# The possible values for each option are described in the docstring of

# Plot. They are based purely on convention, no checking is done.

self.title = title

self.xlabel = xlabel

self.ylabel = ylabel

self.aspect_ratio = aspect_ratio

self.axis_center = axis_center

self.axis = axis

self.xscale = xscale

self.yscale = yscale

self.legend = legend

self.autoscale = autoscale

self.margin = margin

self.annotations = annotations

self.markers = markers

self.rectangles = rectangles

self.fill = fill

# Contains the data objects to be plotted. The backend should be smart

# enough to iterate over this list.

self._series = []

self._series.extend(args)

# The backend type. On every show() a new backend instance is created

# in self._backend which is tightly coupled to the Plot instance

# (thanks to the parent attribute of the backend).

self.backend = plot_backends[backend]

is_real = \

lambda lim: all(getattr(i, 'is_real', True) for i in lim)

is_finite = \

lambda lim: all(getattr(i, 'is_finite', True) for i in lim)

self.xlim = None

self.ylim = None

if xlim:

if not is_real(xlim):

raise ValueError(

"All numbers from xlim={} must be real".format(xlim))

if not is_finite(xlim):

raise ValueError(

"All numbers from xlim={} must be finite".format(xlim))

self.xlim = (float(xlim[0]), float(xlim[1]))

if ylim:

if not is_real(ylim):

raise ValueError(

"All numbers from ylim={} must be real".format(ylim))

if not is_finite(ylim):

raise ValueError(

"All numbers from ylim={} must be finite".format(ylim))

self.ylim = (float(ylim[0]), float(ylim[1]))

def show(self):

# TODO move this to the backend (also for save)

if hasattr(self, '_backend'):

self._backend.close()

self._backend = self.backend(self)

self._backend.show()

def save(self, path):

if hasattr(self, '_backend'):

self._backend.close()

self._backend = self.backend(self)

self._backend.save(path)

def __str__(self):

series_strs = [('[%d]: ' % i) + str(s)

for i, s in enumerate(self._series)]

return 'Plot object containing:\n' + '\n'.join(series_strs)

def __getitem__(self, index):

return self._series[index]

def __setitem__(self, index, *args):

if len(args) == 1 and isinstance(args[0], BaseSeries):

self._series[index] = args

def __delitem__(self, index):

del self._series[index]

def append(self, arg):

"""Adds an element from a plot's series to an existing plot.

if isinstance(arg, BaseSeries):

self._series.append(arg)

else:

raise TypeError('Must specify element of plot to append.')

def extend(self, arg):

"""Adds all series from another plot.

if isinstance(arg, Plot):

self._series.extend(arg._series)

elif is_sequence(arg):

self._series.extend(arg)

else:

"""This class helps to plot subplots from already created sympy plots

def __init__(self, nrows, ncolumns, *args, show=True, **kwargs):

"""

self.nrows = nrows

self.ncolumns = ncolumns

self._series = []

self.args = args

for arg in args:

self._series.append(arg._series)

self.backend = DefaultBackend

if show:

self.show()

def show(self):

if hasattr(self, '_backend'):

self._backend.close()

self._backend = self.backend(self)

self._backend.show()

def save(self, path):

if hasattr(self, '_backend'):

self._backend.close()

self._backend = self.backend(self)

self._backend.save(path)

def __str__(self):

plot_strs = [('Plot[%d]:' % i) + str(plot)

for i, plot in enumerate(self.args)]

"""Base class for the data objects containing stuff to be plotted.

# Some flags follow. The rationale for using flags instead of checking base

# classes is that setting multiple flags is simpler than multiple

# inheritance.

is_2Dline = False

# Some of the backends expect:

# - get_points returning 1D np.arrays list_x, list_y

# - get_segments returning np.array (done in Line2DBaseSeries)

# - get_color_array returning 1D np.array (done in Line2DBaseSeries)

# with the colors calculated at the points from get_points

is_3Dline = False

# Some of the backends expect:

# - get_points returning 1D np.arrays list_x, list_y, list_y

# - get_segments returning np.array (done in Line2DBaseSeries)

# - get_color_array returning 1D np.array (done in Line2DBaseSeries)

# with the colors calculated at the points from get_points

is_3Dsurface = False

# Some of the backends expect:

# - get_meshes returning mesh_x, mesh_y, mesh_z (2D np.arrays)

# - get_points an alias for get_meshes

is_contour = False

# Some of the backends expect:

# - get_meshes returning mesh_x, mesh_y, mesh_z (2D np.arrays)

# - get_points an alias for get_meshes

is_implicit = False

# Some of the backends expect:

# - get_meshes returning mesh_x (1D array), mesh_y(1D array,

# mesh_z (2D np.arrays)

# - get_points an alias for get_meshes

# Different from is_contour as the colormap in backend will be

# different

is_parametric = False

# The calculation of aesthetics expects:

# - get_parameter_points returning one or two np.arrays (1D or 2D)

# used for calculation aesthetics

def __init__(self):

super().__init__()

@property

def is_3D(self):

flags3D = [

self.is_3Dline,

self.is_3Dsurface

]

return any(flags3D)

@property

def is_line(self):

flagslines = [

self.is_2Dline,

self.is_3Dline

]

"""A base class for 2D lines.

is_2Dline = True

_dim = 2

def __init__(self):

super().__init__()

self.label = None

self.steps = False

self.only_integers = False

self.line_color = None

def get_segments(self):

np = import_module('numpy')

points = self.get_points()

if self.steps is True:

x = np.array((points[0], points[0])).T.flatten()[1:]

y = np.array((points[1], points[1])).T.flatten()[:-1]

points = (x, y)

points = np.ma.array(points).T.reshape(-1, 1, self._dim)

return np.ma.concatenate([points[:-1], points[1:]], axis=1)

def get_color_array(self):

np = import_module('numpy')

c = self.line_color

if hasattr(c, '__call__'):

f = np.vectorize(c)

nargs = arity(c)

if nargs == 1 and self.is_parametric:

x = self.get_parameter_points()

return f(centers_of_segments(x))

else:

variables = list(map(centers_of_segments, self.get_points()))

if nargs == 1:

return f(variables[0])

elif nargs == 2:

return f(*variables[:2])

else: # only if the line is 3D (otherwise raises an error)

return f(*variables)

else:

"""Representation for a line consisting of list of points."""

def __init__(self, list_x, list_y):

np = import_module('numpy')

super().__init__()

self.list_x = np.array(list_x)

self.list_y = np.array(list_y)

self.label = 'list'

def __str__(self):

return 'list plot'

def get_points(self):

"""Representation for a line consisting of a SymPy expression over a range."""

def __init__(self, expr, var_start_end, **kwargs):

super().__init__()

self.expr = sympify(expr)

self.label = kwargs.get('label', None) or str(self.expr)

self.var = sympify(var_start_end[0])

self.start = float(var_start_end[1])

self.end = float(var_start_end[2])

self.nb_of_points = kwargs.get('nb_of_points', 300)

self.adaptive = kwargs.get('adaptive', True)

self.depth = kwargs.get('depth', 12)

self.line_color = kwargs.get('line_color', None)

self.xscale = kwargs.get('xscale', 'linear')

def __str__(self):

return 'cartesian line: %s for %s over %s' % (

str(self.expr), str(self.var), str((self.start, self.end)))

def get_segments(self):

"""

if self.only_integers or not self.adaptive:

return super().get_segments()

else:

f = lambdify([self.var], self.expr)

list_segments = []

np = import_module('numpy')

def sample(p, q, depth):

""" Samples recursively if three points are almost collinear.

# Randomly sample to avoid aliasing.

random = 0.45 + np.random.rand() * 0.1

if self.xscale == 'log':

xnew = 10**(np.log10(p[0]) + random * (np.log10(q[0]) -

np.log10(p[0])))

else:

xnew = p[0] + random * (q[0] - p[0])

ynew = f(xnew)

new_point = np.array([xnew, ynew])

# Maximum depth

if depth > self.depth:

list_segments.append([p, q])

# Sample irrespective of whether the line is flat till the

# depth of 6. We are not using linspace to avoid aliasing.

elif depth < 6:

sample(p, new_point, depth + 1)

sample(new_point, q, depth + 1)

# Sample ten points if complex values are encountered

# at both ends. If there is a real value in between, then

# sample those points further.

elif p[1] is None and q[1] is None:

if self.xscale == 'log':

xarray = np.logspace(p[0], q[0], 10)

else:

xarray = np.linspace(p[0], q[0], 10)

yarray = list(map(f, xarray))

if any(y is not None for y in yarray):

for i in range(len(yarray) - 1):

if yarray[i] is not None or yarray[i + 1] is not None:

sample([xarray[i], yarray[i]],

[xarray[i + 1], yarray[i + 1]], depth + 1)

# Sample further if one of the end points in None (i.e. a

# complex value) or the three points are not almost collinear.

elif (p[1] is None or q[1] is None or new_point[1] is None

or not flat(p, new_point, q)):

sample(p, new_point, depth + 1)

sample(new_point, q, depth + 1)

else:

list_segments.append([p, q])

f_start = f(self.start)

f_end = f(self.end)

sample(np.array([self.start, f_start]),

np.array([self.end, f_end]), 0)

return list_segments

def get_points(self):

np = import_module('numpy')

if self.only_integers is True:

if self.xscale == 'log':

list_x = np.logspace(int(self.start), int(self.end),

num=int(self.end) - int(self.start) + 1)

else:

list_x = np.linspace(int(self.start), int(self.end),

num=int(self.end) - int(self.start) + 1)

else:

if self.xscale == 'log':

list_x = np.logspace(self.start, self.end, num=self.nb_of_points)

else:

list_x = np.linspace(self.start, self.end, num=self.nb_of_points)

f = vectorized_lambdify([self.var], self.expr)

list_y = f(list_x)

"""Representation for a line consisting of two parametric sympy expressions

is_parametric = True

def __init__(self, expr_x, expr_y, var_start_end, **kwargs):

super().__init__()

self.expr_x = sympify(expr_x)

self.expr_y = sympify(expr_y)

self.label = kwargs.get('label', None) or \

"(%s, %s)" % (str(self.expr_x), str(self.expr_y))

self.var = sympify(var_start_end[0])

self.start = float(var_start_end[1])

self.end = float(var_start_end[2])

self.nb_of_points = kwargs.get('nb_of_points', 300)

self.adaptive = kwargs.get('adaptive', True)

self.depth = kwargs.get('depth', 12)

self.line_color = kwargs.get('line_color', None)

def __str__(self):

return 'parametric cartesian line: (%s, %s) for %s over %s' % (

str(self.expr_x), str(self.expr_y), str(self.var),

str((self.start, self.end)))

def get_parameter_points(self):

np = import_module('numpy')

return np.linspace(self.start, self.end, num=self.nb_of_points)

def get_points(self):

param = self.get_parameter_points()

fx = vectorized_lambdify([self.var], self.expr_x)

fy = vectorized_lambdify([self.var], self.expr_y)

list_x = fx(param)

list_y = fy(param)

return (list_x, list_y)

def get_segments(self):

"""

if not self.adaptive:

return super().get_segments()

f_x = lambdify([self.var], self.expr_x)

f_y = lambdify([self.var], self.expr_y)

list_segments = []

def sample(param_p, param_q, p, q, depth):

""" Samples recursively if three points are almost collinear.

# Randomly sample to avoid aliasing.

np = import_module('numpy')

random = 0.45 + np.random.rand() * 0.1

param_new = param_p + random * (param_q - param_p)

xnew = f_x(param_new)

ynew = f_y(param_new)

new_point = np.array([xnew, ynew])

# Maximum depth

if depth > self.depth:

list_segments.append([p, q])

# Sample irrespective of whether the line is flat till the

# depth of 6. We are not using linspace to avoid aliasing.

elif depth < 6:

sample(param_p, param_new, p, new_point, depth + 1)

sample(param_new, param_q, new_point, q, depth + 1)

# Sample ten points if complex values are encountered

# at both ends. If there is a real value in between, then

# sample those points further.

elif ((p[0] is None and q[1] is None) or

(p[1] is None and q[1] is None)):

param_array = np.linspace(param_p, param_q, 10)

x_array = list(map(f_x, param_array))

y_array = list(map(f_y, param_array))

if any(x is not None and y is not None

for x, y in zip(x_array, y_array)):

for i in range(len(y_array) - 1):

if ((x_array[i] is not None and y_array[i] is not None) or

(x_array[i + 1] is not None and y_array[i + 1] is not None)):

point_a = [x_array[i], y_array[i]]

point_b = [x_array[i + 1], y_array[i + 1]]

sample(param_array[i], param_array[i], point_a,

point_b, depth + 1)

# Sample further if one of the end points in None (i.e. a complex

# value) or the three points are not almost collinear.

elif (p[0] is None or p[1] is None

or q[1] is None or q[0] is None

or not flat(p, new_point, q)):

sample(param_p, param_new, p, new_point, depth + 1)

sample(param_new, param_q, new_point, q, depth + 1)

else:

list_segments.append([p, q])

f_start_x = f_x(self.start)

f_start_y = f_y(self.start)

start = [f_start_x, f_start_y]

f_end_x = f_x(self.end)

f_end_y = f_y(self.end)

end = [f_end_x, f_end_y]

sample(self.start, self.end, start, end, 0)

"""A base class for 3D lines.

is_2Dline = False

is_3Dline = True

_dim = 3

def __init__(self):

"""Representation for a 3D line consisting of two parametric sympy

def __init__(self, expr_x, expr_y, expr_z, var_start_end, **kwargs):

super().__init__()

self.expr_x = sympify(expr_x)

self.expr_y = sympify(expr_y)

self.expr_z = sympify(expr_z)

self.label = kwargs.get('label', None) or \

"(%s, %s)" % (str(self.expr_x), str(self.expr_y))

self.var = sympify(var_start_end[0])

self.start = float(var_start_end[1])

self.end = float(var_start_end[2])

self.nb_of_points = kwargs.get('nb_of_points', 300)

self.line_color = kwargs.get('line_color', None)

def __str__(self):

return '3D parametric cartesian line: (%s, %s, %s) for %s over %s' % (

str(self.expr_x), str(self.expr_y), str(self.expr_z),

str(self.var), str((self.start, self.end)))

def get_parameter_points(self):

np = import_module('numpy')

return np.linspace(self.start, self.end, num=self.nb_of_points)

def get_points(self):

np = import_module('numpy')

param = self.get_parameter_points()

fx = vectorized_lambdify([self.var], self.expr_x)

fy = vectorized_lambdify([self.var], self.expr_y)

fz = vectorized_lambdify([self.var], self.expr_z)

list_x = fx(param)

list_y = fy(param)

list_z = fz(param)

list_x = np.array(list_x, dtype=np.float64)

list_y = np.array(list_y, dtype=np.float64)

list_z = np.array(list_z, dtype=np.float64)

list_x = np.ma.masked_invalid(list_x)

list_y = np.ma.masked_invalid(list_y)

list_z = np.ma.masked_invalid(list_z)

self._xlim = (np.amin(list_x), np.amax(list_x))

self._ylim = (np.amin(list_y), np.amax(list_y))

self._zlim = (np.amin(list_z), np.amax(list_z))

"""A base class for 3D surfaces."""

is_3Dsurface = True

def __init__(self):

super().__init__()

self.surface_color = None

def get_color_array(self):

np = import_module('numpy')

c = self.surface_color

if isinstance(c, Callable):

f = np.vectorize(c)

nargs = arity(c)

if self.is_parametric:

variables = list(map(centers_of_faces, self.get_parameter_meshes()))

if nargs == 1:

return f(variables[0])

elif nargs == 2:

return f(*variables)

variables = list(map(centers_of_faces, self.get_meshes()))

if nargs == 1:

return f(variables[0])

elif nargs == 2:

return f(*variables[:2])

else:

return f(*variables)

else:

"""Representation for a 3D surface consisting of a sympy expression and 2D

def __init__(self, expr, var_start_end_x, var_start_end_y, **kwargs):

super().__init__()

self.expr = sympify(expr)

self.var_x = sympify(var_start_end_x[0])

self.start_x = float(var_start_end_x[1])

self.end_x = float(var_start_end_x[2])

self.var_y = sympify(var_start_end_y[0])

self.start_y = float(var_start_end_y[1])

self.end_y = float(var_start_end_y[2])

self.nb_of_points_x = kwargs.get('nb_of_points_x', 50)

self.nb_of_points_y = kwargs.get('nb_of_points_y', 50)

self.surface_color = kwargs.get('surface_color', None)

self._xlim = (self.start_x, self.end_x)

self._ylim = (self.start_y, self.end_y)

def __str__(self):

return ('cartesian surface: %s for'

' %s over %s and %s over %s') % (

str(self.expr),

str(self.var_x),

str((self.start_x, self.end_x)),

str(self.var_y),

str((self.start_y, self.end_y)))

def get_meshes(self):

np = import_module('numpy')

mesh_x, mesh_y = np.meshgrid(np.linspace(self.start_x, self.end_x,

num=self.nb_of_points_x),

np.linspace(self.start_y, self.end_y,

num=self.nb_of_points_y))

f = vectorized_lambdify((self.var_x, self.var_y), self.expr)

mesh_z = f(mesh_x, mesh_y)

mesh_z = np.array(mesh_z, dtype=np.float64)

mesh_z = np.ma.masked_invalid(mesh_z)

self._zlim = (np.amin(mesh_z), np.amax(mesh_z))

"""Representation for a 3D surface consisting of three parametric sympy

is_parametric = True

def __init__(

self, expr_x, expr_y, expr_z, var_start_end_u, var_start_end_v,

**kwargs):

super().__init__()

self.expr_x = sympify(expr_x)

self.expr_y = sympify(expr_y)

self.expr_z = sympify(expr_z)

self.var_u = sympify(var_start_end_u[0])

self.start_u = float(var_start_end_u[1])

self.end_u = float(var_start_end_u[2])

self.var_v = sympify(var_start_end_v[0])

self.start_v = float(var_start_end_v[1])

self.end_v = float(var_start_end_v[2])

self.nb_of_points_u = kwargs.get('nb_of_points_u', 50)

self.nb_of_points_v = kwargs.get('nb_of_points_v', 50)

self.surface_color = kwargs.get('surface_color', None)

def __str__(self):

return ('parametric cartesian surface: (%s, %s, %s) for'

' %s over %s and %s over %s') % (

str(self.expr_x),

str(self.expr_y),

str(self.expr_z),

str(self.var_u),

str((self.start_u, self.end_u)),

str(self.var_v),