Merge branch 'u/chapoton/34342' in 9.7.rc0

Author: fchapoton

build/pkgs/matplotlib/make-setup-config.py

@@ -1,5 +1,4 @@
 from configparser import ConfigParser
-import pkgconfig
 import os
 
 config = ConfigParser()
@@ -23,7 +22,7 @@
 
 print("NOTE: Set SAGE_MATPLOTLIB_GUI to anything but 'no' to try to build the Matplotlib GUI.")
 
-graphical_backend='False'
+graphical_backend = 'False'
 if os.environ.get('SAGE_MATPLOTLIB_GUI', 'no').lower() != 'no':
     graphical_backend = 'auto'
 
@@ -35,7 +34,7 @@
 
 config.add_section('gui_support')
 for backend in ('gtk', 'gtkagg', 'tkagg', 'wxagg', 'macosx', 'windowing'):
-    config.set('gui_support', backend,  graphical_backend)
+    config.set('gui_support', backend, graphical_backend)
 
 with open('src/mplsetup.cfg', 'w') as configfile:
     config.write(configfile)

src/sage/algebras/quatalg/quaternion_algebra.py

@@ -2690,15 +2690,13 @@ def multiply_by_conjugate(self, J):
         R = self.quaternion_algebra()
         return R.ideal(basis, check=False)
 
-    def is_equivalent(I, J, B=10):
+    def is_equivalent(self, J, B=10) -> bool:
         """
-        Return ``True`` if ``I`` and ``J`` are equivalent as right ideals.
+        Return ``True`` if ``self`` and ``J`` are equivalent as right ideals.
 
         INPUT:
 
-        - ``I`` -- a fractional quaternion ideal (self)
-
-        - ``J`` -- a fractional quaternion ideal with same order as ``I``
+        - ``J`` -- a fractional quaternion ideal with same order as ``self``
 
         - ``B`` -- a bound to compute and compare theta series before
           doing the full equivalence test
@@ -2718,23 +2716,24 @@ def is_equivalent(I, J, B=10):
             sage: R[0].is_equivalent(S)
             True
         """
-        if not isinstance(I, QuaternionFractionalIdeal_rational):
+        # shorthand: let I be self
+        if not isinstance(self, QuaternionFractionalIdeal_rational):
             return False
 
-        if I.right_order() != J.right_order():
-            raise ValueError("I and J must be right ideals")
+        if self.right_order() != J.right_order():
+            raise ValueError("self and J must be right ideals")
 
         # Just test theta series first.  If the theta series are
         # different, the ideals are definitely not equivalent.
-        if B > 0 and I.theta_series_vector(B) != J.theta_series_vector(B):
+        if B > 0 and self.theta_series_vector(B) != J.theta_series_vector(B):
             return False
 
         # The theta series are the same, so perhaps the ideals are
         # equivalent.  We use Prop 1.18 of [Pizer, 1980] to decide.
         # 1. Compute I * Jbar
         # see Prop. 1.17 in Pizer.  Note that we use IJbar instead of
         # JbarI since we work with right ideals
-        IJbar = I.multiply_by_conjugate(J)
+        IJbar = self.multiply_by_conjugate(J)
 
         # 2. Determine if there is alpha in K such
         #    that N(alpha) = N(I)*N(J) as explained by Pizer.

src/sage/functions/log.py

@@ -1243,6 +1243,7 @@ def _print_latex_(self, z, m):
 
 harmonic_number = Function_harmonic_number_generalized()
 
+
 class _Function_swap_harmonic(BuiltinFunction):
     r"""
     Harmonic number function with swapped arguments. For internal use only.
@@ -1262,14 +1263,18 @@ class _Function_swap_harmonic(BuiltinFunction):
     """
     def __init__(self):
         BuiltinFunction.__init__(self, "_swap_harmonic", nargs=2)
+
     def _eval_(self, a, b, **kwds):
-        return harmonic_number(b,a,**kwds)
+        return harmonic_number(b, a, **kwds)
+
 
 _swap_harmonic = _Function_swap_harmonic()
 
+
 register_symbol(_swap_harmonic, {'maxima': 'gen_harmonic_number'})
 register_symbol(_swap_harmonic, {'maple': 'harmonic'})
 
+
 class Function_harmonic_number(BuiltinFunction):
     r"""
     Harmonic number function, defined by:

src/sage/groups/abelian_gps/dual_abelian_group.py

@@ -63,11 +63,10 @@
 #                  http://www.gnu.org/licenses/
 ###########################################################################
 
-from sage.rings.infinity import infinity
 from sage.structure.category_object import normalize_names
 from sage.structure.unique_representation import UniqueRepresentation
 from sage.groups.abelian_gps.dual_abelian_group_element import (
-    DualAbelianGroupElement, is_DualAbelianGroupElement )
+    DualAbelianGroupElement, is_DualAbelianGroupElement)
 from sage.misc.mrange import mrange
 from sage.misc.cachefunc import cached_method
 from sage.groups.group import AbelianGroup as AbelianGroupBase
@@ -126,7 +125,7 @@ def __init__(self, G, names, base_ring):
         self._group = G
         names = normalize_names(G.ngens(), names)
         self._assign_names(names)
-        AbelianGroupBase.__init__(self) # TODO: category=CommutativeGroups()
+        AbelianGroupBase.__init__(self)  # TODO: category=CommutativeGroups()
 
     def group(self):
         """
@@ -165,7 +164,7 @@ def __str__(self):
             sage: print(Fd)
             DualAbelianGroup( AbelianGroup ( 3, (5, 64, 729) ) )
         """
-        s = "DualAbelianGroup( AbelianGroup ( %s, %s ) )"%(self.ngens(), self.gens_orders())
+        s = "DualAbelianGroup( AbelianGroup ( %s, %s ) )" % (self.ngens(), self.gens_orders())
         return s
 
     def _repr_(self):
@@ -188,9 +187,9 @@ def _repr_(self):
         eldv = G.gens_orders()
         gp = ""
         for x in eldv:
-            if x!=0:
-                gp = gp + "Z/%sZ x "%x
-            if x==0:
+            if x != 0:
+                gp = gp + "Z/%sZ x " % x
+            if x == 0:
                 gp = gp + "Z x "
         gp = gp[:-2].strip()
         s = 'Dual of Abelian Group isomorphic to ' + gp + ' over ' + str(self.base_ring())
@@ -235,7 +234,7 @@ def random_element(self):
         result = self.one()
         for g in self.gens():
             order = g.order()
-            result *= g**(randint(0,order))
+            result *= g**(randint(0, order))
         return result
 
     def gen(self, i=0):
@@ -255,8 +254,8 @@ def gen(self, i=0):
         """
         n = self.group().ngens()
         if i < 0 or i >= n:
-            raise IndexError("Argument i (= %s) must be between 0 and %s."%(i, n-1))
-        x = [0]*n
+            raise IndexError("Argument i (= %s) must be between 0 and %s." % (i, n - 1))
+        x = [0] * n
         if self.gens_orders()[i] != 1:
             x[i] = 1
         return self.element_class(self, x)
@@ -324,7 +323,7 @@ def invariants(self):
         # TODO: deprecate
         return self.group().gens_orders()
 
-    def __contains__(self,X):
+    def __contains__(self, X):
         """
         Implements "in".
 

src/sage/interfaces/ecm.py

@@ -46,11 +46,11 @@
 #   Distributed under the terms of the GNU General Public License (GPL)
 #   as published by the Free Software Foundation; either version 3 of
 #   the License, or (at your option) any later version.
-#                   http://www.gnu.org/licenses/
+#                   https://www.gnu.org/licenses/
 ###############################################################################
 
 import re
-import subprocess
+from subprocess import Popen, PIPE, call
 
 from sage.structure.sage_object import SageObject
 from sage.rings.integer_ring import ZZ
@@ -216,8 +216,6 @@ def _run_ecm(self, cmd, n):
             sage: ecm._run_ecm(['cat'], 1234)
             '1234'
         """
-        from subprocess import Popen, PIPE
-
         # Under normal usage this program only returns ASCII; anything
         # else mixed is garbage and an error
         # So just accept latin-1 without encoding errors, and let the
@@ -261,7 +259,7 @@ def interact(self):
         """
         print("Enter numbers to run ECM on them.")
         print("Press control-D to exit.")
-        subprocess.call(self._cmd)
+        call(self._cmd)
 
     # Recommended settings from
     # http://www.mersennewiki.org/index.php/Elliptic_Curve_Method
@@ -661,7 +659,7 @@ def factor(self, n, factor_digits=None, B1=2000, proof=False, **kwds):
             # Step 3: Call find_factor until a factorization is found
             n_factorization = [n]
             while len(n_factorization) == 1:
-                n_factorization = self.find_factor(n,B1=B1)
+                n_factorization = self.find_factor(n, B1=B1)
             factors.extend(n_factorization)
 
         return sorted(probable_prime_factors)

src/sage/modules/quotient_module.py

@@ -19,12 +19,11 @@
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
 
-from sage.structure.richcmp import rich_to_bool, richcmp
-
 from .free_module import (Module_free_ambient,
                           FreeModule_ambient,
                           FreeModule_ambient_field)
 
+
 ###############################################################################
 #
 # Quotients of ambient free modules over a domain
@@ -80,7 +79,7 @@ def __init__(self, module, sub):
             v = [C(self._free_cover, x.list(), coerce=False, copy=False) for x in sub.gens()]
             w = [C(self._free_cover, x.list(), coerce=False, copy=False) for x in module.free_relations().gens()]
             self._relations = self._free_cover.submodule(v + w, check=False)
-        else: # Otherwise module should be a free module
+        else:  # Otherwise module should be a free module
             self._free_cover = module
             self._relations = sub
 
@@ -448,7 +447,7 @@ def _repr_(self):
             sage: Q._repr_()
             'Vector space quotient V/W of dimension 1 over Finite Field in a of size 3^2 where\nV: Vector space of degree 3 and dimension 2 over Finite Field in a of size 3^2\nUser basis matrix:\n[1 0 a]\n[a a 1]\nW: Vector space of degree 3 and dimension 1 over Finite Field in a of size 3^2\nBasis matrix:\n[    1     1 a + 2]'
         """
-        return "%s space quotient V/W of dimension %s over %s where\nV: %s\nW: %s"%(
+        return "%s space quotient V/W of dimension %s over %s where\nV: %s\nW: %s" % (
             "Sparse vector" if self.is_sparse() else "Vector",
             self.dimension(), self.base_ring(),
             self.V(), self.W())
@@ -675,4 +674,3 @@ def relations(self):
         return self._sub
 
     W = relations
-