cython-lint : further fixes in quadratic forms

Author: fchapoton

src/sage/quadratic_forms/count_local_2.pyx

@@ -2,7 +2,6 @@ r"""
 Optimized counting of congruence solutions
 """
 from sage.arith.misc import is_prime, kronecker as kronecker_symbol, valuation
-from sage.rings.finite_rings.integer_mod cimport IntegerMod_gmp
 from sage.rings.finite_rings.integer_mod import Mod
 from sage.rings.finite_rings.integer_mod_ring import IntegerModRing
 
@@ -103,11 +102,6 @@ cdef CountAllLocalTypesNaive_cdef(Q, p, k, m, zvec, nzvec):
     R = p ** k
     Q1 = Q.change_ring(IntegerModRing(R))
 
-    # Cython Variables
-    cdef IntegerMod_gmp zero, one
-    zero = IntegerMod_gmp(IntegerModRing(R), 0)
-    one = IntegerMod_gmp(IntegerModRing(R), 1)
-
     # Initialize the counting vector
     count_vector = [0 for i in range(6)]
 
@@ -119,7 +113,7 @@ cdef CountAllLocalTypesNaive_cdef(Q, p, k, m, zvec, nzvec):
     m1 = Mod(m, R)
 
     # Count the local solutions
-    for i from 0 <= i < R_n:
+    for i in range(R_n):
 
         # Perform a carry (when value = R-1) until we can increment freely
         ptr = len(v)
@@ -128,20 +122,20 @@ cdef CountAllLocalTypesNaive_cdef(Q, p, k, m, zvec, nzvec):
             ptr += -1
 
         # Only increment if we're not already at the zero vector =)
-        if (ptr > 0):
+        if ptr > 0:
             v[ptr-1] += 1
 
         # Evaluate Q(v) quickly
         tmp_val = Mod(0, R)
         for a from 0 <= a < n:
             for b from a <= b < n:
-                tmp_val += Q1[a,b] * v[a] * v[b]
+                tmp_val += Q1[a, b] * v[a] * v[b]
 
         # Sort the solution by it's type
-        #if (Q1(v) == m1):
-        if (tmp_val == m1):
+        # if Q1(v) == m1:
+        if tmp_val == m1:
             solntype = local_solution_type_cdef(Q1, p, v, zvec, nzvec)
-            if (solntype != 0):
+            if solntype != 0:
                 count_vector[solntype] += 1
 
     # Generate the Bad-type and Total counts
@@ -187,11 +181,6 @@ def CountAllLocalTypesNaive(Q, p, k, m, zvec, nzvec):
     return CountAllLocalTypesNaive_cdef(Q, p, k, m, zvec, nzvec)
 
 
-
-
-
-
-
 cdef local_solution_type_cdef(Q, p, w, zvec, nzvec):
     """
     Internal routine to check if a given solution vector `w` (of `Q(w) =
@@ -209,91 +198,87 @@ cdef local_solution_type_cdef(Q, p, w, zvec, nzvec):
 
     # Check if the solution satisfies the zvec "zero" congruence conditions
     # (either zvec is empty or its components index the zero vector mod p)
-    if (zvec is None) or (not zvec):
+    if zvec is None or not zvec:
         zero_flag = True
     else:
         zero_flag = False
         i = 0
-        while ( (i < len(zvec)) and ((w[zvec[i]] % p) == 0) ):  # Increment so long as our entry is zero (mod p)
+        while i < len(zvec) and not w[zvec[i]] % p:  # Increment so long as our entry is zero (mod p)
             i += 1
-        if (i == len(zvec)):      # If we make it through all entries then the solution is zero (mod p)
+        if i == len(zvec):      # If we make it through all entries then the solution is zero (mod p)
             zero_flag = True
 
-
     # DIAGNOSTIC
-    #print("IsLocalSolutionType: Finished the Zero congruence condition test \n")
+    # print("IsLocalSolutionType: Finished the Zero congruence condition test \n")
 
     if not zero_flag:
         return <long> 0
 
     # DIAGNOSTIC
-    #print("IsLocalSolutionType: Passed the Zero congruence condition test \n")
+    # print("IsLocalSolutionType: Passed the Zero congruence condition test \n")
 
     # Check if the solution satisfies the nzvec "nonzero" congruence conditions
     # (nzvec is non-empty and its components index a non-zero vector mod p)
-    if (nzvec is None):
+    if nzvec is None:
         nonzero_flag = True
-    elif (len(nzvec) == 0):
+    elif len(nzvec) == 0:
         nonzero_flag = False           # Trivially no solutions in this case!
     else:
         nonzero_flag = False
         i = 0
-        while ((not nonzero_flag) and (i < len(nzvec))):
-            if ((w[nzvec[i]] % p) != 0):
+        while not nonzero_flag and i < len(nzvec):
+            if w[nzvec[i]] % p:
                 nonzero_flag = True           # The non-zero condition is satisfied when we find one non-zero entry
             i += 1
 
     if not nonzero_flag:
         return <long> 0
 
-
     # Check if the solution has the appropriate (local) type:
     # -------------------------------------------------------
 
     # 1: Check Good-type
-    for i from 0 <= i < n:
-        if (((w[i] % p) != 0)  and ((Q[i,i] % p) != 0)):
+    for i in range(n):
+        if w[i] % p and Q[i, i] % p:
             return <long> 1
-    if (p == 2):
-        for i from 0 <= i < (n - 1):
-            if (((Q[i,i+1] % p) != 0) and (((w[i] % p) != 0) or ((w[i+1] % p) != 0))):
+    if p == 2:
+        for i in range(n - 1):
+            if ((Q[i, i+1] % p)) and (((w[i] % p)) or ((w[i+1] % p))):
                 return <long> 1
 
-
     # 2: Check Zero-type
     Zero_flag = True
-    for i from 0 <= i < n:
-        if ((w[i] % p) != 0):
+    for i in range(n):
+        if w[i] % p:
             Zero_flag = False
     if Zero_flag:
         return <long> 2
 
-
     # Check if wS1 is zero or not
     wS1_nonzero_flag = False
     for i from 0 <= i < n:
 
         # Compute the valuation of each index, allowing for off-diagonal terms
-        if (Q[i,i] == 0):
-            if (i == 0):
-                val = valuation(Q[i,i+1], p)    # Look at the term to the right
-            elif (i == n - 1):
-                val = valuation(Q[i-1,i], p)    # Look at the term above
+        if Q[i, i] == 0:
+            if i == 0:
+                val = valuation(Q[i, i+1], p)   # Look at the term to the right
+            elif i == n - 1:
+                val = valuation(Q[i-1, i], p)   # Look at the term above
             else:
-                val = valuation(Q[i,i+1] + Q[i-1,i], p)    # Finds the valuation of the off-diagonal term since only one isn't zero
+                val = valuation(Q[i, i+1] + Q[i-1, i], p)  # Finds the valuation of the off-diagonal term since only one isn't zero
         else:
-            val = valuation(Q[i,i], p)
+            val = valuation(Q[i, i], p)
 
         # Test each index
-        if ((val == 1) and ((w[i] % p) != 0)):
+        if val == 1 and w[i] % p:
             wS1_nonzero_flag = True
 
     # 4: Check Bad-type I
-    if (wS1_nonzero_flag is True):
+    if wS1_nonzero_flag:
         return <long> 4
 
     # 5: Check Bad-type II
-    if (wS1_nonzero_flag is False):
+    if wS1_nonzero_flag:
         return <long> 5
 
     # Error if we get here! =o

src/sage/quadratic_forms/quadratic_form__evaluate.pyx

@@ -4,14 +4,15 @@
 def QFEvaluateVector(Q, v):
     r"""
     Evaluate this quadratic form `Q` on a vector or matrix of elements
-    coercible to the base ring of the quadratic form.  If a vector
-    is given, then the output will be the ring element `Q(v)`, but if a
-    matrix is given, then the output will be the quadratic form `Q'`
-    which in matrix notation is given by:
+    coercible to the base ring of the quadratic form.
+
+    If a vector is given, then the output will be the ring element
+    `Q(v)`, but if a matrix is given, then the output will be the
+    quadratic form `Q'` which in matrix notation is given by:
 
     .. MATH::
 
-            Q' = v^t\cdot Q\cdot v.
+        Q' = v^t\cdot Q\cdot v.
 
     .. NOTE::
 
@@ -43,7 +44,6 @@ def QFEvaluateVector(Q, v):
     return QFEvaluateVector_cdef(Q, v)
 
 
-
 cdef QFEvaluateVector_cdef(Q, v):
     r"""
     Routine to quickly evaluate a quadratic form `Q` on a vector `v`.  See
@@ -54,16 +54,15 @@ cdef QFEvaluateVector_cdef(Q, v):
     # (In matrix notation: A^t * Q * A)
     n = Q.dim()
 
-    tmp_val = Q.base_ring()(0)
-    for i from 0 <= i < n:
-        for j from i <= j < n:
-            tmp_val += Q[i,j] * v[i] * v[j]
+    tmp_val = Q.base_ring().zero()
+    for i in range(n):
+        for j in range(i, n):
+            tmp_val += Q[i, j] * v[i] * v[j]
 
     # Return the value (over R)
     return Q.base_ring().coerce(tmp_val)
 
 
-
 def QFEvaluateMatrix(Q, M, Q2):
     r"""
     Evaluate this quadratic form `Q` on a matrix `M` of elements coercible
@@ -72,7 +71,7 @@ def QFEvaluateMatrix(Q, M, Q2):
 
     .. MATH::
 
-            Q_2 = M^t\cdot Q\cdot M.
+        Q_2 = M^t\cdot Q\cdot M.
 
     .. NOTE::
 
@@ -125,14 +124,17 @@ cdef QFEvaluateMatrix_cdef(Q, M, Q2):
     # TODO: Check the dimensions of M are compatible with those of Q and Q2
 
     # Evaluate Q(M) into Q2
-    for k from 0 <= k < m:
-        for l from k <= l < m:
-            tmp_sum = Q2.base_ring()(0)
-            for i from 0 <= i < n:
-                for j from i <= j < n:
-                    if (k == l):
-                        tmp_sum += Q[i,j] * (M[i,k] * M[j,l])
-                    else:
-                        tmp_sum += Q[i,j] * (M[i,k] * M[j,l] + M[i,l] * M[j,k])
-            Q2[k,l] = tmp_sum
+    for k in range(m):
+        for l in range(k, m):
+            tmp_sum = Q2.base_ring().zero()
+            if k == l:
+                for i in range(n):
+                    for j in range(i, n):
+                        tmp_sum += Q[i, j] * (M[i, k] * M[j, l])
+            else:
+                for i in range(n):
+                    for j in range(i, n):
+                        tmp_sum += Q[i, j] * (M[i, k] * M[j, l] +
+                                              M[i, l] * M[j, k])
+            Q2[k, l] = tmp_sum
     return Q2