fix pycodestyle E713 and E714 in rings

Author: fchapoton

src/sage/rings/complex_interval_field.py

@@ -25,15 +25,15 @@
     ``+/-1``.
 """
 
-#*****************************************************************************
+# ****************************************************************************
 #       Copyright (C) 2006 William Stein <[email protected]>
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 2 of the License, or
 # (at your option) any later version.
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
 
 
 from sage.structure.parent import Parent
@@ -94,7 +94,7 @@ def ComplexIntervalField(prec=53, names=None):
     if prec in cache:
         X = cache[prec]
         C = X()
-        if not C is None:
+        if C is not None:
             return C
     C = ComplexIntervalField_class(prec)
     cache[prec] = weakref.ref(C)

src/sage/rings/derivation.py

@@ -247,7 +247,7 @@ def __init__(self, domain, codomain, twist=None):
             TypeError: the domain of the derivation must coerce to the domain of the twisting homomorphism
 
         """
-        if not domain in Rings().Commutative():
+        if domain not in Rings().Commutative():
             raise TypeError("the domain must be a commutative ring")
 
         if codomain in Rings().Commutative() and codomain.has_coerce_map_from(domain):

src/sage/rings/function_field/divisor.py

@@ -456,7 +456,7 @@ def multiplicity(self, place):
             sage: D.multiplicity(p2)
             -3
         """
-        if not place in self._data:
+        if place not in self._data:
             return 0
         return self._data[place]
 

src/sage/rings/function_field/function_field.py

@@ -2893,7 +2893,7 @@ def places_above(self, p):
         """
         R = self.base_field()
 
-        if not p in R.place_set():
+        if p not in R.place_set():
             raise TypeError("not a place of the base rational function field")
 
         if p.is_infinite_place():
@@ -3372,9 +3372,9 @@ def _weierstrass_places(self):
         gaps = [1]
         while M.nrows() < d:
             row = vector([der._derive(basis[i], e) for i in range(d)])
-            if not row in M.row_space():
+            if row not in M.row_space():
                 M = matrix(M.rows() + [row])
-                gaps.append(e+1)
+                gaps.append(e + 1)
             e += 1
 
         # This is faster than M.determinant(). Note that Mx

src/sage/rings/function_field/order.py

@@ -1997,7 +1997,7 @@ def decomposition(self, ideal):
                 row.append( V([to(e) for e in self._mtable[i][j]]) )
             mtable.append(row)
 
-        if not p in self._kummer_places:
+        if p not in self._kummer_places:
             #####################################
             # Decomposition by Kummer's theorem #
             #####################################

src/sage/rings/function_field/place.py

@@ -759,7 +759,7 @@ def _gaps_wronskian(self):
         gaps = [1]
         while M.nrows() < d:
             row = vector([to_R(der._derive(basis[i], e, sep)) for i in range(d)])
-            if not row in M.row_space():
+            if row not in M.row_space():
                 M = matrix(M.rows() + [row])
                 M.echelonize()
                 gaps.append(e + 1)
@@ -1065,7 +1065,7 @@ def from_K(e):
         alpha_powered_by_ramification_index = alpha ** prime._ramification_index
 
         def to_K(f):
-            if not f in O:
+            if f not in O:
                 den = O.coordinate_vector(f).denominator()
                 num = den * f
 

src/sage/rings/invariants/reconstruction.py

@@ -383,8 +383,7 @@ def _reduce_invariants(invariants, weights):
     for prime in gcd(invariants).factor():
         p = prime[0]
         for D in factors:
-            if not p in D:
+            if p not in D:
                 D[p] = 0
         scalar = scalar*p**min([factors[i][p]//weights[i] for i in range(n)])
     return [invariants[i]*scalar**-weights[i] for i in range(n)]
-

src/sage/rings/polynomial/infinite_polynomial_ring.py

@@ -709,11 +709,11 @@ def __init__(self, R, names, order):
         self._names = tuple(names)
         if not isinstance(order, str):
             raise TypeError("The monomial order must be given as a string")
-        if not R in Rings().Commutative():
+        if R not in Rings().Commutative():
             raise TypeError("The given 'base ring' (= %s) must be a commutative ring" % R)
 
         # now, the input is accepted
-        if hasattr(R,'_underlying_ring'):
+        if hasattr(R, '_underlying_ring'):
             self._underlying_ring = R._underlying_ring
         else:
             self._underlying_ring = R.base_ring()

src/sage/rings/polynomial/multi_polynomial_ideal.py

@@ -2238,7 +2238,7 @@ def quotient(self, J):
         if not isinstance(J, MPolynomialIdeal):
             raise TypeError("J needs to be a multivariate polynomial ideal")
 
-        if not R is J.ring() and not R == J.ring():
+        if R is not J.ring() and not R == J.ring():
             raise TypeError("base rings do not match")
 
         from sage.libs.singular.function_factory import ff

src/sage/rings/polynomial/padics/polynomial_padic_capped_relative_dense.py

@@ -87,15 +87,15 @@ def __init__(self, parent, x=None, check=True, is_gen=False, construct = False,
         #We now coerce various types into lists of coefficients.  There are fast pathways for some types of polynomials
         if isinstance(x, Polynomial):
             if x.parent() is self.parent():
-                if not absprec is infinity or not relprec is infinity:
+                if absprec is not infinity or relprec is not infinity:
                     x._normalize()
                 self._poly = x._poly
                 self._valbase = x._valbase
                 self._valaddeds = x._valaddeds
                 self._relprecs = x._relprecs
                 self._normalized = x._normalized
                 self._list = x._list
-                if not absprec is infinity or not relprec is infinity:
+                if absprec is not infinity or relprec is not infinity:
                     self._adjust_prec_info(absprec, relprec)
                 return
             elif x.base_ring() is ZZ:
@@ -106,7 +106,7 @@ def __init__(self, parent, x=None, check=True, is_gen=False, construct = False,
                 self._comp_valaddeds()
                 self._normalized = len(self._valaddeds) == 0 or (min(self._valaddeds) == 0)
                 self._list = None
-                if not absprec is infinity or not relprec is infinity:
+                if absprec is not infinity or relprec is not infinity:
                     self._adjust_prec_info(absprec, relprec)
                 return
             else:
@@ -147,14 +147,14 @@ def __init__(self, parent, x=None, check=True, is_gen=False, construct = False,
             self._relprecs = []
             self._poly = PolynomialRing(ZZ, parent.variable_name())()
             self._normalized = True
-            if not absprec is infinity or not relprec is infinity:
+            if absprec is not infinity or relprec is not infinity:
                 self._adjust_prec_info(absprec, relprec)
         else:
             self._valaddeds = [c - self._valbase for c in self._valaddeds]
             self._relprecs = [a.precision_absolute() - self._valbase for a in x]
             self._poly = PolynomialRing(ZZ, parent.variable_name())([a >> self._valbase for a in x])
             self._normalized = True
-            if not absprec is infinity or not relprec is infinity:
+            if absprec is not infinity or relprec is not infinity:
                 self._adjust_prec_info(absprec, relprec)
 
     def _new_constant_poly(self, a, P):
@@ -702,21 +702,21 @@ def _unsafe_mutate(self, n, value):
                 self._poly._unsafe_mutate(self, n, 0)
             if n < len(self._relprecs):
                 self._relprecs[n] = value.precision_absolute() - self._valbase
-                if not self._valaddeds is None:
+                if self._valaddeds is not None:
                     self._valaddeds[n] = value.valuation() - self._valbase
-                if not self._list is None:
+                if self._list is not None:
                     self._list[n] = value
             else:
                 self._relprecs.extend([infinity] * (n - len(self._relprecs)) + [value.precision_absolute() - self._valbase])
-                if not self._valaddeds is None:
+                if self._valaddeds is not None:
                     self._valaddeds.extend([infinity] * (n - len(self._relprecs)) + [value.valuation() - self._valbase])
-                if not self._list is None:
+                if self._list is not None:
                     zero = self.base_ring()(0)
                     self._list.extend([zero] * (n - len(self._relprecs)) + [value])
         else:
             basediff = self._valbase - value.valuation()
             self._valbase = value.valuation()
-            if not self._valaddeds is None:
+            if self._valaddeds is not None:
                 self._valaddeds = [c + basediff for c in self._valaddeds]
             self._poly = self._poly * self.base_ring().prime_pow(basediff)
             if value != 0:
@@ -728,7 +728,7 @@ def _unsafe_mutate(self, n, value):
             else:
                 self._relprecs.extend([infinity] * (n - len(self._relprecs)) + [value.precision_relative()])
             self._normalized = False
-            if not self._list is None:
+            if self._list is not None:
                 if n < len(self._list):
                     self._list[n] = value
                 else: