first adaptations for python3

basic_operation.py

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 import multiprocessing
+from functools import reduce
 
 from sage.all import Integer, ZZ, gcd, QQ, mod, floor, sqrt
 
@@ -336,12 +337,11 @@ def _spos_def_mats_lt(tpl):
 def _key_of_tuples(prec, cuspidal=False, hol=False):
     if cuspidal and not hol:
         return list(PrecisionDeg2(prec).pos_defs())
-    elif hol and cuspidal:
-        return prec.group_by_reduced_forms_with_sgn().keys()
-    elif hol and not cuspidal:
-        return prec.group_by_reduced_forms().keys()
-    else:
-        return list(PrecisionDeg2(prec))
+    if hol and cuspidal:
+        return list(prec.group_by_reduced_forms_with_sgn())
+    if hol and not cuspidal:
+        return list(prec.group_by_reduced_forms())
+    return list(PrecisionDeg2(prec))
 
 
 @cached_function

const.py

@@ -5,6 +5,7 @@
 
 from __future__ import print_function
 
+from functools import reduce
 from abc import ABCMeta, abstractmethod, abstractproperty
 import os
 import hashlib
@@ -91,7 +92,7 @@ def _frozen_wts(self):
         if isinstance(self.wts, list):
             return tuple(self.wts)
         else:
-            return frozenset((k, v) for k, v in self.wts.iteritems())
+            return frozenset((k, v) for k, v in self.wts.items())
 
     @property
     def _key(self):
@@ -119,7 +120,7 @@ def _calc_from_gens_dict(self, dct):
         def _monm(ws):
             return mul(dct[k] for k in ws)
 
-        return sum(_monm(k) * v for k, v in coeffs_dct.iteritems())
+        return sum(_monm(k) * v for k, v in coeffs_dct.items())
 
     def _polynomial_expr(self):
         R = PolynomialRing(QQ,

diff_operator_pullback_vector_valued.py

@@ -128,7 +128,7 @@ def _z_u_ring_zgens():
 
 def _from_z_dz_ring_to_diff_op(pol):
     pol = _Z_dZ_ring(pol)
-    d = {tuple(t): _Z_ring(v) for t, v in pol.dict().iteritems()}
+    d = {tuple(t): _Z_ring(v) for t, v in pol.dict().items()}
     return DiffZOperatorElement(d)
 
 
@@ -285,7 +285,7 @@ def fc_of_pullback_of_diff_eisen(l, k, m, A, D, u3, u4, verbose=False):
         # L_operator is a differential operator whose order <= m,
         # we truncate it.
         pol = _Z_ring(
-            {t: v for t, v in pol.dict().iteritems() if sum(list(t)) <= m})
+            {t: v for t, v in pol.dict().items() if sum(list(t)) <= m})
         _l_op_tmp = L_operator(k, m, A, D, r_ls, pol *
                                es.fourier_coefficient(mat), us, d_up_down_mlt)
         _l_op_tmp = _U_ring({(m - a, a): _l_op_tmp[_u1 ** (m - a) * _u2 ** a]
@@ -294,7 +294,7 @@ def fc_of_pullback_of_diff_eisen(l, k, m, A, D, u3, u4, verbose=False):
     res = res * QQ(mul(k + i for i in range(m))) ** (-1)
     res = res * _zeta(1 - l) * _zeta(1 - 2 * l + 2) * _zeta(1 - 2 * l + 4)
     if verbose:
-        print "Done computation of Fourier coefficient of pullback."
+        print("Done computation of Fourier coefficient of pullback.")
     return res
 
 
@@ -317,7 +317,7 @@ def _pullback_vector(l, D, u3, u4, space_of_cuspforms, verbose=False):
             l, k, j, tpl_to_half_int_mat(t), D, u3, u4,
             verbose=verbose) for t in tpls}
         pull_back_dct = {k: v.constant_coefficient()
-                         for k, v in pull_back_dct.iteritems()}
+                         for k, v in pull_back_dct.items()}
     return space_of_cuspforms._to_vector(pull_back_dct)
 
 

elements.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 from abc import ABCMeta, abstractmethod
 import operator
-from itertools import imap
+from functools import reduce
 
 import sage
 
@@ -20,7 +20,7 @@
 
 
 def to_sorted_fc_list(fc_dct):
-    dct = {k: v for k, v in fc_dct.iteritems() if v != 0}
+    dct = {k: v for k, v in fc_dct.items() if v != 0}
     keys = dct.keys()
     keys_sorted = sorted(keys, key=lambda x: (max(x[0], x[2]),
                                               x[0], x[2], abs(x[1]), x[1]))
@@ -61,7 +61,7 @@ def __mul__(self, other):
 
     def __eq__(self, other):
         if other == 0:
-            return all([x == 0 for x in self.fc_dct.itervalues()])
+            return all([x == 0 for x in self.fc_dct.values()])
         else:
             return self - other == 0
 
@@ -111,7 +111,7 @@ def __getitem__(self, idx):
         return self.fc_dct[idx]
 
     def iteritems(self):
-        return self.fc_dct.iteritems()
+        return self.fc_dct.items()
 
     def sorted_list(self):
         return to_sorted_fc_list(self.fc_dct)
@@ -160,7 +160,7 @@ def __init__(self, fc_dct, prec, base_ring=QQ, is_cuspidal=False):
 
     def __eq__(self, other):
         if other == 0:
-            return all([x == 0 for x in self.fc_dct.itervalues()])
+            return all([x == 0 for x in self.fc_dct.values()])
         else:
             return self - other == 0
 
@@ -303,14 +303,14 @@ def __pow__(self, other):
 
     def theta_operator4(self):
         dic = dict()
-        for k, v in self.fc_dct.iteritems():
+        for k, v in self.fc_dct.items():
             (n, r, m) = k
             dic[k] = (4 * n * m - r ** 2) * v
         return QexpLevel1(dic, self.prec, self.base_ring)
 
     def phi_operator(self):
         d = {n: self[(n, 0, 0)] for n in self.prec._phi_operator_prec()}
-        return {n: v for n, v in d.iteritems() if v != 0}
+        return {n: v for n, v in d.items() if v != 0}
 
     def gcd_of_coefficients(self):
         K = self.base_ring
@@ -349,7 +349,7 @@ def _differential_operator_monomial(self, a, b, c):
         del_tau^a del_z^b del_w^c
         '''
         fcmap = {(n, r, m): n ** a * r ** b * m ** c * v for (n, r, m), v
-                 in self.fc_dct.iteritems()}
+                 in self.fc_dct.items()}
         res = QexpLevel1(fcmap, self.prec, base_ring=self.base_ring,
                          is_cuspidal=self._is_cuspidal)
         return res
@@ -375,11 +375,11 @@ def theta_sym(self, j=2):
         pl = (r1 * u1 ** 2 + r2 * u1 * u2 + r3 * u2 ** 2) ** (j // 2)
         pldct = pl.dict()
         formsdict = {}
-        for (_, i), ply in pldct.iteritems():
+        for (_, i), ply in pldct.items():
             formsdict[i] = sum([v * self._differential_operator_monomial(a, b, c)
-                                for (a, b, c), v in ply.dict().iteritems()])
+                                for (a, b, c), v in ply.dict().items()])
         forms = [x for _, x in
-                 sorted([(i, v) for i, v in formsdict.iteritems()],
+                 sorted([(i, v) for i, v in formsdict.items()],
                         key=lambda x: x[0])]
         return SymWtGenElt(forms, self.prec, self.base_ring)
 
@@ -392,14 +392,14 @@ def change_ring(self, R=None, hom=None):
         if R is None:
             R = hom.codomain()
         fc_map = {}
-        for k, v in self.fc_dct.iteritems():
+        for k, v in self.fc_dct.items():
             fc_map[k] = hom(v)
         return QexpLevel1(fc_map, self.prec, base_ring=R,
                           is_cuspidal=self._is_cuspidal)
 
     def mod_p_map(self, p):
         fcmap = {}
-        for k, v in self.fc_dct.iteritems():
+        for k, v in self.fc_dct.items():
             if v != 0:
                 fcmap[k] = modulo(v, p, self.base_ring)
         return fcmap
@@ -543,7 +543,7 @@ def _differential_operator_monomial(self, a, b, c):
         fcmap = {(n, r, m): ((n - QQ(1) / QQ(2)) ** a *
                              (r + QQ(1) / QQ(2)) ** b *
                              (m - QQ(1) / QQ(2)) ** c * v)
-                 for (n, r, m), v in self.f_part.fc_dct.iteritems()}
+                 for (n, r, m), v in self.f_part.fc_dct.items()}
         f = QexpLevel1(fcmap, self.prec, base_ring=self.base_ring)
         return QseriesTimesQminushalf(f)
 
@@ -614,11 +614,11 @@ def __init__(self, wt, fc_dct, prec, base_ring=QQ,
         if given_reduced_tuples_only:
             if is_cuspidal or wt % 2 == 1:  # level 1 specific.
                 for rdf, col in \
-                        prec.group_by_reduced_forms_with_sgn().iteritems():
+                        prec.group_by_reduced_forms_with_sgn().items():
                     for t, sgn in col:
                         fc_dct[t] = fc_dct[rdf] * sgn ** wt
             else:
-                for rdf, col in prec.group_by_reduced_forms().iteritems():
+                for rdf, col in prec.group_by_reduced_forms().items():
                     for t in col:
                         fc_dct[t] = fc_dct[rdf]
         QexpLevel1.__init__(self, fc_dct, prec, base_ring=base_ring,
@@ -630,7 +630,7 @@ def wt(self):
 
     def __eq__(self, other):
         if other == 0:
-            return all([x == 0 for x in self.fc_dct.itervalues()])
+            return all(x == 0 for x in self.fc_dct.values())
         else:
             return self - other == 0
 
@@ -1164,4 +1164,4 @@ def modulo(x, p, K):
     a_s = [a ** i for i in range(d)]
     xl = x.list()
     xl_p = [mod(b, p).lift() for b in xl]
-    return sum(list(imap(operator.mul, a_s, xl_p)))
+    return sum(list(map(operator.mul, a_s, xl_p)))

hecke_module.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+from functools import reduce
 from abc import ABCMeta, abstractmethod, abstractproperty
 import operator
 

interpolate.py

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 import multiprocessing
+from functools import reduce
 
 from degree2.basic_operation import PrecisionDeg2
 from degree2.elements import ModFormQexpLevel1, QexpLevel1

rankin_cohen_diff.py

@@ -67,7 +67,7 @@ def _inc_weight(Q):
     for r11, r12, _ in group(rs, 3):
         rdct[r11] = 4 * r11
         rdct[r12] = 2 * r12
-    t = [t for t, v in Q.dict().iteritems() if v != 0][0]
+    t = [t for t, v in Q.dict().items() if v != 0][0]
     a = Q.map_coefficients(lambda f: f.subs(rdct))[t] / Q.subs({u1: 2 * u1})[t]
     return int(log(a) / log(2))
 
@@ -387,7 +387,7 @@ def _dct(gens, v):
         dct.update(_dct(gens_z, v3))
         return f.subs(dct)
 
-    res_dc = {k: pol_to_val(v) for k, v in pol_dc.iteritems()}
+    res_dc = {k: pol_to_val(v) for k, v in pol_dc.items()}
     return [res_dc[(j + 2 - i, i)] for i in range(j + 3)]
 
 

scalar_valued_smfs.py

@@ -2,6 +2,7 @@
 import os
 import operator
 from abc import ABCMeta, abstractproperty
+from functools import reduce
 import sage
 from sage.misc.cachefunc import cached_method, cached_function
 from sage.all import (QQ, save, load, gcd, PolynomialRing,
@@ -132,7 +133,7 @@ def load_cached_gens_from_file(prec):
     prec34_m17_51 = PrecisionDeg2([(34, -17, 51)])
 
     if Deg2global_gens_dict != {}:
-        a_ky = Deg2global_gens_dict.keys()[0]
+        a_ky = next(iter(Deg2global_gens_dict.keys()))
         if Deg2global_gens_dict[a_ky].prec >= prec:
             return None
 
@@ -147,7 +148,7 @@ def load_cached_gens_from_file(prec):
             gens_dct1 = load(os.path.join(cached_dir, '_fc_dict39.sobj'))
             gens_dct2 = load(os.path.join(cached_dir,
                                           '_fc_dict_tuples_34_-17_51.sobj'))
-            for k in gens_dct1.keys():
+            for k in gens_dct1:
                 gens_dct1[k].update(gens_dct2[k])
             gens_dct = {k: {t: gens_dct1[k][t] for t in prec}
                         for k in gens_dct1.keys()}
@@ -296,7 +297,7 @@ def x5_jacobi_g(n, r, prec=40):
     psr = x5_jacobi_pwsr((prec - 1) // 2)
     l_pol = psr[(n - 1) // 2]
     d = {}
-    a_key = l_pol.dict().keys()[0]
+    a_key = next(iter(l_pol.dict()))
     is_int_key = isinstance(a_key, int)
     is_etuple = isinstance(a_key, sage.rings.polynomial.polydict.ETuple)
     for k, v in l_pol.dict().items():
@@ -693,7 +694,7 @@ def _hecke_tp2_charpoly(self, p, var='x', algorithm='linbox'):
 
         def morph(a, b, f, m):
             G = (-1) ** m * f.subs({x: -x}) * f
-            alst = [[k // 2, v] for k, v in G.dict().iteritems()]
+            alst = [[k // 2, v] for k, v in G.dict().items()]
             F = sum([v * x ** k for k, v in alst])
             return a ** m * F.subs({x: (x - b) / a})
         f1 = morph(u ** 2 + u + 1, -p * u ** 3 - u ** 2 - p * u, f, m)

tests/test_eigenforms.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+from functools import reduce
 import unittest
 import operator
 
@@ -50,7 +51,7 @@ def polynomial_to_form(f, prec):
 
     def monom(t):
         return reduce(operator.mul, [f ** a for f, a in zip(gens, t)])
-    return sum([a * monom(t) for t, a in f.dict().iteritems()])
+    return sum([a * monom(t) for t, a in f.dict().items()])
 
 
 x47_fc_dct = load_cache("x47_fc_dct.sobj")
@@ -162,7 +163,7 @@ def test_wt_35_eigenvalues(self):
     def test_es4_eigenvalues(self):
         es4 = eisenstein_series_degree2(4, 25)
         d = {2: 45, 3: 280, 4: 1549, 5: 3276, 9: 69049, 25: 10256401}
-        for k, v in d.iteritems():
+        for k, v in d.items():
             self.assertTrue(es4.hecke_eigenvalue(k) == v)
 
     def test_cusp_sp_wt28_hecke_charpoly(self):

tests/test_fc_mul_add.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+from functools import reduce
 from degree2.scalar_valued_smfs import eisenstein_series_degree2, QexpLevel1,\
     x10_with_prec, x12_with_prec, x35_with_prec, ModFormQexpLevel1
 from degree2.basic_operation import PrecisionDeg2

tests/test_prec_class.py

@@ -27,7 +27,7 @@ def test_le(self):
     def test_group_by_reduced_forms_with_sgn(self):
         prec = 8
         bls = []
-        for t, ls in PrecisionDeg2(prec).group_by_reduced_forms_with_sgn().iteritems():
+        for t, ls in PrecisionDeg2(prec).group_by_reduced_forms_with_sgn().items():
             rdf_t, sgn_t = reduced_form_with_sign(t)
             for t1, sgn in ls:
                 _, sgn_t1 = reduced_form_with_sign(t1)

tests/test_pullback_se_vector_valued.py

@@ -99,13 +99,13 @@ def assert_pullback_scalar_valued(self, f, t0, ts, l, verbose=False):
         D = tpl_to_half_int_mat(t0)
         f = f * f[t0] ** (-1)
         if verbose:
-            print "Compute for %s" % (t0,)
+            print("Compute for %s" % (t0,))
         a = fc_of_pullback_of_diff_eisen(
             l, f.wt, 0, D, D, 1, 1, verbose=verbose)
         self.assertNotEqual(a, 0)
         for t in ts:
             if verbose:
-                print "Checking for %s" % (t, )
+                print("Checking for %s" % (t, ))
             A = tpl_to_half_int_mat(t)
             self.assertEqual(fc_of_pullback_of_diff_eisen(l, f.wt, 0, A, D, 1, 1, verbose=verbose),
                              a * f[t])
@@ -189,7 +189,7 @@ def assert_pullback_lin_comb(self, M, f, l, ts, verbose=False):
             A = tpl_to_half_int_mat(t)
             fc = fc_of_pullback_of_diff_eisen(l, k, j, A, D, u3_val, u4_val)
             if verbose:
-                print "Checking for t = %s" % (t, )
+                print("Checking for t = %s" % (t,))
             if j > 0:
                 self.assertEqual(fc, f_vec[t]._to_pol())
             else: