passagemath-modules 10.5.46__cp310-cp310-macosx_14_0_arm64.whl → 10.6.20__cp310-cp310-macosx_14_0_arm64.whl

sage/algebras/steenrod/steenrod_algebra.py

@@ -453,12 +453,13 @@ examples.
 #  Distributed under the terms of the GNU General Public License (GPL)
 # ****************************************************************************
 
-from sage.combinat.free_module import CombinatorialFreeModule
-from sage.misc.lazy_attribute import lazy_attribute
-from sage.misc.cachefunc import cached_method
+from sage.categories.homset import Hom
 from sage.categories.modules_with_basis import ModulesWithBasis
 from sage.categories.tensor import tensor
-from sage.categories.homset import Hom
+from sage.combinat.free_module import CombinatorialFreeModule
+from sage.misc.cachefunc import cached_method
+from sage.misc.lazy_attribute import lazy_attribute
+from sage.sets.family import Family
 
 ######################################################
 # the main class
@@ -2109,7 +2110,7 @@ class SteenrodAlgebra_generic(CombinatorialFreeModule):
             sage: A1._element_constructor_(Sq(4)) # Sq(4) not in A1
             Traceback (most recent call last):
             ...
-            ValueError: Element does not lie in this Steenrod algebra
+            ValueError: element does not lie in this Steenrod algebra
             sage: A1({(2,): 1, (1,): 13})
             Sq(1) + Sq(2)
         """
@@ -2131,7 +2132,7 @@ class SteenrodAlgebra_generic(CombinatorialFreeModule):
                 if self.basis_name() == 'milnor':
                     return a
                 return a.change_basis(self.basis_name())
-        raise ValueError("Element does not lie in this Steenrod algebra")
+        raise ValueError("element does not lie in this Steenrod algebra")
 
     def __contains__(self, x):
         r"""
@@ -2343,7 +2344,8 @@ class SteenrodAlgebra_generic(CombinatorialFreeModule):
         """
         from sage.rings.integer import Integer
         if self.basis_name() != 'milnor':
-            return self(SteenrodAlgebra(p=self.prime(),generic=self._generic).P(*nums))
+            return self(SteenrodAlgebra(p=self.prime(),
+                                        generic=self._generic).P(*nums))
         while nums and nums[-1] == 0:
             nums = nums[:-1]
         if len(nums) == 0 or (len(nums) == 1 and nums[0] == 0):
@@ -2359,10 +2361,11 @@ class SteenrodAlgebra_generic(CombinatorialFreeModule):
         else:
             t = ((), nums)
         if self._check_profile_on_basis(t):
-            A = SteenrodAlgebra_generic(p=self.prime(),generic=self._generic)
+            A = SteenrodAlgebra_generic(p=self.prime(),
+                                        generic=self._generic)
             a = A.monomial(t)
             return self(a)
-        raise ValueError("Element not in this algebra")
+        raise ValueError("element not in this algebra")
 
     def Q_exp(self, *nums):
         r"""
@@ -2399,7 +2402,7 @@ class SteenrodAlgebra_generic(CombinatorialFreeModule):
             Q_0 Q_2
         """
         if not all(x in (0, 1) for x in nums):
-            raise ValueError("The tuple %s should consist " % (nums,) +
+            raise ValueError("the tuple %s should consist " % (nums,) +
                              "only of 0s and 1s")
         else:
             if self.basis_name() != 'milnor':
@@ -2452,13 +2455,14 @@ class SteenrodAlgebra_generic(CombinatorialFreeModule):
             sage: H.Q(4)
             Traceback (most recent call last):
             ...
-            ValueError: Element not in this algebra
+            ValueError: element not in this algebra
         """
         if len(nums) != len(set(nums)):
             return self(0)
         else:
             if self.basis_name() != 'milnor':
-                return self(SteenrodAlgebra(p=self.prime(),generic=self._generic).Q(*nums))
+                return self(SteenrodAlgebra(p=self.prime(),
+                                            generic=self._generic).Q(*nums))
             if not self._generic:
                 if len(nums) == 0:
                     return self.one()
@@ -2474,9 +2478,9 @@ class SteenrodAlgebra_generic(CombinatorialFreeModule):
                 t = answer.leading_support()
                 if self._check_profile_on_basis(t):
                     return answer
-                raise ValueError("Element not in this algebra")
+                raise ValueError("element not in this algebra")
 
-    def an_element(self):
+    def _an_element_(self):
         """
         An element of this Steenrod algebra.
 
@@ -2509,29 +2513,32 @@ class SteenrodAlgebra_generic(CombinatorialFreeModule):
                 return self.one()
 
         if basis == 'milnor' and not self._generic:
-            return self.monomial((2,1))
+            return self.monomial((2, 1))
         if basis == 'milnor' and self._generic:
-            return self.term(((1,3), (2,1)), GF(p)(p-1))
+            return self.term(((1, 3), (2, 1)), GF(p)(p - 1))
         if basis == 'serre-cartan' and not self._generic:
-            return self.monomial((4,2,1))
+            return self.monomial((4, 2, 1))
         if basis == 'serre-cartan' and self._generic:
-            return self.term((1,p,0,1,0), GF(p)(p-1))
+            return self.term((1, p, 0, 1, 0), GF(p)(p - 1))
         if basis == 'woody' or basis == 'woodz':
-            return self._from_dict({((3,0),): 1, ((1, 1), (1, 0)): 1}, coerce=True)
+            return self._from_dict({((3, 0),): 1,
+                                    ((1, 1), (1, 0)): 1}, coerce=True)
         if basis.find('wall') >= 0:
-            return self._from_dict({((1,1), (1,0)): 1, ((2, 2), (0, 0)): 1}, coerce=True)
+            return self._from_dict({((1, 1), (1, 0)): 1,
+                                    ((2, 2), (0, 0)): 1}, coerce=True)
         if basis.find('arnona') >= 0:
-            return self._from_dict({((3,3),): 1, ((1, 1), (2, 1)): 1}, coerce=True)
+            return self._from_dict({((3, 3),): 1,
+                                    ((1, 1), (2, 1)): 1}, coerce=True)
         if basis == 'arnonc':
             return self._from_dict({(8,): 1, (4, 4): 1}, coerce=True)
         if basis.find('pst') >= 0:
             if not self._generic:
                 return self.monomial(((3, 1),))
-            return self.term(((1,), (((1,1), 2),)), GF(p)(p-1))
+            return self.term(((1,), (((1, 1), 2),)), GF(p)(p - 1))
         if basis.find('comm') >= 0:
             if not self._generic:
                 return self.monomial(((1, 2),))
-            return self.term(((), (((1,2), 1),)), GF(p)(p-1))
+            return self.term(((), (((1, 2), 1),)), GF(p)(p - 1))
 
     def pst(self, s, t):
         r"""
@@ -2564,7 +2571,8 @@ class SteenrodAlgebra_generic(CombinatorialFreeModule):
         """
         from sage.rings.integer import Integer
         if self.basis_name() != 'milnor':
-            return self(SteenrodAlgebra(p=self.prime(),generic=self._generic).pst(s,t))
+            return self(SteenrodAlgebra(p=self.prime(),
+                                        generic=self._generic).pst(s, t))
         if not isinstance(s, (Integer, int)) and s >= 0:
             raise ValueError("%s is not a nonnegative integer" % s)
         if not isinstance(t, (Integer, int)) and t > 0:
@@ -2620,7 +2628,7 @@ class SteenrodAlgebra_generic(CombinatorialFreeModule):
             return sum(self._profile)
         return sum(self._profile[0]) + len([a for a in self._profile[1] if a == 2])
 
-    def gens(self):
+    def gens(self) -> Family:
         r"""
         Family of generators for this algebra.
 
@@ -2677,7 +2685,6 @@ class SteenrodAlgebra_generic(CombinatorialFreeModule):
             sage: SteenrodAlgebra(p=5, profile=[[2,1], [2,2,2]]).algebra_generators()
             Family (Q_0, P(1), P(5))
         """
-        from sage.sets.family import Family
         from sage.sets.non_negative_integers import NonNegativeIntegers
         from sage.rings.infinity import Infinity
         n = self.ngens()
@@ -2739,7 +2746,7 @@ class SteenrodAlgebra_generic(CombinatorialFreeModule):
             sage: SteenrodAlgebra(profile=[1,2,1]).gen(5)
             Traceback (most recent call last):
             ...
-            ValueError: This algebra only has 4 generators, so call gen(i) with 0 <= i < 4
+            ValueError: this algebra only has 4 generators, so call gen(i) with 0 <= i < 4
 
             sage: D = SteenrodAlgebra(profile=lambda n: n)
             sage: [D.gen(n) for n in range(5)]
@@ -2761,11 +2768,11 @@ class SteenrodAlgebra_generic(CombinatorialFreeModule):
         num = self.ngens()
         if num < Infinity:
             if i >= num:
-                raise ValueError("This algebra only has %s generators, so call gen(i) with 0 <= i < %s" % (num, num))
+                raise ValueError("this algebra only has %s generators, so call gen(i) with 0 <= i < %s" % (num, num))
             # check to see if equal to A(n) for some n.
             n = self.profile(1)
             if not self._generic and self._profile == AA(n-1, p=p)._profile:
-                return self.pst(i,1)
+                return self.pst(i, 1)
             if self._generic and self._profile == AA(n, p=p)._profile:
                 if i == 0:
                     return self.Q(0)
@@ -3053,7 +3060,7 @@ class SteenrodAlgebra_generic(CombinatorialFreeModule):
         """
         return self.is_field()
 
-    def is_noetherian(self):
+    def is_noetherian(self) -> bool:
         """
         This algebra is Noetherian if and only if it is finite.
 

sage/algebras/steenrod/steenrod_algebra_bases.py

@@ -355,7 +355,7 @@ def steenrod_algebra_basis(n, basis='milnor', p=2, **kwds):
     profile = kwds.get("profile", None)
     if (profile is not None and profile != () and profile != ((), ())
             and basis != 'milnor' and basis.find('pst') == -1):
-        raise ValueError("Profile functions may only be used with the Milnor or pst bases")
+        raise ValueError("profile functions may only be used with the Milnor or pst bases")
 
     # Milnor basis
     if basis_name == 'milnor':
@@ -377,7 +377,7 @@ def steenrod_algebra_basis(n, basis='milnor', p=2, **kwds):
     elif not generic and basis == 'arnonc':
         return arnonC_basis(n)
     else:
-        raise ValueError("Unknown basis: %s at the prime %s" % (basis, p))
+        raise ValueError("unknown basis: %s at the prime %s" % (basis, p))
 
 
 # helper functions for producing bases

sage/algebras/steenrod/steenrod_algebra_misc.py

@@ -414,7 +414,7 @@ def normalize_profile(profile, precision=None, truncation_type='auto', p=2, gene
         sage: normalize_profile(lambda n: 3, precision=4, truncation_type=0)
         Traceback (most recent call last):
         ...
-        ValueError: Invalid profile
+        ValueError: invalid profile
         sage: normalize_profile(lambda n: 3, precision=4, truncation_type = Infinity)
         ((3, 3, 3), +Infinity)
 
@@ -458,7 +458,7 @@ def normalize_profile(profile, precision=None, truncation_type='auto', p=2, gene
         sage: normalize_profile([[0,0,0], [1,2,3,2,1]], p=11)
         Traceback (most recent call last):
         ...
-        ValueError: Invalid profile
+        ValueError: invalid profile
     """
     from sage.rings.infinity import Infinity
     if truncation_type == 'zero':
@@ -501,7 +501,7 @@ def normalize_profile(profile, precision=None, truncation_type='auto', p=2, gene
         if is_valid_profile(new_profile, truncation_type, p):
             return new_profile, truncation_type
         else:
-            raise ValueError("Invalid profile")
+            raise ValueError("invalid profile")
     else: # p odd
         if profile is None or profile == Infinity:
             # no specified profile or infinite profile: return profile
@@ -561,7 +561,7 @@ def normalize_profile(profile, precision=None, truncation_type='auto', p=2, gene
         if is_valid_profile(new_profile, truncation_type, p, generic=True):
             return new_profile, truncation_type
         else:
-            raise ValueError("Invalid profile")
+            raise ValueError("invalid profile")
 
 ######################################################
 # string representations for elements

sage/algebras/steenrod/steenrod_algebra_mult.py

@@ -195,10 +195,10 @@ squares or `p`-th power operations and Bocksteins into a dictionary
 representing a sum of admissible monomials.
 """
 
-#*****************************************************************************
+# ****************************************************************************
 #  Copyright (C) 2008-2010 John H. Palmieri <palmieri@math.washington.edu>
 #  Distributed under the terms of the GNU General Public License (GPL)
-#*****************************************************************************
+# ****************************************************************************
 
 from sage.misc.cachefunc import cached_function
 

sage/all__sagemath_modules.py

@@ -1,4 +1,5 @@
 # sage_setup: distribution = sagemath-modules
+# delvewheel: patch
 r"""
 Top level of the distribution package sagemath-modules
 

sage/calculus/integration.pyx

@@ -74,7 +74,7 @@ cdef double c_f(double t, void *params) noexcept:
 
 def numerical_integral(func, a, b=None,
                        algorithm='qag',
-                       max_points=87, params=[], eps_abs=1e-6,
+                       max_points=87, params=None, eps_abs=1e-6,
                        eps_rel=1e-6, rule=6):
     r"""
     Return the numerical integral of the function on the interval
@@ -268,8 +268,6 @@ def numerical_integral(func, a, b=None,
     """
     cdef double abs_err  # step size
     cdef double result
-    cdef int i
-    cdef int j
     cdef double _a, _b
     cdef PyFunctionWrapper wrapper  # struct to pass information into GSL C function
 
@@ -289,6 +287,9 @@ def numerical_integral(func, a, b=None,
     cdef gsl_integration_workspace* W
     W = NULL
 
+    if params is None:
+        params = []
+
     if True:
         from sage.rings.infinity import Infinity
         try:
@@ -620,7 +621,7 @@ def monte_carlo_integral(func, xl, xu, size_t calls, algorithm='plain',
         if len(vars) < target_dim:
             raise ValueError(("The function to be integrated depends on "
                               "{} variables {}, and so cannot be "
-                                 "integrated in {} dimensions. Please fix "
+                              "integrated in {} dimensions. Please fix "
                               "additional variables with the 'params' "
                               "argument").format(len(vars), tuple(vars),
                                                  target_dim))
@@ -629,7 +630,7 @@ def monte_carlo_integral(func, xl, xu, size_t calls, algorithm='plain',
                               "{} variables {}, and so cannot be "
                               "integrated in {} dimensions. Please add "
                               "more items in upper and lower limits"
-                             ).format(len(vars), tuple(vars), target_dim))
+                              ).format(len(vars), tuple(vars), target_dim))
 
         from sage.structure.element import Expression
         if isinstance(func, Expression):

sage/calculus/ode.pxd

@@ -1,5 +1,5 @@
 # sage_setup: distribution = sagemath-modules
 cdef class ode_system:
-   cdef int  c_j(self, double , double *, double *, double *) noexcept
+    cdef int  c_j(self, double , double *, double *, double *) noexcept
 
-   cdef int c_f(self, double t, double* , double* ) noexcept
+    cdef int c_f(self, double t, double* , double*) noexcept

sage/calculus/ode.pyx

@@ -343,7 +343,9 @@ class ode_solver():
         sage: with NamedTemporaryFile(suffix='.png') as f:
         ....:     T.plot_solution(i=0, filename=f.name)
     """
-    def __init__(self, function=None, jacobian=None, h=1e-2, error_abs=1e-10, error_rel=1e-10, a=False, a_dydt=False, scale_abs=False, algorithm='rkf45', y_0=None, t_span=None, params=[]):
+    def __init__(self, function=None, jacobian=None, h=1e-2, error_abs=1e-10,
+                 error_rel=1e-10, a=False, a_dydt=False, scale_abs=False,
+                 algorithm='rkf45', y_0=None, t_span=None, params=None):
         self.function = function
         self.jacobian = jacobian
         self.h = h
@@ -355,7 +357,7 @@ class ode_solver():
         self.algorithm = algorithm
         self.y_0 = y_0
         self.t_span = t_span
-        self.params = params
+        self.params = [] if params is None else params
         self.solution = []
 
     def __setattr__(self, name, value):
@@ -408,7 +410,7 @@ class ode_solver():
         else:
             G.save(filename=filename)
 
-    def ode_solve(self, t_span=False, y_0=False, num_points=False, params=[]):
+    def ode_solve(self, t_span=False, y_0=False, num_points=False, params=None):
         cdef double h  # step size
         h = self.h
         cdef int i
@@ -416,7 +418,7 @@ class ode_solver():
         cdef int type
         cdef int dim
         cdef PyFunctionWrapper wrapper  # struct to pass information into GSL C function
-        self.params = params
+        self.params = [] if params is None else params
 
         if t_span:
             self.t_span = t_span

sage/calculus/riemann.pyx

@@ -52,7 +52,7 @@ from math import pi
 from math import sin
 from math import cos
 
-from math import log # used for complex plot lightness
+from math import log  # used for complex plot lightness
 from math import atan
 
 from cmath import exp
@@ -202,7 +202,7 @@ cdef class Riemann_Map:
     cdef exterior
 
     def __init__(self, fs, fprimes, COMPLEX_T a, int N=500, int ncorners=4,
-        opp=False, exterior = False):
+                 opp=False, exterior=False):
         """
         Initialize the ``Riemann_Map`` class. See the class :class:`Riemann_Map`
         for full documentation on the input of this initialization method.
@@ -228,7 +228,7 @@ cdef class Riemann_Map:
         self.f = fs[0]
         self.a = a
         self.ncorners = ncorners
-        self.N = N  # Number of collocation pts
+        self.N = N   # Number of collocation pts
         self.opp = opp
         self.exterior = exterior
         self.tk = np.array(np.arange(N) * TWOPI / N + 0.001 / N,
@@ -237,14 +237,14 @@ cdef class Riemann_Map:
         for i in range(N):
             self.tk2[i] = self.tk[i]
         self.tk2[N] = TWOPI
-        self.B = len(fs) # number of boundaries of the figure
+        self.B = len(fs)  # number of boundaries of the figure
         if self.exterior and (self.B > 1):
             raise ValueError(
                 "The exterior map is undefined for multiply connected domains")
         cdef np.ndarray[COMPLEX_T,ndim=2] cps = np.zeros([self.B, N],
-            dtype=COMPLEX)
+                                                         dtype=COMPLEX)
         cdef np.ndarray[COMPLEX_T,ndim=2] dps = np.zeros([self.B, N],
-            dtype=COMPLEX)
+                                                         dtype=COMPLEX)
         # Find the points on the boundaries and their derivatives.
         if self.exterior:
             for k in range(self.B):
@@ -322,14 +322,14 @@ cdef class Riemann_Map:
         hconj = h.conjugate()
         g = -sadp * hconj
         normalized_dp=dp/adp
-        C = I / N * sadp # equivalent to -TWOPI / N * 1 / (TWOPI * I) * sadp
-        errinvalid = np.geterr()['invalid'] # checks the current error handling for invalid
-        errdivide = np.geterr()['divide'] # checks the current error handling for divide
+        C = I / N * sadp  # equivalent to -TWOPI / N * 1 / (TWOPI * I) * sadp
+        errinvalid = np.geterr()['invalid']  # checks the current error handling for invalid
+        errdivide = np.geterr()['divide']  # checks the current error handling for divide
         np.seterr(divide='ignore',invalid='ignore')
         K = np.array([C * sadp[t] * (normalized_dp/(cp-cp[t]) -
-             (normalized_dp[t]/(cp-cp[t])).conjugate())
-              for t in np.arange(NB)], dtype=np.complex128)
-        np.seterr(divide=errdivide,invalid=errinvalid) # resets the error handling
+                                     (normalized_dp[t]/(cp-cp[t])).conjugate())
+                      for t in np.arange(NB)], dtype=np.complex128)
+        np.seterr(divide=errdivide,invalid=errinvalid)  # resets the error handling
         for i in range(NB):
             K[i, i] = 1
         # Nystrom Method for solving 2nd kind integrals
@@ -337,7 +337,6 @@ cdef class Riemann_Map:
         # the all-important Szego kernel
         szego = np.array(phi.flatten() / np.sqrt(dp), dtype=COMPLEX)
         self.szego = szego.reshape([B, N])
-        start = 0
         # Finding the theta correspondence using phase. Misbehaves for some
         # regions.
         if B != 1:
@@ -432,7 +431,6 @@ cdef class Riemann_Map:
             sage: sz0 = m.get_szego(boundary=0)
             sage: sz1 = m.get_szego(boundary=1)
         """
-        cdef int k, B
         if boundary < 0:
             temptk = self.tk
             for i in range(self.B - 1):
@@ -707,10 +705,11 @@ cdef class Riemann_Map:
         else:
             return mapped
 
-    def plot_boundaries(self, plotjoined=True, rgbcolor=[0,0,0], thickness=1):
+    def plot_boundaries(self, plotjoined=True, rgbcolor=None, thickness=1):
         """
-        Plots the boundaries of the region for the Riemann map. Note that
-        this method DOES work for multiply connected domains.
+        Plot the boundaries of the region for the Riemann map.
+
+        Note that this method DOES work for multiply connected domains.
 
         INPUT:
 
@@ -748,6 +747,9 @@ cdef class Riemann_Map:
         """
         from sage.plot.all import list_plot
 
+        if rgbcolor is None:
+            rgbcolor = [0, 0, 0]
+
         plots = list(range(self.B))
         for k in range(self.B):
             # This conditional should be eliminated when the thickness/pointsize
@@ -828,8 +830,9 @@ cdef class Riemann_Map:
 
     @options(interpolation='catrom')
     def plot_spiderweb(self, spokes=16, circles=4, pts=32, linescale=0.99,
-            rgbcolor=[0, 0, 0], thickness=1, plotjoined=True, withcolor=False,
-            plot_points=200, min_mag=0.001, **options):
+                       rgbcolor=None, thickness=1,
+                       plotjoined=True, withcolor=False,
+                       plot_points=200, min_mag=0.001, **options):
         """
         Generate a traditional "spiderweb plot" of the Riemann map.
 
@@ -945,12 +948,16 @@ cdef class Riemann_Map:
         cdef int k, i
         if self.exterior:
             raise ValueError(
-                "Spiderwebs for exterior maps are not currently    supported")
+                "Spiderwebs for exterior maps are not currently supported")
+
+        if rgbcolor is None:
+            rgbcolor = [0, 0, 0]
+
         if self.B == 1:  # The efficient simply connected
             edge = self.plot_boundaries(plotjoined=plotjoined,
-                rgbcolor=rgbcolor, thickness=thickness)
+                                        rgbcolor=rgbcolor,
+                                        thickness=thickness)
             circle_list = list(range(circles))
-            theta_array = self.theta_array[0]
             s = spline(np.column_stack([self.theta_array[0], self.tk2]).tolist())
             tmax = self.theta_array[0, self.N]
             tmin = self.theta_array[0, 0]
@@ -961,10 +968,13 @@ cdef class Riemann_Map:
                         (k + 1) / (circles + 1.0) * exp(I*i * TWOPI / (2*pts)))
                 if plotjoined:
                     circle_list[k] = list_plot(comp_pt(temp, 1),
-                        rgbcolor=rgbcolor, thickness=thickness, plotjoined=True)
+                                               rgbcolor=rgbcolor,
+                                               thickness=thickness,
+                                               plotjoined=True)
                 else:
                     circle_list[k] = list_plot(comp_pt(temp, 1),
-                        rgbcolor=rgbcolor, pointsize=thickness)
+                                               rgbcolor=rgbcolor,
+                                               pointsize=thickness)
             line_list = list(range(spokes))
             for k in range(spokes):
                 temp = list(range(pts))
@@ -990,24 +1000,31 @@ cdef class Riemann_Map:
                     self.plot_colored(plot_points=plot_points)
             else:
                 return edge + sum(circle_list) + sum(line_list)
-        else: # The more difficult multiply connected
+        else:  # The more difficult multiply connected
             z_values, xmin, xmax, ymin, ymax = self.compute_on_grid([],
-                plot_points)
+                                                                    plot_points)
             xstep = (xmax-xmin)/plot_points
             ystep = (ymax-ymin)/plot_points
-            dr, dtheta= get_derivatives(z_values, xstep, ystep) # clean later
+            dr, dtheta= get_derivatives(z_values, xstep, ystep)  # clean later
 
             g = Graphics()
-            g.add_primitive(ComplexPlot(complex_to_spiderweb(z_values,dr,dtheta,
-                spokes, circles, rgbcolor,thickness, withcolor, min_mag),
-                (xmin, xmax), (ymin, ymax),options))
+            g.add_primitive(ComplexPlot(complex_to_spiderweb(z_values, dr,
+                                                             dtheta, spokes,
+                                                             circles,
+                                                             rgbcolor,
+                                                             thickness,
+                                                             withcolor,
+                                                             min_mag),
+                                        (xmin, xmax), (ymin, ymax),options))
             return g + self.plot_boundaries(thickness = thickness)
 
     @options(interpolation='catrom')
-    def plot_colored(self, plot_range=[], int plot_points=100, **options):
+    def plot_colored(self, plot_range=None, int plot_points=100, **options):
         """
-        Generates a colored plot of the Riemann map. A red point on the
-        colored plot corresponds to a red point on the unit disc.
+        Generate a colored plot of the Riemann map.
+
+        A red point on the colored plot corresponds to a red point on
+        the unit disc.
 
         INPUT:
 
@@ -1054,11 +1071,14 @@ cdef class Riemann_Map:
         from sage.plot.complex_plot import ComplexPlot
         from sage.plot.all import Graphics
 
+        if plot_range is None:
+            plot_range = []
+
         z_values, xmin, xmax, ymin, ymax = self.compute_on_grid(plot_range,
-            plot_points)
+                                                                plot_points)
         g = Graphics()
         g.add_primitive(ComplexPlot(complex_to_rgb(z_values), (xmin, xmax),
-            (ymin, ymax),options))
+                                    (ymin, ymax), options))
         return g
 
 cdef comp_pt(clist, loop=True):
@@ -1090,8 +1110,8 @@ cdef comp_pt(clist, loop=True):
         list2.append(list2[0])
     return list2
 
-cpdef get_derivatives(np.ndarray[COMPLEX_T, ndim=2] z_values, FLOAT_T xstep,
-    FLOAT_T ystep):
+cpdef get_derivatives(np.ndarray[COMPLEX_T, ndim=2] z_values,
+                      FLOAT_T xstep, FLOAT_T ystep):
     """
     Compute the r*e^(I*theta) form of derivatives from the grid of points. The
     derivatives are computed using quick-and-dirty taylor expansion and
@@ -1133,8 +1153,6 @@ cpdef get_derivatives(np.ndarray[COMPLEX_T, ndim=2] z_values, FLOAT_T xstep,
     """
     cdef np.ndarray[COMPLEX_T, ndim=2] xderiv
     cdef np.ndarray[FLOAT_T, ndim = 2] dr, dtheta, zabs
-    imax = len(z_values)-2
-    jmax = len(z_values[0])-2
     # (f(x+delta)-f(x-delta))/2delta
     xderiv = (z_values[1:-1,2:]-z_values[1:-1,:-2])/(2*xstep)
     # b/c the function is analytic, we know the magnitude of its
@@ -1142,12 +1160,14 @@ cpdef get_derivatives(np.ndarray[COMPLEX_T, ndim=2] z_values, FLOAT_T xstep,
     dr = np.abs(xderiv)
     # the abs(derivative) scaled by distance from origin
     zabs = np.abs(z_values[1:-1,1:-1])
-    dtheta = np.divide(dr,zabs)
+    dtheta = np.divide(dr, zabs)
     return dr, dtheta
 
 cpdef complex_to_spiderweb(np.ndarray[COMPLEX_T, ndim = 2] z_values,
-    np.ndarray[FLOAT_T, ndim = 2] dr, np.ndarray[FLOAT_T, ndim = 2] dtheta,
-    spokes, circles, rgbcolor, thickness, withcolor, min_mag):
+                           np.ndarray[FLOAT_T, ndim = 2] dr,
+                           np.ndarray[FLOAT_T, ndim = 2] dtheta,
+                           spokes, circles, rgbcolor, thickness,
+                           withcolor, min_mag):
     """
     Convert a grid of complex numbers into a matrix containing rgb data
     for the Riemann spiderweb plot.
@@ -1222,9 +1242,9 @@ cpdef complex_to_spiderweb(np.ndarray[COMPLEX_T, ndim = 2] z_values,
                 [1.        , 1.        , 1.        ]]])
      """
     cdef Py_ssize_t i, j, imax, jmax
-    cdef FLOAT_T x, y, mag, arg, width, target, precision, dmag, darg
+    cdef FLOAT_T mag, arg, target, precision, dmag, darg
     cdef COMPLEX_T z
-    cdef FLOAT_T DMAX = 70 # change to adjust rate_of_change cutoff below
+    cdef FLOAT_T DMAX = 70  # change to adjust rate_of_change cutoff below
     precision = thickness/150.0
     imax = len(z_values)
     jmax = len(z_values[0])
@@ -1235,7 +1255,7 @@ cpdef complex_to_spiderweb(np.ndarray[COMPLEX_T, ndim = 2] z_values,
         rgb = np.zeros(dtype=FLOAT, shape=(imax, jmax, 3))
         rgb += 1
     if circles != 0:
-        circ_radii = srange(0,1.0,1.0/circles)
+        circ_radii = srange(0, 1.0, 1.0/circles)
     else:
         circ_radii = []
     if spokes != 0:
@@ -1302,7 +1322,7 @@ cpdef complex_to_rgb(np.ndarray[COMPLEX_T, ndim=2] z_values):
         TypeError: Argument 'z_values' has incorrect type (expected numpy.ndarray, got list)
     """
     cdef Py_ssize_t i, j, imax, jmax
-    cdef FLOAT_T x, y, mag, arg
+    cdef FLOAT_T mag, arg
     cdef FLOAT_T lightness, hue, top, bot
     cdef FLOAT_T r, g, b
     cdef int ihue
@@ -1495,7 +1515,7 @@ cpdef analytic_interior(COMPLEX_T z, int n, FLOAT_T epsilon):
     # evaluates the Cauchy integral of the boundary, split into the real
     # and imaginary results because numerical_integral can't handle complex data.
     rp = 1/(TWOPI)*numerical_integral(cauchy_kernel,0,2*pi,
-        params = [epsilon,z,n,'i'])[0]
+                                      params = [epsilon,z,n,'i'])[0]
     ip = 1/(TWOPI*I)*numerical_integral(cauchy_kernel,0,2*pi,
-        params = [epsilon,z,n,'r'])[0]
+                                        params = [epsilon,z,n,'r'])[0]
     return rp + ip