partial pep8 cleanup in plot and plot3d

Author: fchapoton

src/sage/plot/misc.py

@@ -63,10 +63,10 @@ def setup_for_eval_on_grid(funcs,
 
     EXAMPLES::
 
-        sage: x,y,z=var('x,y,z')
-        sage: f(x,y)=x+y-z
-        sage: g(x,y)=x+y
-        sage: h(y)=-y
+        sage: x,y,z = var('x,y,z')
+        sage: f(x,y) = x+y-z
+        sage: g(x,y) = x+y
+        sage: h(y) = -y
         sage: sage.plot.misc.setup_for_eval_on_grid(f, [(0, 2),(1,3),(-4,1)], plot_points=5)
         (<sage...>, [(0.0, 2.0, 0.5), (1.0, 3.0, 0.5), (-4.0, 1.0, 1.25)])
         sage: sage.plot.misc.setup_for_eval_on_grid([g,h], [(0, 2),(-1,1)], plot_points=5)
@@ -149,20 +149,21 @@ def setup_for_eval_on_grid(funcs,
     # pad the variables if we don't have enough
     nargs = len(ranges)
     if len(vars) < nargs:
-        vars += ('_',)*(nargs-len(vars))
+        vars += ('_',) * (nargs - len(vars))
 
     ranges = [[float(z) for z in r] for r in ranges]
 
     if plot_points is None:
         plot_points = 2
 
     if not isinstance(plot_points, (list, tuple)):
-        plot_points = [plot_points]*len(ranges)
+        plot_points = [plot_points] * len(ranges)
     elif len(plot_points) != nargs:
         raise ValueError("plot_points must be either an integer or a list of integers, one for each range")
 
     plot_points = [int(p) if p >= 2 else 2 for p in plot_points]
-    range_steps = [abs(range[1] - range[0])/(p-1) for range, p in zip(ranges, plot_points)]
+    range_steps = [abs(range[1] - range[0]) / (p - 1)
+                   for range, p in zip(ranges, plot_points)]
     if min(range_steps) == float(0):
         raise ValueError("plot start point and end point must be different")
 
@@ -206,11 +207,12 @@ def try_make_fast(f):
 
     # Handle vectors, lists, tuples, etc.
     if isinstance(funcs, Iterable):
-        funcs = tuple( try_make_fast(f) for f in funcs )
+        funcs = tuple(try_make_fast(f) for f in funcs)
     else:
         funcs = try_make_fast(funcs)
 
-    #TODO: raise an error if there is a function/method in funcs that takes more values than we have ranges
+    # TODO: raise an error if there is a function/method in funcs that
+    # takes more values than we have ranges
 
     if return_vars:
         return (funcs,
@@ -242,10 +244,10 @@ def unify_arguments(funcs):
 
     EXAMPLES::
 
-        sage: x,y,z=var('x,y,z')
-        sage: f(x,y)=x+y-z
-        sage: g(x,y)=x+y
-        sage: h(y)=-y
+        sage: x,y,z = var('x,y,z')
+        sage: f(x,y) = x+y-z
+        sage: g(x,y) = x+y
+        sage: h(y) = -y
         sage: sage.plot.misc.unify_arguments((f,g,h))
         ((x, y, z), (z,))
         sage: sage.plot.misc.unify_arguments((g,h))
@@ -284,7 +286,9 @@ def _multiple_of_constant(n, pos, const):
     r"""
     Function for internal use in formatting ticks on axes with
     nice-looking multiples of various symbolic constants, such
-    as `\pi` or `e`.  Should only be used via keyword argument
+    as `\pi` or `e`.
+
+    This should only be used via keyword argument
     `tick_formatter` in :meth:`plot.show`.  See documentation
     for the matplotlib.ticker module for more details.
 
@@ -311,11 +315,11 @@ def _multiple_of_constant(n, pos, const):
     from sage.misc.latex import latex
     from sage.rings.continued_fraction import continued_fraction
     from sage.rings.infinity import Infinity
-    cf = continued_fraction(n/const)
+    cf = continued_fraction(n / const)
     k = 1
     while cf.quotient(k) != Infinity and cf.denominator(k) < 12:
         k += 1
-    return '$%s$' % latex(cf.convergent(k-1)*const)
+    return '$%s$' % latex(cf.convergent(k - 1) * const)
 
 
 def get_matplotlib_linestyle(linestyle, return_type):
@@ -401,10 +405,14 @@ def get_matplotlib_linestyle(linestyle, return_type):
         {'solid', 'dashed', 'dotted', dashdot', 'None'}, respectively {'-',
         '--', ':', '-.', ''}
     """
-    long_to_short_dict = {'solid' : '-','dashed' : '--', 'dotted' : ':',
-                        'dashdot':'-.'}
-    short_to_long_dict = {'-' : 'solid','--' : 'dashed', ':' : 'dotted',
-                        '-.':'dashdot'}
+    long_to_short_dict = {'solid': '-',
+                          'dashed': '--',
+                          'dotted': ':',
+                          'dashdot': '-.'}
+    short_to_long_dict = {'-': 'solid',
+                          '--': 'dashed',
+                          ':': 'dotted',
+                          '-.': 'dashdot'}
 
     # We need this to take care of region plot. Essentially, if None is
     # passed, then we just return back the same thing.
@@ -416,16 +424,16 @@ def get_matplotlib_linestyle(linestyle, return_type):
     elif linestyle.startswith("steps"):
         if linestyle.startswith("steps-mid"):
             return "steps-mid" + get_matplotlib_linestyle(
-                                    linestyle.strip("steps-mid"), "short")
+                linestyle.strip("steps-mid"), "short")
         elif linestyle.startswith("steps-post"):
             return "steps-post" + get_matplotlib_linestyle(
-                                    linestyle.strip("steps-post"), "short")
+                linestyle.strip("steps-post"), "short")
         elif linestyle.startswith("steps-pre"):
             return "steps-pre" + get_matplotlib_linestyle(
-                                    linestyle.strip("steps-pre"), "short")
+                linestyle.strip("steps-pre"), "short")
         else:
             return "steps" + get_matplotlib_linestyle(
-                                    linestyle.strip("steps"), "short")
+                linestyle.strip("steps"), "short")
 
     if return_type == 'short':
         if linestyle in short_to_long_dict.keys():

src/sage/plot/plot3d/parametric_plot3d.py

@@ -989,7 +989,7 @@ def g(x, y): return x, y+sin(y), x**2 + y**2
     if isinstance(f, Vector):
         f = tuple(f)
 
-    if isinstance(f, (list, tuple)) and len(f) > 0 and isinstance(f[0], (list, tuple)):
+    if isinstance(f, (list, tuple)) and f and isinstance(f[0], (list, tuple)):
         return sum([parametric_plot3d(v, urange, vrange, plot_points=plot_points, **kwds) for v in f])
 
     if not isinstance(f, (tuple, list)) or len(f) != 3:
@@ -1121,7 +1121,9 @@ def _parametric_plot3d_surface(f, urange, vrange, plot_points, boundary_style, *
 
     if boundary_style is not None:
         for u in (urange[0], urange[-1]):
-            G += line3d([(g[0](u,v), g[1](u,v), g[2](u,v)) for v in vrange], **boundary_style)
+            G += line3d([(g[0](u, v), g[1](u, v), g[2](u, v)) for v in vrange],
+                        **boundary_style)
         for v in (vrange[0], vrange[-1]):
-            G += line3d([(g[0](u,v), g[1](u,v), g[2](u,v)) for u in urange], **boundary_style)
+            G += line3d([(g[0](u, v), g[1](u, v), g[2](u, v)) for u in urange],
+                        **boundary_style)
     return G

src/sage/plot/plot3d/plot3d.py

@@ -155,7 +155,7 @@ def f(x, y): return math.exp(x/5)*math.cos(y)
 from sage.plot.plot3d.shapes import arrow3d
 from sage.plot.plot3d.texture import Texture
 from sage.plot.plot3d.tri_plot import TrianglePlot
-
+from . import parametric_plot3d
 lazy_import("sage.functions.trig", ["cos", "sin"])
 
 
@@ -191,7 +191,7 @@ def __init__(self, dep_var, indep_vars):
         """
         all_vars = sage_getargspec(self.transform).args[1:]
         if set(all_vars) != set(indep_vars + [dep_var]):
-            raise ValueError('variables were specified incorrectly for this coordinate system; incorrect variables were %s' % list(set(all_vars).symmetric_difference(set(indep_vars+[dep_var]))))
+            raise ValueError('variables were specified incorrectly for this coordinate system; incorrect variables were %s' % list(set(all_vars).symmetric_difference(set(indep_vars + [dep_var]))))
         self.dep_var = dep_var
         self.indep_vars = indep_vars
 
@@ -790,10 +790,7 @@ def smooth_triangle(self, a, b, c, da, db, dc, color=None):
             sage: sm_tri
             [[0, 0, 0], [0, 0, 1], [1, 1, 0]]
         """
-        return [a,b,c]
-
-
-from . import parametric_plot3d
+        return [a, b, c]
 
 
 def plot3d(f, urange, vrange, adaptive=False, transformation=None, **kwds):
@@ -1083,7 +1080,7 @@ def plot3d(f, urange, vrange, adaptive=False, transformation=None, **kwds):
             params = f.variables()
 
         from sage.modules.vector_callable_symbolic_dense import Vector_callable_symbolic_dense
-        if isinstance(transformation, (tuple, list,Vector_callable_symbolic_dense)):
+        if isinstance(transformation, (tuple, list, Vector_callable_symbolic_dense)):
             if len(transformation) == 3:
                 if params is None:
                     raise ValueError("must specify independent variable names in the ranges when using generic transformation")
@@ -1095,7 +1092,7 @@ def plot3d(f, urange, vrange, adaptive=False, transformation=None, **kwds):
                 raise ValueError("unknown transformation type")
             # find out which variable is the function variable by
             # eliminating the parameter variables.
-            all_vars = set(sum([list(s.variables()) for s in transformation],[]))
+            all_vars = set(sum([list(s.variables()) for s in transformation], []))
             dep_var = all_vars - set(indep_vars)
             if len(dep_var) == 1:
                 dep_var = dep_var.pop()
@@ -1173,11 +1170,11 @@ def plot3d_adaptive(f, x_range, y_range, color='automatic',
     max_depth = max(max_depth, initial_depth)
 
     from sage.plot.misc import setup_for_eval_on_grid
-    g, ranges = setup_for_eval_on_grid(f, [x_range,y_range], plot_points=2)
-    xmin,xmax = ranges[0][:2]
-    ymin,ymax = ranges[1][:2]
+    g, ranges = setup_for_eval_on_grid(f, [x_range, y_range], plot_points=2)
+    xmin, xmax = ranges[0][:2]
+    ymin, ymax = ranges[1][:2]
 
-    opacity = float(kwds.get('opacity',1))
+    opacity = float(kwds.get('opacity', 1))
 
     if color == "automatic":
         texture = rainbow(num_colors, 'rgbtuple')
@@ -1197,9 +1194,9 @@ def plot3d_adaptive(f, x_range, y_range, color='automatic',
     if isinstance(texture, (list, tuple)):
         if len(texture) == 2:
             # do a grid coloring
-            xticks = (xmax - xmin)/2**initial_depth
-            yticks = (ymax - ymin)/2**initial_depth
-            parts = P.partition(lambda x,y,z: (int((x-xmin)/xticks) + int((y-ymin)/yticks)) % 2)
+            xticks = (xmax - xmin) / 2**initial_depth
+            yticks = (ymax - ymin) / 2**initial_depth
+            parts = P.partition(lambda x, y, z: (int((x - xmin) / xticks) + int((y - ymin) / yticks)) % 2)
         else:
             # do a topo coloring
             bounds = P.bounding_box()
@@ -1208,8 +1205,8 @@ def plot3d_adaptive(f, x_range, y_range, color='automatic',
             if max_z == min_z:
                 span = 0
             else:
-                span = (len(texture)-1) / (max_z - min_z)    # max to avoid dividing by 0
-            parts = P.partition(lambda x, y, z: int((z-min_z)*span))
+                span = (len(texture) - 1) / (max_z - min_z)  # max to avoid dividing by 0
+            parts = P.partition(lambda x, y, z: int((z - min_z) * span))
         all = []
         for k, G in parts.items():
             G.set_texture(texture[k], opacity=opacity)

src/sage/plot/plot3d/plot_field3d.py

@@ -2,7 +2,7 @@
 """
 Plotting 3D fields
 """
-#*****************************************************************************
+# ****************************************************************************
 #       Copyright (C) 2009 Jason Grout <[email protected]>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
@@ -14,8 +14,8 @@
 #
 #  The full text of the GPL is available at:
 #
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
 
 from sage.arith.srange import srange
 from sage.plot.misc import setup_for_eval_on_grid
@@ -143,13 +143,14 @@ def plot_vector_field3d(functions, xrange, yrange, zrange,
             from matplotlib.colors import LinearSegmentedColormap
             cm = LinearSegmentedColormap.from_list('mymap', colors)
         else:
-            cm = lambda x: colors
+            def cm(x):
+                return colors
 
     max_len = max(v.norm() for v in vectors)
-    scaled_vectors = [v/max_len for v in vectors]
+    scaled_vectors = [v / max_len for v in vectors]
 
     if center_arrows:
-        G = sum([plot(v, color=cm(v.norm()), **kwds).translate(p-v/2) for v, p in zip(scaled_vectors, points)])
+        G = sum([plot(v, color=cm(v.norm()), **kwds).translate(p - v / 2) for v, p in zip(scaled_vectors, points)])
         G._set_extra_kwds(kwds)
         return G
     else:

src/sage/plot/plot3d/revolution_plot3d.py

@@ -7,7 +7,7 @@
 - Oscar Gerardo Lazo Arjona (2010): initial version.
 """
 
-#*****************************************************************************
+# ****************************************************************************
 #       Copyright (C) 2010 Oscar Gerardo Lazo Arjona [email protected]
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
@@ -19,8 +19,8 @@
 #
 #  The full text of the GPL is available at:
 #
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
 from sage.misc.decorators import rename_keyword
 
 from sage.plot.plot3d.parametric_plot3d import parametric_plot3d
@@ -253,10 +253,10 @@ def cf(u, phi): return float(2 * u / pi) % 1
         phirange = (phi, phirange[0], phirange[1])
 
     if isinstance(curve, (tuple, list)):
-        #this if-else provides a vector v to be plotted
-        #if curve is a tuple or a list of length 2, it is interpreted as a parametric curve
-        #in the x-z plane.
-        #if it is of length 3 it is interpreted as a parametric curve in 3d space
+        # this if-else provides a vector v to be plotted
+        # if curve is a tuple or a list of length 2, it is interpreted as a parametric curve
+        # in the x-z plane.
+        # if it is of length 3 it is interpreted as a parametric curve in 3d space
 
         if len(curve) == 2:
             x = curve[0]

src/sage/plot/plot3d/shapes2.py

@@ -7,7 +7,7 @@
 
 - William Stein and Robert Bradshaw (2008-01): Many improvements
 """
-#*****************************************************************************
+# ****************************************************************************
 #      Copyright (C) 2007 William Stein <[email protected]>
 #      Copyright (C) 2008 Robert Bradshaw <[email protected]>
 #
@@ -20,10 +20,11 @@
 #
 #  The full text of the GPL is available at:
 #
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
 
 import math
+
 from . import shapes
 
 from .base import PrimitiveObject, point_list_bounding_box
@@ -34,11 +35,10 @@
 from sage.arith.srange import srange
 
 from .texture import Texture
-
-TACHYON_PIXEL = 1/200.0
-
 from .shapes import Text, Sphere
 
+TACHYON_PIXEL = 1 / 200.0
+
 
 @rename_keyword(alpha='opacity')
 def line3d(points, thickness=1, radius=None, arrow_head=False, **kwds):
@@ -516,18 +516,20 @@ def frame_labels(lower_left, upper_right,
     # Helper function for formatting the frame labels
     from math import log
     log10 = log(10)
-    nd = lambda a: int(log(a)/log10)
+
+    def nd(a):
+        return int(log(a) / log10)
 
     def fmt_string(a):
-        b = a/2.0
+        b = a / 2.0
         if b >= 1:
             return "%.1f"
         n = max(0, 2 - nd(a/2.0))
         return "%%.%sf" % n
 
     # Slightly faster than mean for this situation
     def avg(a, b):
-        return (a+b)/2.0
+        return (a + b) / 2.0
 
     color = (0.3, 0.3, 0.3)
 
@@ -722,8 +724,8 @@ def ruler_frame(lower_left, upper_right, ticks=4, sub_ticks=4, **kwds):
         sphinx_plot(ruler_frame([1,2,3],vector([2,3,4]),ticks=6, sub_ticks=2, color='red'))
     """
     return ruler(lower_left, (upper_right[0], lower_left[1], lower_left[2]), ticks=ticks, sub_ticks=sub_ticks, absolute=True, **kwds) \
-         + ruler(lower_left, (lower_left[0], upper_right[1], lower_left[2]), ticks=ticks, sub_ticks=sub_ticks, absolute=True, **kwds) \
-         + ruler(lower_left, (lower_left[0], lower_left[1], upper_right[2]), ticks=ticks, sub_ticks=sub_ticks, absolute=True, **kwds)
+        + ruler(lower_left, (lower_left[0], upper_right[1], lower_left[2]), ticks=ticks, sub_ticks=sub_ticks, absolute=True, **kwds) \
+        + ruler(lower_left, (lower_left[0], lower_left[1], upper_right[2]), ticks=ticks, sub_ticks=sub_ticks, absolute=True, **kwds)
 
 
 ###########################
@@ -1143,8 +1145,8 @@ def tachyon_repr(self, render_params):
                 cmd = ('FCylinder base {pos[0]!r} {pos[1]!r} {pos[2]!r} '
                        'apex {apex[0]!r} {apex[1]!r} {apex[2]!r} '
                        'rad {radius!r} {texture}').format(
-                               pos=(px, py, pz), apex=(x, y, z), radius=radius,
-                               texture=self.texture.id)
+                           pos=(px, py, pz), apex=(x, y, z), radius=radius,
+                           texture=self.texture.id)
                 cmds.append(cmd)
             px, py, pz = x, y, z
         return cmds