Formatting

Author: bdlucas1

mathics/builtin/drawing/plot.py

@@ -26,7 +26,6 @@
 from mathics.core.evaluation import Evaluation
 from mathics.core.expression import Expression
 from mathics.core.list import ListExpression
-from mathics.eval.nevaluator import eval_N
 from mathics.core.symbols import Symbol, SymbolList
 from mathics.core.systemsymbols import (
     SymbolAll,
@@ -55,6 +54,7 @@
     get_plot_range,
     get_plot_range_option,
 )
+from mathics.eval.nevaluator import eval_N
 
 # The vectorized plot function generates GraphicsComplex using NumericArray,
 # which no consumer will currently understand. So lets make it opt-in for now.
@@ -64,9 +64,19 @@
 # TODO: work out exactly how to deploy.
 use_vectorized_plot = os.getenv("MATHICS3_USE_VECTORIZED_PLOT", False)
 if use_vectorized_plot:
-    from mathics.eval.drawing.plot3d_vectorized import eval_DensityPlot, eval_Plot3D, eval_ComplexPlot, eval_ComplexPlot3D
+    from mathics.eval.drawing.plot3d_vectorized import (
+        eval_ComplexPlot,
+        eval_ComplexPlot3D,
+        eval_DensityPlot,
+        eval_Plot3D,
+    )
 else:
-    from mathics.eval.drawing.plot3d import eval_DensityPlot, eval_Plot3D, eval_ComplexPlot, eval_ComplexPlot3D
+    from mathics.eval.drawing.plot3d import (
+        eval_ComplexPlot,
+        eval_ComplexPlot3D,
+        eval_DensityPlot,
+        eval_Plot3D,
+    )
 
 # This tells documentation how to sort this module
 # Here we are also hiding "drawing" since this erroneously appears at the top level.
@@ -467,12 +477,14 @@ def __init__(self, expr, range_exprs, options, evaluation):
             range = [range_expr.elements[0]]
             for limit_expr in range_expr.elements[1:3]:
                 limit = eval_N(limit_expr, evaluation).to_python()
-                if not isinstance(limit, (int,float,complex)):
+                if not isinstance(limit, (int, float, complex)):
                     self.error(expr, "plln", limit_expr, range_expr)
                 range.append(limit)
-            if isinstance(limit, (int,float)) and range[2] <= range[1]:
+            if isinstance(limit, (int, float)) and range[2] <= range[1]:
                 self.error(expr, "invrange", range_expr)
-            if isinstance(limit, complex) and (range[2].real <= range[1].real or range[2].imag <= range[1].imag):
+            if isinstance(limit, complex) and (
+                range[2].real <= range[1].real or range[2].imag <= range[1].imag
+            ):
                 self.error(expr, "invrange", range_expr)
             self.ranges.append(range)
 
@@ -621,11 +633,12 @@ def eval(
         graphics = self.eval_function(plot_options, evaluation)
         if not graphics:
             return
-        graphics_expr = graphics.generate(options_to_rules(options, self.graphics_class.options))
+        graphics_expr = graphics.generate(
+            options_to_rules(options, self.graphics_class.options)
+        )
         return graphics_expr
 
 
-
 class BarChart(_Chart):
     """
     <url>:WMA link: https://reference.wolfram.com/language/ref/BarChart.html</url>
@@ -749,19 +762,16 @@ class ColorDataFunction(Builtin):
 
 
 class ComplexPlot3D(_Plot3D):
-
     summary_text = "plots one or more complex functions as a surface"
     expected_args = 2
-    options = _Plot3D.options3d | {
-        "Mesh": "None"
-    }
+    options = _Plot3D.options3d | {"Mesh": "None"}
 
     many_functions = True
     eval_function = staticmethod(eval_ComplexPlot3D)
     graphics_class = Graphics3D
 
+
 class ComplexPlot(_Plot3D):
-    
     summary_text = "plots a complex function showing amplitude and phase using colors"
     expected_args = 2
     options = _Plot3D.options2d

mathics/eval/drawing/plot3d_vectorized.py

@@ -71,7 +71,7 @@ def compute_over_grid(nx, ny):
                 if not is_complex:
                     zs = function(**{str(names[0]): xs, str(names[1]): ys})
                 else:
-                    cs = xs + ys * 1j # TODO: fast enough?
+                    cs = xs + ys * 1j  # TODO: fast enough?
                     zs = function(**{str(names[0]): cs})
 
             # sometimes expr gets compiled into something that returns a complex
@@ -103,7 +103,6 @@ def compute_over_grid(nx, ny):
         # pass the xyzs and quads back to the caller to add colors and emit quads as appropriate
         emit(graphics, i, xyzs, quads)
 
-
     # If requested by the Mesh attribute create a mesh of lines covering the surfaces
     # For now only for Plot3D
     # TODO: mesh for DensityPlot?
@@ -131,7 +130,6 @@ def eval_Plot3D(
     evaluation: Evaluation,
 ):
     def emit(graphics, i, xyzs, quads):
-
         # color-blind friendly palette from https://davidmathlogic.com/colorblind
         palette = [
             (255, 176, 0),  # orange
@@ -148,11 +146,10 @@ def emit(graphics, i, xyzs, quads):
         rgb = [c / 255.0 for c in rgb]
         # graphics.add_color(SymbolRGBColor, rgb)
         graphics.add_directives([SymbolRGBColor, *rgb])
-        
+
         # add a GraphicsComplex displaying a surface for this function
         graphics.add_complex(xyzs, lines=None, polys=quads)
 
-
     return make_plot(plot_options, evaluation, dim=3, is_complex=False, emit=emit)
 
 
@@ -162,7 +159,6 @@ def eval_DensityPlot(
     evaluation: Evaluation,
 ):
     def emit(graphics, i, xyzs, quads):
-
         # Fixed palette for now
         # TODO: accept color options
         with Timer("compute colors"):
@@ -184,10 +180,9 @@ def emit(graphics, i, xyzs, quads):
 
 @Timer("complex colors")
 def complex_colors(zs, s=None):
-
     # hue depends on phase
     h = np.angle(zs, deg=True) / 360
-    
+
     # saturation depends on magnitude
     if s is None:
         zabs = abs(zs)
@@ -196,10 +191,10 @@ def complex_colors(zs, s=None):
         s = (zabs - zmin) / (zmax - zmin)
     else:
         s = np.full(zs.shape, s)
-    
+
     # brightness is constant
     b = np.full(zs.shape, 1.0)
-    
+
     # convert to rgb
     hsb = np.array([h, s, b]).T
     rgb = convert_color(hsb, "HSB", "RGB", False)
@@ -213,23 +208,24 @@ def eval_ComplexPlot3D(
     evaluation: Evaluation,
 ):
     def emit(graphics, i, xyzs, quads):
-        zs = xyzs[:,2]
+        zs = xyzs[:, 2]
         rgb = complex_colors(zs, s=0.8)
-        xyzs[:,2] = abs(zs)
-        graphics.add_complex(xyzs.astype(float), lines=None, polys=quads, colors=rgb)        
+        xyzs[:, 2] = abs(zs)
+        graphics.add_complex(xyzs.astype(float), lines=None, polys=quads, colors=rgb)
 
     return make_plot(plot_options, evaluation, dim=3, is_complex=True, emit=emit)
 
 
-
 @Timer("eval_ComplexPlot")
 def eval_ComplexPlot(
     plot_options,
     evaluation: Evaluation,
 ):
     def emit(graphics, i, xyzs, quads):
         # flatten the points and add the quads
-        rgb = complex_colors(xyzs[:,2])
-        graphics.add_complex(xyzs[:, 0:2].astype(float), lines=None, polys=quads, colors=rgb)
+        rgb = complex_colors(xyzs[:, 2])
+        graphics.add_complex(
+            xyzs[:, 0:2].astype(float), lines=None, polys=quads, colors=rgb
+        )
 
     return make_plot(plot_options, evaluation, dim=2, is_complex=True, emit=emit)