passagemath-ntl 10.6.36__cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

sage/rings/padics/pow_computer_ext.pyx

@@ -0,0 +1,2401 @@
+# sage_setup: distribution = sagemath-ntl
+# distutils: libraries = NTL_LIBRARIES gmp M_LIBRARIES
+# distutils: extra_compile_args = NTL_CFLAGS
+# distutils: include_dirs = NTL_INCDIR
+# distutils: library_dirs = NTL_LIBDIR
+# distutils: extra_link_args = NTL_LIBEXTRA
+# distutils: language = c++
+# sage.doctest: needs sage.rings.padics
+"""
+PowComputer_ext
+
+The classes in this file are designed to be attached to `p`-adic parents
+and elements for Cython access to properties of the parent.
+
+In addition to storing the defining polynomial (as an NTL polynomial)
+at different precisions, they also cache powers of p and data to speed
+right shifting of elements.
+
+The hierarchy of PowComputers splits first at whether it's for a base
+ring (Qp or Zp) or an extension.
+
+Among the extension classes (those in this file), they are first split
+by the type of NTL polynomial (ntl_ZZ_pX or ntl_ZZ_pEX), then by the
+amount and style of caching (see below).  Finally, there are
+subclasses of the ntl_ZZ_pX PowComputers that cache additional
+information for Eisenstein extensions.
+
+There are three styles of caching:
+
+    * FM: caches powers of p up to the cache_limit, only caches the
+      polynomial modulus and the ntl_ZZ_pContext of precision
+      prec_cap.
+
+    * small: Requires cache_limit = prec_cap.  Caches p^k for every k
+      up to the cache_limit and caches a polynomial modulus and a
+      ntl_ZZ_pContext for each such power of p.
+
+    * big: Caches as the small does up to cache_limit and caches
+      prec_cap.  Also has a dictionary that caches values above the
+      cache_limit when they are computed (rather than at ring creation
+      time).
+
+AUTHORS:
+
+- David Roe  (2008-01-01) initial version
+"""
+# ****************************************************************************
+#       Copyright (C) 2008 David Roe <roed.math@gmail.com>
+#                          William Stein <wstein@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#  as published by the Free Software Foundation; either version 2 of
+#  the License, or (at your option) any later version.
+#
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from cpython.list cimport *
+from cpython.dict cimport *
+
+from cysignals.signals cimport sig_on, sig_off
+
+include "../../libs/ntl/decl.pxi"
+
+from sage.misc.timing import cputime
+from sage.libs.gmp.mpz cimport *
+from sage.libs.ntl.ntl_ZZ_pContext cimport ntl_ZZ_pContext_factory
+from sage.libs.ntl.ntl_ZZ_pContext import ZZ_pContext_factory
+from sage.libs.ntl.ntl_ZZ cimport ntl_ZZ
+from sage.libs.ntl.ntl_ZZ_pX cimport ntl_ZZ_pX, ntl_ZZ_pX_Modulus
+from sage.rings.integer cimport Integer
+
+cdef extern from "../../ext/ccobject.h":
+    ZZ_c* Allocate_ZZ_array "Allocate_array<ZZ>"(size_t n)
+    void Delete_ZZ_array "Delete_array<ZZ>"(ZZ_c* v)
+    ZZ_pX_c* Allocate_ZZ_pX_array "Allocate_array<ZZ_pX>"(size_t n)
+    void Delete_ZZ_pX_array "Delete_array<ZZ_pX>"(ZZ_pX_c* v)
+    ZZ_pX_Multiplier_c* Allocate_ZZ_pX_Multiplier_array "Allocate_array<ZZ_pXMultiplier>"(size_t n)
+    void Delete_ZZ_pX_Multiplier_array "Delete_array<ZZ_pXMultiplier>"(ZZ_pX_Multiplier_c* v)
+    ZZ_pX_Modulus_c* Allocate_ZZ_pX_Modulus_array "Allocate_array<ZZ_pXModulus>"(size_t n)
+    void Delete_ZZ_pX_Modulus_array "Delete_array<ZZ_pXModulus>"(ZZ_pX_Modulus_c* v)
+
+cdef int ZZ_pX_Eis_init(PowComputer_ZZ_pX prime_pow, ntl_ZZ_pX shift_seed) except -1:
+    """
+    Precomputes quantities for shifting right in Eisenstein extensions.
+
+    INPUT:
+
+    - ``prime_pow`` -- the PowComputer to be initialized
+    - ``shift_seed`` -- x^e/p as a polynomial of degree at most e-1 in x
+
+    EXAMPLES::
+
+        sage: A = PowComputer_ext_maker(5, 10, 10, 40, False, ntl.ZZ_pX([-5,65,125,0,1],5^10), 'small','e',ntl.ZZ_pX([1,-13,-25],5^10))  # indirect doctest
+    """
+    if prime_pow.deg <= 1:
+        raise ValueError("Eisenstein extension must have degree at least 2")
+    cdef unsigned long D = prime_pow.deg - 1
+    cdef int low_length = 0
+    cdef int high_length = 0
+    if sizeof(long) > 4 and D > 4294967295: # 2^32 - 1
+        low_length += 32
+        D = D >> 32
+    if D >= 65536: # 2^16
+        low_length += 16
+        D = D >> 16
+    if D >= 256: # 2^8
+        low_length += 8
+        D = D >> 8
+    if D >= 16: # 2^4
+        low_length += 4
+        D = D >> 4
+    if D >= 4: # 2^2
+        low_length += 2
+        D = D >> 2
+    if D >= 2: # 2^1
+        low_length += 1
+        D = D >> 1
+    low_length += 1
+    # low_length is the number of elements in the list we need to store.
+    # if deg = 2, low_length = 1 (store p/x)
+    # if deg = 3,4, low_length = 2 (store p/x, p/x^2)
+    # if deg = 5,6,7,8, low_length = 3 (store p/x, p/x^2, p/x^4)
+    # if deg = 9,...,16, low_length = 4 (store p/x, p/x^2, p/x^4, p/x^8)
+
+    # Now we do the same process for powers of p, ie storing p^(2^k)/x^(e*2^k)
+    D = prime_pow.prec_cap - 1
+    high_length = 0
+    if sizeof(long) > 4 and D > 4294967295: # 2^32 - 1
+        high_length += 32
+        D = D >> 32
+    if D >= 65536: # 2^16
+        high_length += 16
+        D = D >> 16
+    if D >= 256: # 2^8
+        high_length += 8
+        D = D >> 8
+    if D >= 16: # 2^4
+        high_length += 4
+        D = D >> 4
+    if D >= 4: # 2^2
+        high_length += 2
+        D = D >> 2
+    if D >= 2: # 2^1
+        high_length += 1
+        D = D >> 1
+    high_length += 1
+    # high_length is the number of elements in the list we need to store.
+    # if prec_cap = 2, high_length = 1 (store p/x^e)
+    # if prec_cap = 3,4, high_length = 2 (store p/x^e, p^2/x^(2e))
+    # if prec_cap = 5,6,7,8, high_length = 3 (store p/x^e, p^2/x^(2e), p^4/x^(4e))
+    # if prec_cap = 9,...,16, high_length = 4 (store p/x, p^2/x^(2e), p^4/x^(4e), p^8/x^(8e))
+
+    cdef ZZ_pX_Multiplier_c* low_shifter_m
+    cdef ZZ_pX_Multiplier_c* high_shifter_m
+    cdef ZZ_pX_c* low_shifter_p
+    cdef ZZ_pX_c* high_shifter_p
+    cdef bint multiplier
+    if isinstance(prime_pow, PowComputer_ZZ_pX_FM_Eis):
+        multiplier = 1
+        (<PowComputer_ZZ_pX_FM_Eis>prime_pow).low_length = low_length
+        (<PowComputer_ZZ_pX_FM_Eis>prime_pow).high_length = high_length
+
+        sig_on()
+        (<PowComputer_ZZ_pX_FM_Eis>prime_pow).low_shifter = Allocate_ZZ_pX_Multiplier_array(low_length)
+        (<PowComputer_ZZ_pX_FM_Eis>prime_pow).high_shifter = Allocate_ZZ_pX_Multiplier_array(high_length)
+        sig_off()
+        low_shifter_m = (<PowComputer_ZZ_pX_FM_Eis>prime_pow).low_shifter
+        high_shifter_m = (<PowComputer_ZZ_pX_FM_Eis>prime_pow).high_shifter
+    elif isinstance(prime_pow, PowComputer_ZZ_pX_small_Eis):
+        multiplier = 0
+        (<PowComputer_ZZ_pX_small_Eis>prime_pow).low_length = low_length
+        (<PowComputer_ZZ_pX_small_Eis>prime_pow).high_length = high_length
+
+        sig_on()
+        (<PowComputer_ZZ_pX_small_Eis>prime_pow).low_shifter = Allocate_ZZ_pX_array(low_length)
+        (<PowComputer_ZZ_pX_small_Eis>prime_pow).high_shifter = Allocate_ZZ_pX_array(high_length)
+        sig_off()
+        low_shifter_p = (<PowComputer_ZZ_pX_small_Eis>prime_pow).low_shifter
+        high_shifter_p = (<PowComputer_ZZ_pX_small_Eis>prime_pow).high_shifter
+    elif isinstance(prime_pow, PowComputer_ZZ_pX_big_Eis):
+        multiplier = 0
+        (<PowComputer_ZZ_pX_big_Eis>prime_pow).low_length = low_length
+        (<PowComputer_ZZ_pX_big_Eis>prime_pow).high_length = high_length
+
+        sig_on()
+        (<PowComputer_ZZ_pX_big_Eis>prime_pow).low_shifter = Allocate_ZZ_pX_array(low_length)
+        (<PowComputer_ZZ_pX_big_Eis>prime_pow).high_shifter = Allocate_ZZ_pX_array(high_length)
+        sig_off()
+        low_shifter_p = (<PowComputer_ZZ_pX_big_Eis>prime_pow).low_shifter
+        high_shifter_p = (<PowComputer_ZZ_pX_big_Eis>prime_pow).high_shifter
+    else:
+        raise TypeError("unrecognized Eisenstein type")
+
+    cdef long i
+    cdef ZZ_pX_c into_multiplier, shift_seed_inv
+    # We obtain successive p/x^(2^i) by squaring and then dividing by p.  So we need one extra digit of precision.
+    prime_pow.restore_top_context()
+    #cdef ntl_ZZ_pContext_class cup = prime_pow.get_context(prime_pow.prec_cap + low_length)
+    #cup.restore_c()
+    #ZZ_pX_conv_modulus(modup, prime_pow.get_top_modulus()[0].val(), cup.x)
+    #ZZ_div(a, ZZ_p_rep(ZZ_pX_ConstTerm(modup)), prime_pow.small_powers[1])
+    #ZZ_InvMod(a, a, prime_pow.pow_ZZ_tmp(prime_pow.prec_cap + low_length)[0])
+    #ZZ_negate(a, a)
+    ##cdef ntl_ZZ_pX printer = ntl_ZZ_pX([], prime_pow.get_context(prime_pow.prec_cap))
+    ##printer.x = modup
+    # Note that we're losing one digit of precision here.
+    # This is correct because right shifting does not preserve precision.
+    # a is now the negative of the inverse of the unit part of the constant of the defining polynomial (there's a mouthful)
+    #ZZ_pX_RightShift(tmp, modup, 1)
+    ##printer.x = modup
+    #ZZ_pX_mul_ZZ_p(tmp, tmp, ZZ_to_ZZ_p(a))
+    # tmp is now p/x
+    #ZZ_pX_conv_modulus(into_multiplier, tmp, prime_pow.get_top_context().x)
+    ##printer.x = into_multiplier
+    #if multiplier:
+    #    ZZ_pX_Multiplier_construct(low_shifter_m)
+    #    ZZ_pX_Multiplier_build(low_shifter_m[0], into_multiplier, prime_pow.get_top_modulus()[0])
+    #else:
+    #    ZZ_pX_construct(low_shifter_p)
+    #    low_shifter_p[0] = into_multiplier
+    ##printer.x = (low_shifter[0]).val()
+    ZZ_pX_InvMod_newton_ram(shift_seed_inv, shift_seed.x, prime_pow.get_top_modulus()[0], prime_pow.get_top_context().x)
+    for i in range(low_length):
+        # Currently tmp = p / x^(2^(i-1)).  Squaring yields p^2 / x^(2^i)
+        #ZZ_pX_SqrMod(tmp, tmp, modup)
+        # Now we divide by p.
+        #ZZ_pX_right_pshift(tmp, tmp, prime_pow.small_powers[1], cup.x)
+        #ZZ_pX_conv_modulus(into_multiplier, tmp, prime_pow.get_top_context().x)
+        ZZ_pX_PowerXMod_long_pre(into_multiplier, prime_pow.e - (1L << i), prime_pow.get_top_modulus()[0])
+        ZZ_pX_MulMod_pre(into_multiplier, into_multiplier, shift_seed_inv, prime_pow.get_top_modulus()[0])
+        ##printer.x = into_multiplier
+        if multiplier:
+            ZZ_pX_Multiplier_build(low_shifter_m[i], into_multiplier, prime_pow.get_top_modulus()[0])
+        else:
+            low_shifter_p[i] = into_multiplier
+
+    # Now we handle high_shifter.
+    # We can obtain p/x^e by computing the inverse of x^e/p.
+    # Note that modup is still defined from before
+    ###cup.restore_c()
+
+    ###ZZ_pX_conv_modulus(modup, prime_pow.get_top_modulus()[0].val(), cup.x)
+    ###ZZ_pX_SetCoeff_long(modup, prime_pow.deg, 0)
+    ###ZZ_pX_negate(modup, modup)
+    ###ZZ_pX_right_pshift(into_multiplier, modup, prime_pow.small_powers[1], prime_pow.get_top_context().x)
+
+    ###printer.x = into_multiplier
+
+    # into_multiplier now holds x^e/p
+    # prime_pow.c.x should have been restored, but we make sure
+    prime_pow.restore_top_context()
+    ##printer.x = prime_pow.get_top_modulus()[0].val()
+    into_multiplier = shift_seed_inv
+    #ZZ_pX_InvMod_newton_ram(into_multiplier, shift_seed.x, prime_pow.get_top_modulus()[0], prime_pow.get_top_context().x)
+    ##printer.x = into_multiplier
+    ##ZZ_pX_MulMod_pre(printer.x, into_multiplier, shift_seed.x, prime_pow.get_top_modulus()[0])
+    if multiplier:
+        ZZ_pX_Multiplier_build(high_shifter_m[0], into_multiplier, prime_pow.get_top_modulus()[0])
+    else:
+        high_shifter_p[0] = into_multiplier
+    # Now we cache powers of p/x^e.  This is a unit, so we don't have to worry about precision issues (yay!)
+    for i in range(1, high_length):
+        ZZ_pX_SqrMod_pre(into_multiplier, into_multiplier, prime_pow.get_top_modulus()[0])
+        if multiplier:
+            ZZ_pX_Multiplier_build(high_shifter_m[i], into_multiplier, prime_pow.get_top_modulus()[0])
+        else:
+            high_shifter_p[i] = into_multiplier
+
+
+def ZZ_pX_eis_shift_test(_shifter, _a, _n, _finalprec):
+    """
+    Shift ``_a`` right ``_n`` x-adic digits, where x is considered modulo the
+    polynomial in ``_shifter``.
+
+    EXAMPLES::
+
+        sage: from sage.rings.padics.pow_computer_ext import ZZ_pX_eis_shift_test
+        sage: A = PowComputer_ext_maker(5, 3, 10, 40, False, ntl.ZZ_pX([-5,75,15,0,1],5^10), 'big', 'e',ntl.ZZ_pX([1,-15,-3],5^10))
+        sage: ZZ_pX_eis_shift_test(A, [0, 1], 1, 5)
+        [1]
+        sage: ZZ_pX_eis_shift_test(A, [0, 0, 1], 1, 5)
+        [0 1]
+        sage: ZZ_pX_eis_shift_test(A, [5], 1, 5)
+        [75 15 0 1]
+        sage: ZZ_pX_eis_shift_test(A, [1], 1, 5)
+        []
+        sage: ZZ_pX_eis_shift_test(A, [17, 91, 8, -2], 1, 5)
+        [316 53 3123 3]
+        sage: ZZ_pX_eis_shift_test(A, [316, 53, 3123, 3], -1, 5)
+        [15 91 8 3123]
+        sage: ZZ_pX_eis_shift_test(A, [15, 91, 8, 3123], 1, 5)
+        [316 53 3123 3]
+    """
+    cdef PowComputer_ZZ_pX shifter = <PowComputer_ZZ_pX?>_shifter
+    cdef ntl_ZZ_pX x = <ntl_ZZ_pX>ntl_ZZ_pX(modulus=shifter._prime()**_finalprec)
+    cdef ntl_ZZ_pX a = <ntl_ZZ_pX>ntl_ZZ_pX(_a, modulus=shifter._prime()**_finalprec)
+    cdef long n = _n
+    cdef long finalprec = _finalprec
+    ZZ_pX_eis_shift_p(shifter, &x.x, &a.x, n, finalprec)
+    return x
+
+
+cdef int ZZ_pX_eis_shift_p(PowComputer_ZZ_pX self, ZZ_pX_c* x, ZZ_pX_c* a, long n, long finalprec) except -1:
+    """
+    Eis-shifts a over by n and puts the result into x.
+
+    Negative n corresponds to multiplying by x^-n.
+
+    TESTS::
+
+        sage: R.<x> = QQ[]
+        sage: K = Qp(11,10)
+        sage: J.<a> = K.extension(x^30 - 11)
+        sage: M.<t> = PowerSeriesRing(J)
+        sage: S.<x,y> = QQ[]
+        sage: xr = O(a^152)*t + (8*a^2 + 10*a^32 + 7*a^62 + 10*a^92 + 7*a^122 + O(a^152))*t^2 + O(a^154)*t^3 + (2*a^4 + 10*a^64 + 2*a^124 + O(a^154))*t^4 + O(a^156)*t^5 + (5*a^6 + 2*a^96 + a^126 + O(a^156))*t^6 + O(a^158)*t^7 + (7*a^8 + 6*a^38 + 8*a^68 + 2*a^98 + 5*a^128 + O(a^158))*t^8 + O(a^160)*t^9 + (8*a^10 + 10*a^40 + a^70 + 5*a^130 + O(a^160))*t^10 + O(a^162)*t^11 + (9*a^12 + 7*a^42 + 8*a^72 + 6*a^102 + 9*a^132 + O(a^162))*t^12 + O(a^164)*t^13 + (2*a^14 + 5*a^44 + 3*a^74 + a^104 + 4*a^134 + O(a^164))*t^14 + O(a^166)*t^15 + (2*a^16 + 5*a^46 + 8*a^76 + 5*a^106 + 7*a^136 + O(a^166))*t^16 + O(a^168)*t^17 + (7*a^18 + 3*a^48 + 6*a^78 + 9*a^138 + O(a^168))*t^18 + O(a^172)*t^19 + (7*a^50 + 3*a^80 + 5*a^110 + 5*a^140 + 7*a^170 + O(a^172))*t^20 + O(a^172)*t^21 + (a^22 + a^52 + 3*a^82 + 3*a^112 + 2*a^142 + O(a^172))*t^22 + O(a^174)*t^23 + (4*a^24 + 7*a^54 + 9*a^84 + 4*a^114 + 7*a^144 + O(a^174))*t^24 + O(a^176)*t^25 + (3*a^26 + 8*a^56 + 8*a^116 + 5*a^146 + O(a^176))*t^26 + O(a^178)*t^27 + (2*a^28 + 2*a^58 + 6*a^88 + a^118 + 10*a^148 + O(a^178))*t^28 + O(a^180)*t^29 + (8*a^30 + 5*a^60 + 8*a^90 + 5*a^120 + 6*a^150 + O(a^180))*t^30 + O(a^184)*t^31 + (7*a^62 + 9*a^92 + 2*a^182 + O(a^184))*t^32
+        sage: yr = xr^2
+        sage: dtr = xr.derivative()
+        sage: f_dtr = yr*dtr; f_dtr
+        O(a^456)*t^2 + O(a^306)*t^3 + O(a^156)*t^4 + (a^6 + 6*a^36 + 2*a^66 + 7*a^96 + 4*a^126 + O(a^156))*t^5 + O(a^158)*t^6 + (a^8 + 2*a^38 + 8*a^68 + 3*a^98 + O(a^158))*t^7 + O(a^160)*t^8 + (8*a^40 + 10*a^100 + 5*a^130 + O(a^160))*t^9 + O(a^162)*t^10 + (2*a^12 + 5*a^42 + 3*a^72 + 7*a^102 + O(a^162))*t^11 + O(a^164)*t^12 + (8*a^14 + a^44 + 6*a^74 + 4*a^104 + 7*a^134 + O(a^164))*t^13 + O(a^166)*t^14 + (2*a^16 + 8*a^46 + 5*a^106 + 4*a^136 + O(a^166))*t^15 + O(a^168)*t^16 + (a^18 + 6*a^48 + 5*a^78 + 2*a^108 + 9*a^138 + O(a^168))*t^17 + O(a^170)*t^18 + (8*a^50 + 2*a^110 + O(a^170))*t^19 + O(a^172)*t^20 + (4*a^52 + 2*a^82 + 7*a^112 + 5*a^142 + O(a^172))*t^21 + O(a^174)*t^22 + (2*a^54 + 3*a^84 + 8*a^114 + 6*a^144 + O(a^174))*t^23 + O(a^176)*t^24 + (a^26 + 6*a^56 + 4*a^86 + 9*a^116 + 3*a^146 + O(a^176))*t^25 + O(a^178)*t^26 + (10*a^28 + 5*a^58 + 4*a^88 + 10*a^118 + 6*a^148 + O(a^178))*t^27 + O(a^180)*t^28 + (5*a^30 + 5*a^60 + 4*a^90 + 9*a^120 + 3*a^150 + O(a^180))*t^29 + O(a^182)*t^30 + (4*a^32 + 10*a^62 + 5*a^92 + 7*a^122 + 3*a^152 + O(a^182))*t^31 + O(a^184)*t^32 + (5*a^34 + 9*a^94 + 3*a^124 + 6*a^154 + O(a^184))*t^33 + O(a^186)*t^34 + (4*a^36 + 3*a^66 + 10*a^96 + 2*a^126 + 6*a^156 + O(a^186))*t^35 + O(a^188)*t^36 + (6*a^38 + 9*a^68 + 7*a^128 + 10*a^158 + O(a^188))*t^37 + O(a^190)*t^38 + (7*a^40 + 3*a^70 + 4*a^100 + 4*a^130 + 8*a^160 + O(a^190))*t^39 + O(a^192)*t^40 + (a^42 + 10*a^72 + 10*a^102 + a^132 + 7*a^162 + O(a^192))*t^41 + O(a^194)*t^42 + (8*a^74 + 8*a^104 + 9*a^134 + 7*a^164 + O(a^194))*t^43 + O(a^196)*t^44 + (10*a^136 + 2*a^166 + O(a^196))*t^45 + O(a^198)*t^46 + (7*a^48 + 10*a^78 + 5*a^108 + 8*a^138 + 3*a^168 + O(a^198))*t^47 + O(a^200)*t^48 + (6*a^50 + 5*a^80 + a^110 + 6*a^170 + O(a^200))*t^49 + O(a^202)*t^50 + (a^52 + 8*a^82 + 2*a^112 + 10*a^172 + O(a^202))*t^51 + O(a^204)*t^52 + (9*a^54 + 2*a^84 + 6*a^114 + 4*a^144 + O(a^204))*t^53 + O(a^206)*t^54 + (2*a^56 + 5*a^86 + 2*a^116 + 4*a^146 + a^176 + O(a^206))*t^55 + O(a^208)*t^56 + (3*a^58 + 3*a^88 + a^118 + 5*a^148 + 2*a^178 + O(a^208))*t^57 + O(a^210)*t^58 + (5*a^60 + 10*a^90 + 9*a^120 + a^150 + 6*a^180 + O(a^210))*t^59 + O(a^212)*t^60 + (4*a^62 + 9*a^92 + 7*a^122 + 7*a^152 + 9*a^182 + O(a^212))*t^61 + O(a^214)*t^62 + (10*a^64 + 8*a^94 + 6*a^124 + 8*a^154 + 4*a^184 + O(a^214))*t^63 + O(a^216)*t^64 + (4*a^126 + 10*a^156 + 9*a^186 + O(a^216))*t^65 + O(a^218)*t^66 + (7*a^98 + 4*a^128 + 6*a^158 + 6*a^188 + O(a^218))*t^67 + O(a^220)*t^68 + (3*a^70 + 6*a^100 + 8*a^130 + 9*a^160 + 10*a^190 + O(a^220))*t^69 + O(a^222)*t^70 + (9*a^72 + 5*a^102 + 9*a^132 + 3*a^162 + 10*a^192 + O(a^222))*t^71 + O(a^224)*t^72 + (3*a^74 + 8*a^104 + 7*a^134 + 2*a^164 + O(a^224))*t^73 + O(a^226)*t^74 + (10*a^76 + a^106 + 2*a^136 + 4*a^166 + 9*a^196 + O(a^226))*t^75 + O(a^228)*t^76 + (3*a^78 + 6*a^108 + 9*a^138 + 4*a^168 + 5*a^198 + O(a^228))*t^77 + O(a^230)*t^78 + (4*a^80 + 10*a^110 + 7*a^170 + 8*a^200 + O(a^230))*t^79 + O(a^232)*t^80 + (5*a^82 + 4*a^112 + 9*a^142 + 8*a^172 + 8*a^202 + O(a^232))*t^81 + O(a^234)*t^82 + (4*a^84 + 9*a^114 + 8*a^144 + 2*a^174 + 6*a^204 + O(a^234))*t^83 + O(a^236)*t^84 + (3*a^86 + 5*a^116 + 4*a^146 + 8*a^206 + O(a^236))*t^85 + O(a^238)*t^86 + (a^118 + 7*a^148 + 6*a^208 + O(a^238))*t^87 + O(a^240)*t^88 + (4*a^90 + 9*a^120 + 9*a^150 + 6*a^180 + 6*a^210 + O(a^240))*t^89 + O(a^244)*t^90 + (10*a^122 + 3*a^152 + 8*a^182 + 4*a^212 + 2*a^242 + O(a^244))*t^91 + O(a^276)*t^92 + (9*a^154 + 10*a^184 + 10*a^214 + 7*a^244 + 9*a^274 + O(a^276))*t^93 + O(a^308)*t^94 + (9*a^186 + 4*a^216 + 5*a^246 + a^276 + 10*a^306 + O(a^308))*t^95
+    """
+    cdef ZZ_pX_c low_part
+    cdef ZZ_pX_c shifted_high_part
+    cdef ZZ_pX_c powerx
+    cdef ZZ_pX_c lowshift
+    cdef ZZ_pX_c highshift
+    cdef ZZ_pX_c working, working2
+    cdef ntl_ZZ_pContext_class c
+    cdef ZZ_pX_Modulus_c* m
+    cdef long pshift = n / self.e
+    cdef long eis_part = n % self.e
+    cdef long two_shift = 1
+    cdef int i
+    cdef ZZ_pX_c* high_shifter
+    cdef ZZ_pX_c* low_shifter
+    cdef ZZ_pX_Multiplier_c* high_shifter_fm
+    cdef ZZ_pX_Multiplier_c* low_shifter_fm
+    cdef bint fm
+    cdef long high_length
+    if isinstance(self, PowComputer_ZZ_pX_small_Eis):
+        high_shifter = (<PowComputer_ZZ_pX_small_Eis>self).high_shifter
+        low_shifter = (<PowComputer_ZZ_pX_small_Eis>self).low_shifter
+        high_length = (<PowComputer_ZZ_pX_small_Eis>self).high_length
+        fm = False
+    elif isinstance(self, PowComputer_ZZ_pX_big_Eis):
+        high_shifter = (<PowComputer_ZZ_pX_big_Eis>self).high_shifter
+        low_shifter = (<PowComputer_ZZ_pX_big_Eis>self).low_shifter
+        high_length = (<PowComputer_ZZ_pX_big_Eis>self).high_length
+        fm = False
+    elif isinstance(self, PowComputer_ZZ_pX_FM_Eis):
+        high_shifter_fm = (<PowComputer_ZZ_pX_FM_Eis>self).high_shifter
+        low_shifter_fm = (<PowComputer_ZZ_pX_FM_Eis>self).low_shifter
+        high_length = (<PowComputer_ZZ_pX_FM_Eis>self).high_length
+        fm = True
+    else:
+        raise TypeError("inconsistent type")
+
+    if n < 0:
+        if fm:
+            c = self.get_top_context()
+            m = self.get_top_modulus()
+        else:
+            c = self.get_context(finalprec)
+            m = self.get_modulus(finalprec)
+        c.restore_c()
+        ##printer = ntl_ZZ_pX([],c)
+        ZZ_pX_PowerXMod_long_pre(powerx, -n, m[0])
+        ##printer.x = powerx
+        ZZ_pX_conv_modulus(x[0], a[0], c.x)
+        ZZ_pX_MulMod_pre(x[0], powerx, a[0], m[0])
+        ##printer.x = x[0]
+        return 0
+    elif n == 0:
+        if x != a:
+            if fm:
+                c = self.get_top_context()
+            else:
+                c = self.get_context(finalprec)
+            ZZ_pX_conv_modulus(x[0], a[0], c.x)
+        return 0
+
+# The following doesn't work, sadly.  It should be possible to precompute and do better than what I replace this code with.
+#    c = self.get_context(finalprec)
+#    m = self.get_modulus(finalprec)[0]
+#    printer = ntl_ZZ_pX([],c)
+#    if pshift:
+#        ZZ_pX_right_pshift(x[0], a[0], self.pow_ZZ_tmp(pshift)[0], c.x)
+#    else:
+#        ZZ_pX_conv_modulus(x[0], a[0], c.x)
+#    ##printer.x = a[0]
+#    c.restore_c()
+#    if pshift:
+#        i = 0
+#        # This line restores the top context
+#        #ZZ_pX_right_pshift(x[0], x[0], self.pow_ZZ_tmp(pshift)[0], c.x)
+#        ##printer.x = x[0]
+#        if pshift >= self.prec_cap:
+#            # shifter = p^(2^(high_length - 1))/x^(e*2^(high_length - 1))
+#            ZZ_pX_conv_modulus(shifter, high_shifter[high_length-1], c.x)
+#            ##printer.x = shifter
+#            # if val = r + s * 2^(high_length - 1)
+#            # then shifter = p^(s*2^(high_length - 1))/x^(e*s*2^(high_length - 1))
+#            ZZ_pX_PowerMod_long_pre(shifter, shifter, (pshift / (1L << (high_length - 1))), m)
+#            ##printer.x = shifter
+#            ZZ_pX_MulMod_pre(x[0], x[0], shifter, m)
+#            ##printer.x = shifter
+#            # Now we only need to multiply self.unit by p^r/x^(e*r) where r < 2^(high_length - 1), which is tractible.
+#            pshift = pshift % (1L << (high_length - 1))
+#        while pshift > 0:
+#            if pshift & 1:
+#                ##printer.x = x[0]
+#                ZZ_pX_conv_modulus(highshift, high_shifter[i], c.x)
+#                ZZ_pX_MulMod_pre(x[0], x[0], highshift, m)
+#            i += 1
+#            pshift = pshift >> 1
+    if fm:
+        c = self.get_top_context()
+        m = self.get_top_modulus()
+    else:
+        c = self.get_context(finalprec + pshift + 1)
+    c.restore_c()
+    ZZ_pX_conv_modulus(working, a[0], c.x)
+    if pshift:
+        while pshift > 0:
+            pshift -= 1
+            if fm:
+                ZZ_pX_right_pshift(working, working, self.pow_ZZ_tmp(1)[0],c.x)
+                ZZ_pX_MulMod_premul(working, working, high_shifter_fm[0], m[0])
+            else:
+                c = self.get_context(finalprec + pshift + 1)
+                m = self.get_modulus(finalprec + pshift + 1)
+                ZZ_pX_right_pshift(working, working, self.pow_ZZ_tmp(1)[0],c.x)
+                ZZ_pX_conv_modulus(highshift, high_shifter[0], c.x)
+                ZZ_pX_MulMod_pre(working, working, highshift, m[0])
+    elif not fm:
+        m = self.get_modulus(finalprec + 1)
+    ZZ_pX_conv_modulus(working2, working, c.x)
+    i = 0
+    two_shift = 1
+    while eis_part > 0:
+        if eis_part & 1:
+            ##printer.x = working2
+            ZZ_pX_RightShift(shifted_high_part, working2, two_shift)
+            ##printer.x = shifted_high_part
+            ZZ_pX_LeftShift(low_part, shifted_high_part, two_shift)
+            ZZ_pX_sub(low_part, working2, low_part)
+            ##printer.x = low_part
+            ZZ_pX_right_pshift(low_part, low_part, self.pow_ZZ_tmp(1)[0], c.x)
+            ##printer.x = low_part
+            if fm:
+                ZZ_pX_MulMod_premul(low_part, low_part, low_shifter_fm[i], m[0])
+            else:
+                ZZ_pX_conv_modulus(lowshift, low_shifter[i], c.x)
+                ZZ_pX_MulMod_pre(low_part, low_part, lowshift, m[0])
+            ##printer.x = low_part
+            ZZ_pX_add(working2, low_part, shifted_high_part)
+            ##printer.x = working2
+        i += 1
+        two_shift = two_shift << 1
+        eis_part = eis_part >> 1
+    c = self.get_context(finalprec)
+    ZZ_pX_conv_modulus(x[0], working2, c.x)
+
+cdef class PowComputer_ext(PowComputer_class):
+    def __cinit__(self, Integer prime, long cache_limit, long prec_cap, long ram_prec_cap, bint in_field, poly, shift_seed=None):
+        """
+        Construct the storage for powers of prime as ZZ_c's.
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 10, 10, 20, False, ntl.ZZ_pX([-5, 0, 1], 5^10), 'small', 'e',ntl.ZZ_pX([1],5^10))  # indirect doctest
+        """
+        PowComputer_class.__init__(self, prime, cache_limit, prec_cap, ram_prec_cap, in_field, poly, shift_seed)
+
+        self._initialized = 0
+        self.small_powers = Allocate_ZZ_array(cache_limit + 1)
+        if self.small_powers == NULL:
+            raise MemoryError("out of memory allocating power storing")
+
+        cdef Py_ssize_t i
+
+        ZZ_conv_from_int(self.small_powers[0], 1)
+
+        if cache_limit > 0:
+            mpz_to_ZZ(&(self.small_powers[1]), prime.value)
+
+        sig_on()
+        for i in range(2, cache_limit + 1):
+            ZZ_mul(self.small_powers[i], self.small_powers[i-1], self.small_powers[1])
+        mpz_to_ZZ(&self.top_power, prime.value)
+        ZZ_power(self.top_power, self.top_power, prec_cap)
+        sig_off()
+        mpz_init(self.temp_m)
+        mpz_init(self.temp_m2)
+
+        self._poly = poly
+        self._shift_seed = shift_seed
+
+    def __dealloc__(self):
+        """
+        Frees allocated memory.
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 5, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'FM', 'e',ntl.ZZ_pX([1],5^10))
+            sage: del PC  # indirect doctest
+        """
+        if (<PowComputer_ext>self)._initialized:
+            self.cleanup_ext()
+
+    def __repr__(self):
+        """
+        Return a string representation of ``self``.
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 10, 10, 20, False, ntl.ZZ_pX([-5, 0, 1], 5^10), 'small', 'e',ntl.ZZ_pX([1],5^10))
+            sage: PC  # indirect doctest
+            PowComputer_ext for 5, with polynomial [9765620 0 1]
+        """
+        return "PowComputer_ext for %s, with polynomial %s" % (self.prime, self.polynomial())
+
+    def __reduce__(self):
+        """
+        For pickling.
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 10, 10, 20, False, ntl.ZZ_pX([-5, 0, 1], 5^10), 'small', 'e',ntl.ZZ_pX([1],5^10)); PC
+            PowComputer_ext for 5, with polynomial [9765620 0 1]
+            sage: loads(dumps(PC))
+            PowComputer_ext for 5, with polynomial [9765620 0 1]
+        """
+        cdef Integer cache_limit, prec_cap, ram_prec_cap
+        cache_limit = Integer.__new__(Integer)
+        mpz_set_si(cache_limit.value, self.cache_limit)
+        prec_cap = Integer.__new__(Integer)
+        mpz_set_si(prec_cap.value, self.prec_cap)
+        ram_prec_cap = Integer.__new__(Integer)
+        mpz_set_si(ram_prec_cap.value, self.ram_prec_cap)
+        return PowComputer_ext_maker, (self.prime, cache_limit, prec_cap, ram_prec_cap, self.in_field, self._poly, self._prec_type, self._ext_type, self._shift_seed)
+
+    cdef void cleanup_ext(self) noexcept:
+        """
+        Frees memory allocated in PowComputer_ext.
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 5, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'FM', 'e',ntl.ZZ_pX([1],5^10))
+            sage: del PC  # indirect doctest
+        """
+        Delete_ZZ_array(self.small_powers)
+        mpz_clear(self.temp_m)
+        mpz_clear(self.temp_m2)
+
+    cdef mpz_srcptr pow_mpz_t_tmp(self, long n) except NULL:
+        """
+        Provides fast access to an mpz_t* pointing to self.prime^n.
+
+        The location pointed to depends on the underlying
+        representation.  In no circumstances should you mpz_clear the
+        result.  The value pointed to may be an internal temporary
+        variable for the class.  In particular, you should not try to
+        refer to the results of two pow_mpz_t_tmp calls at the same
+        time, because the second call may overwrite the memory pointed
+        to by the first.
+
+        In the case of PowComputer_exts, the mpz_t pointed to will
+        always be a temporary variable.
+
+        See pow_mpz_t_tmp_demo for an example of this phenomenon.
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 10, 10, 20, False, ntl.ZZ_pX([-5, 0, 1], 5^10), 'small', 'e',ntl.ZZ_pX([1],5^10))
+            sage: PC._pow_mpz_t_tmp_test(4)  # indirect doctest
+            625
+        """
+        if n < 0:
+            raise ValueError("n must be nonnegative")
+        if n <= self.cache_limit:
+            ZZ_to_mpz(self.temp_m, &(self.small_powers[n]))
+        elif n == self.prec_cap:
+            ZZ_to_mpz(self.temp_m, &self.top_power)
+        else:
+            sig_on()
+            # n may exceed self.prec_cap. Very large values can, however, lead to
+            # out-of-memory situations in the following computation. This
+            # sig_on()/sig_off() prevents sage from crashing in such cases.
+            # It does not have a significant impact on performance. For small
+            # values of n the powers are taken from self.small_powers, for large
+            # values, the computation dominates the cost of the sig_on()/sig_off().
+            mpz_pow_ui(self.temp_m, self.prime.value, n)
+            sig_off()
+        return self.temp_m
+
+    cdef ZZ_c* pow_ZZ_tmp(self, long n) except NULL:
+        """
+        Provides fast access to a ZZ_c* pointing to self.prime^n.
+
+        The location pointed to depends on the underlying
+        representation. The value pointed to may be an internal temporary
+        variable for the class.  In particular, you should not try to
+        refer to the results of two pow_ZZ_tmp calls at the same time,
+        because the second call may overwrite the memory pointed to by
+        the first.
+
+        See pow_ZZ_tmp_demo for an example of this phenomenon.
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 10, 10, 20, False, ntl.ZZ_pX([-5, 0, 1], 5^10), 'small', 'e',ntl.ZZ_pX([1],5^10))
+            sage: PC._pow_mpz_t_tmp_test(4)  # indirect doctest
+            625
+        """
+        if n < 0:
+            raise ValueError("n must be nonnegative")
+        if n <= self.cache_limit:
+            return &(self.small_powers[n])
+        if n == self.prec_cap:
+            return &self.top_power
+        ZZ_power(self.temp_z, self.small_powers[1], n)
+        return &self.temp_z
+
+    def _pow_ZZ_tmp_test(self, n):
+        """
+        Test the ``pow_ZZ_tmp`` function.
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 6, 6, 12, False, ntl.ZZ_pX([-5,0,1],5^6),'small', 'e',ntl.ZZ_pX([1],5^6))
+            sage: PC._pow_ZZ_tmp_test(4)
+            625
+            sage: PC._pow_ZZ_tmp_test(7)
+            78125
+        """
+        cdef Integer _n = Integer(n)
+        if _n < 0: raise ValueError
+        cdef ntl_ZZ ans = ntl_ZZ.__new__(ntl_ZZ)
+        ans.x = self.pow_ZZ_tmp(mpz_get_ui(_n.value))[0]
+        return ans
+
+    def _pow_ZZ_tmp_demo(self, m, n):
+        """
+        This function demonstrates a danger in using pow_ZZ_tmp.
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 5, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'big', 'e',ntl.ZZ_pX([1],5^10))
+
+            When you cal pow_ZZ_tmp with an input that is not stored
+            (ie n > self.cache_limit and n != self.prec_cap),
+            it stores the result in self.temp_z and returns a pointer
+            to that ZZ_c.  So if you try to use the results of two
+            calls at once, things will break.
+            sage: PC._pow_ZZ_tmp_demo(6, 8)  # 244140625 on some architectures and 152587890625 on others: random
+            244140625
+            sage: 5^6*5^8
+            6103515625
+            sage: 5^6*5^6
+            244140625
+
+            Note that this does not occur if you try a stored value,
+            because the result of one of the calls points to that
+            stored value.
+            sage: PC._pow_ZZ_tmp_demo(6, 10)
+            152587890625
+            sage: 5^6*5^10
+            152587890625
+        """
+        m = Integer(m)
+        n = Integer(n)
+        if m < 0 or n < 0:
+            raise ValueError("m, n must be nonnegative")
+        cdef ntl_ZZ ans = ntl_ZZ.__new__(ntl_ZZ)
+        ZZ_mul(ans.x, self.pow_ZZ_tmp(mpz_get_ui((<Integer>m).value))[0], self.pow_ZZ_tmp(mpz_get_ui((<Integer>n).value))[0])
+        return ans
+
+    cdef mpz_srcptr pow_mpz_t_top(self) noexcept:
+        """
+        Return ``self.prime^self.prec_cap`` as an ``mpz_srcptr``.
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 6, 6, 12, False, ntl.ZZ_pX([-5,0,1],5^6),'small', 'e',ntl.ZZ_pX([1],5^6))
+            sage: PC._pow_mpz_t_top_test()  # indirect doctest
+            15625
+        """
+        ZZ_to_mpz(self.temp_m, &self.top_power)
+        return self.temp_m
+
+    cdef ZZ_c* pow_ZZ_top(self) noexcept:
+        """
+        Return ``self.prime^self.prec_cap`` as a ZZ_c.
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 6, 6, 12, False, ntl.ZZ_pX([-5,0,1],5^6),'small', 'e',ntl.ZZ_pX([1],5^6))
+            sage: PC._pow_ZZ_top_test()  # indirect doctest
+            15625
+        """
+        return &self.top_power
+
+    def _pow_ZZ_top_test(self):
+        """
+        Test the ``pow_ZZ_top`` function.
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 6, 6, 12, False, ntl.ZZ_pX([-5,0,1],5^6),'small', 'e',ntl.ZZ_pX([1],5^6))
+            sage: PC._pow_ZZ_top_test()
+            15625
+        """
+        cdef ntl_ZZ ans = ntl_ZZ.__new__(ntl_ZZ)
+        ans.x = self.pow_ZZ_top()[0]
+        return ans
+
+    def _ram_prec_cap(self):
+        """
+        Return the precision cap of self, considered as a power of the uniformizer.
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 6, 6, 12, False, ntl.ZZ_pX([-5,0,1],5^5),'small', 'e',ntl.ZZ_pX([1],5^5))
+            sage: PC._ram_prec_cap()
+            12
+        """
+        return self.ram_prec_cap
+
+cdef class PowComputer_ZZ_pX(PowComputer_ext):
+    def __cinit__(self, Integer prime, long cache_limit, long prec_cap, long ram_prec_cap, bint in_field, poly, shift_seed=None):
+        """
+        Initialization.
+
+        For input types see :func:`PowComputer_ext_maker`
+
+        TESTS::
+
+            sage: PC = PowComputer_ext_maker(5, 5, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'FM', 'e',ntl.ZZ_pX([1],5^10))
+            sage: TestSuite(PC).run()
+        """
+        if not isinstance(poly, ntl_ZZ_pX):
+            raise TypeError
+        self.deg = ZZ_pX_deg((<ntl_ZZ_pX>poly).x)
+
+    def polynomial(self):
+        """
+        Return the polynomial (with coefficient precision prec_cap) associated
+        to this ``PowComputer``.
+
+        The polynomial is output as an ntl_ZZ_pX.
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 5, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'FM', 'e',ntl.ZZ_pX([1],5^10))
+            sage: PC.polynomial()
+            [9765620 0 1]
+        """
+        self.restore_top_context()
+        cdef ntl_ZZ_pX r = ntl_ZZ_pX.__new__(ntl_ZZ_pX)
+        r.c = self.get_top_context()
+        r.x = (self.get_top_modulus()[0]).val()
+        return r
+
+    cdef ntl_ZZ_pContext_class get_context(self, long n):
+        """
+        Return a ``ZZ_pContext`` for ``self.prime^(abs(n))``.
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 10, 10, 20, False, ntl.ZZ_pX([-5, 0, 1], 5^10), 'FM', 'e',ntl.ZZ_pX([1],5^10))
+            sage: PC._get_context_test(15)  # indirect doctest
+            NTL modulus 30517578125
+        """
+        cdef ntl_ZZ pn = ntl_ZZ.__new__(ntl_ZZ)
+        if n < 0:
+            n = -n
+        elif n == 0:
+            # Exception will be ignored by Cython
+            raise ValueError("n must be nonzero")
+        pn.x = self.pow_ZZ_tmp(n)[0]
+        cdef ntl_ZZ_pContext_class context = (<ntl_ZZ_pContext_factory>ZZ_pContext_factory).make_c(pn)
+        return context
+
+    def _get_context_test(self, n):
+        """
+        Return a ``ZZ_pContext`` for ``self.prime^n``.
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 10, 10, 20, False, ntl.ZZ_pX([-5, 0, 1], 5^10), 'FM', 'e',ntl.ZZ_pX([1],5^10))
+            sage: PC._get_context_test(15)
+            NTL modulus 30517578125
+        """
+        cdef Integer _n = Integer(n)
+        return self.get_context(mpz_get_si(_n.value))
+
+    cdef ntl_ZZ_pContext_class get_context_capdiv(self, long n):
+        """
+        Return a ``ZZ_pContext`` for ``self.prime^((n-1) // self.e + 1)``.
+
+        For Eisenstein extensions this gives the context used for an
+        element of relative precision n.
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 10, 10, 20, False, ntl.ZZ_pX([-5, 0, 1], 5^10), 'FM', 'e',ntl.ZZ_pX([1],5^10))
+            sage: PC._get_context_capdiv_test(30)  # indirect doctest
+            NTL modulus 30517578125
+        """
+        return self.get_context(self.capdiv(n))
+
+    def _get_context_capdiv_test(self, n):
+        """
+        Return a ``ZZ_pContext`` for ``self.prime^((n-1) // self.e + 1)``.
+
+        For Eisenstein extensions this gives the context used for an
+        element of relative precision n.
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 10, 10, 20, False, ntl.ZZ_pX([-5, 0, 1], 5^10), 'FM', 'e',ntl.ZZ_pX([1],5^10))
+            sage: PC._get_context_capdiv_test(29)
+            NTL modulus 30517578125
+        """
+        cdef Integer _n = Integer(n)
+        return self.get_context_capdiv(mpz_get_si(_n.value))
+
+    def speed_test(self, n, runs):
+        """
+        Run a speed test.
+
+        INPUT:
+
+        - ``n`` -- input to a function to be tested (the function needs to be
+          set in the source code)
+        - ``runs`` -- the number of runs of that function
+
+        OUTPUT:
+
+        - The time in seconds that it takes to call the function on ``n``,
+          ``runs`` times.
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 10, 10, 20, False, ntl.ZZ_pX([-5, 0, 1], 5^10), 'small', 'e',ntl.ZZ_pX([1],5^10))
+            sage: PC.speed_test(10, 10^6)  # random
+            0.0090679999999991878
+        """
+        cdef Py_ssize_t i, end, _n
+        end = mpz_get_ui((<Integer>Integer(runs)).value)
+        _n = mpz_get_ui((<Integer>Integer(n)).value)
+        t = cputime()
+        for i in range(end):
+            # Put the function you want speed tested here.
+            self.get_modulus(_n)
+        return cputime(t)
+
+    cdef ntl_ZZ_pContext_class get_top_context(self):
+        """
+        Return a ``ZZ_pContext`` for ``self.prime^self.prec_cap``.
+
+        TESTS::
+
+            sage: PC = PowComputer_ext_maker(5, 5, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'FM', 'e',ntl.ZZ_pX([1],5^10))
+            sage: PC._get_top_context_test()  # indirect doctest
+            NTL modulus 9765625
+        """
+        return self.get_context(self.prec_cap)
+
+    def _get_top_context_test(self):
+        """
+        Return a ``ZZ_pContext`` for ``self.prime^self.prec_cap``.
+
+        TESTS::
+
+            sage: PC = PowComputer_ext_maker(5, 5, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'FM', 'e',ntl.ZZ_pX([1],5^10))
+            sage: PC._get_top_context_test()
+            NTL modulus 9765625
+        """
+        return self.get_top_context()
+
+    cdef restore_context(self, long n):
+        """
+        Restore the contest corresponding to ``self.prime^n``.
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 5, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'FM', 'e',ntl.ZZ_pX([1],5^10))
+            sage: PC._restore_context_test(4)  # indirect doctest
+        """
+        self.get_context(n).restore_c()
+
+    def _restore_context_test(self, n):
+        """
+        Restore the contest corresponding to ``self.prime^n``.
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 5, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'FM', 'e',ntl.ZZ_pX([1],5^10))
+            sage: PC._restore_context_test(4)
+        """
+        cdef Integer _n = Integer(n)
+        self.restore_context(mpz_get_si(_n.value))
+
+    cdef restore_context_capdiv(self, long n):
+        """
+        Restore the context for ``self.prime^((n-1) // self.e + 1)``.
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 5, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'FM', 'e',ntl.ZZ_pX([1],5^10))
+            sage: PC._restore_context_capdiv_test(4)  # indirect doctest
+        """
+        self.restore_context(self.capdiv(n))
+
+    def _restore_context_capdiv_test(self, n):
+        """
+        Restore the context for ``self.prime^((n-1) // self.e + 1)``.
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 5, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'FM', 'e',ntl.ZZ_pX([1],5^10))
+            sage: PC._restore_context_capdiv_test(8)  # indirect doctest
+        """
+        cdef Integer _n = Integer(n)
+        self.restore_context_capdiv(mpz_get_si(_n.value))
+
+    cdef void restore_top_context(self) noexcept:
+        """
+        Restore the context corresponding to ``self.prime^self.prec_cap``.
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 5, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'FM', 'e',ntl.ZZ_pX([1],5^10))
+            sage: PC._restore_top_context_test()
+        """
+        (<ntl_ZZ_pContext_class>self.get_top_context()).restore_c()
+
+    def _restore_top_context_test(self):
+        """
+        Restore the context corresponding to ``self.prime^self.prec_cap``.
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 5, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'FM', 'e',ntl.ZZ_pX([1],5^10))
+            sage: PC._restore_top_context_test()
+        """
+        self.restore_top_context()
+
+    cdef ZZ_pX_Modulus_c* get_modulus(self, long n) noexcept:
+        """
+        Return the modulus corresponding to ``self.polynomial()`` (mod
+        ``self.prime^n``).
+
+        EXAMPLES::
+
+            sage: A = PowComputer_ext_maker(5, 10, 1000, 2000, False, ntl.ZZ_pX([-5,0,1],5^1000), 'big', 'e',ntl.ZZ_pX([1],5^1000))
+            sage: a = ntl.ZZ_pX([4,2],5^2)
+            sage: b = ntl.ZZ_pX([6,3],5^2)
+            sage: A._get_modulus_test(a, b, 2)  # indirect doctest
+            [4 24]
+        """
+        # Exception will be ignored by Cython
+        raise NotImplementedError
+
+    def _get_modulus_test(self, ntl_ZZ_pX a, ntl_ZZ_pX b, Integer n):
+        """
+        Multiply ``a`` and ``b`` modulo the modulus corresponding to
+        ``self.polynomial()`` (mod ``self.prime^n``).
+
+        EXAMPLES::
+
+            sage: A = PowComputer_ext_maker(5, 10, 1000, 2000, False, ntl.ZZ_pX([-5,0,1],5^1000), 'big', 'e',ntl.ZZ_pX([1],5^1000))
+            sage: a = ntl.ZZ_pX([4,2],5^2)
+            sage: b = ntl.ZZ_pX([6,3],5^2)
+            sage: A._get_modulus_test(a, b, 2)
+            [4 24]
+            sage: a * b
+            [24 24 6]
+            sage: mod(6 * 5 + 24, 25)                                                   # needs sage.rings.finite_rings
+            4
+        """
+        if self.pow_Integer(mpz_get_si(n.value)) != Integer(a.c.p):
+            raise ValueError("a context mismatch")
+        if self.pow_Integer(mpz_get_si(n.value)) != Integer(b.c.p):
+            raise ValueError("b context mismatch")
+        cdef ntl_ZZ_pX r = (<ntl_ZZ_pX>a)._new()
+        cdef ntl_ZZ_pX aa = (<ntl_ZZ_pX>a)._new()
+        cdef ntl_ZZ_pX bb = (<ntl_ZZ_pX>b)._new()
+        ZZ_pX_rem(aa.x, a.x, self.get_modulus(mpz_get_si(n.value))[0].val())
+        ZZ_pX_rem(bb.x, b.x, self.get_modulus(mpz_get_si(n.value))[0].val())
+        ZZ_pX_MulMod_pre(r.x, aa.x, bb.x, self.get_modulus(mpz_get_si(n.value))[0])
+        return r
+
+    cdef ZZ_pX_Modulus_c* get_modulus_capdiv(self, long n) noexcept:
+        """
+        Return the modulus corresponding to ``self.polynomial()`` (mod
+        ``self.prime^((n-1) // self.e + 1``).
+        """
+        return self.get_modulus(self.capdiv(n))
+
+    cdef ZZ_pX_Modulus_c* get_top_modulus(self) noexcept:
+        """
+        Return the modulus corresponding to ``self.polynomial()`` (mod
+        ``self.prime^self.prec_cap``).
+
+        EXAMPLES::
+
+            sage: A = PowComputer_ext_maker(5, 3, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'FM', 'e',ntl.ZZ_pX([1],5^10))
+            sage: a = ntl.ZZ_pX([129223,1231],5^10)
+            sage: b = ntl.ZZ_pX([289741,323],5^10)
+            sage: A._get_top_modulus_test(a, b)  # indirect doctest
+            [1783058 7785200]
+        """
+        # Exception will be ignored by Cython
+        raise NotImplementedError
+
+    def _get_top_modulus_test(self, ntl_ZZ_pX a, ntl_ZZ_pX b):
+        """
+        Multiply ``a`` and ``b`` modulo the modulus corresponding to
+        ``self.polynomial()`` (mod ``self.prime^self.prec_cap``).
+
+        EXAMPLES::
+
+            sage: A = PowComputer_ext_maker(5, 3, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'FM', 'e',ntl.ZZ_pX([1],5^10))
+            sage: a = ntl.ZZ_pX([129223,1231],5^10)
+            sage: b = ntl.ZZ_pX([289741,323],5^10)
+            sage: A._get_top_modulus_test(a, b)
+            [1783058 7785200]
+            sage: a*b
+            [9560618 7785200 397613]
+            sage: mod(397613 * 5 + 9560618, 5^10)                                       # needs sage.rings.finite_rings
+            1783058
+        """
+        cdef ntl_ZZ_pX ans = a._new()
+        ZZ_pX_MulMod_pre(ans.x, a.x, b.x, self.get_top_modulus()[0])
+        return ans
+
+    cdef long capdiv(self, long n) noexcept:
+        """
+        If n >= 0 returns ceil(n / self.e)
+
+        If n < 0 returns ceil(-n / self.e)
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 3, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'FM', 'e',ntl.ZZ_pX([1],5^10))
+            sage: PC._capdiv_test(15)
+            8
+            sage: PC._capdiv_test(-7)
+            4
+        """
+        if self.e == 1:
+            return n
+        if n > 0:
+            return (n-1) / self.e + 1
+        elif n < 0:
+            return (-1-n) / self.e + 1
+        else:
+            return 0
+
+    def _capdiv_test(self, n):
+        """
+        If n >= 0, return ceil(n / self.e).
+
+        If n < 0, return ceil(-n / self.e).
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 3, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'FM', 'e',ntl.ZZ_pX([1],5^10))
+            sage: PC._capdiv_test(15)
+            8
+            sage: PC._capdiv_test(-7)
+            4
+        """
+        cdef Integer _n = Integer(n)
+        cdef Integer ans = Integer.__new__(Integer)
+        mpz_set_si(ans.value, self.capdiv(mpz_get_si(_n.value)))
+        return ans
+
+    cdef int eis_shift(self, ZZ_pX_c* x, ZZ_pX_c* a, long n, long finalprec) except -1:
+        raise NotImplementedError
+
+    cdef int eis_shift_capdiv(self, ZZ_pX_c* x, ZZ_pX_c* a, long n, long finalprec) except -1:
+        return self.eis_shift(x, a, n, self.capdiv(finalprec))
+
+    cdef int teichmuller_set_c (self, ZZ_pX_c* x, ZZ_pX_c* a, long absprec) except -1:
+        r"""
+        Set `x` to the Teichmuller lift congruent to a modulo the
+        uniformizer, ie such that `x = a \mod \pi` and
+        `x^q = x \mod \pi^{\mbox{absprec}}`.
+
+        If `a = 0 \mod \pi` this function does nothing and returns 1.
+        Otherwise returns 0.
+
+        `x` should be created with context p^absprec.
+
+        Does not affect ``self``.
+
+        INPUT:
+
+        - ``x`` -- the ``ZZ_pX_c`` to be set
+
+        - ``a`` -- a ``ZZ_pX_c`` ``currently holding an approximation to the
+          Teichmuller representative (this approximation can be any
+          integer).  It will be set to the actual Teichmuller lift.
+
+        - ``absprec`` -- the desired precision of the Teichmuller lift
+
+        OUTPUT:
+
+        - 1 -- `x` should be set to zero
+        - 0 -- normal
+
+        EXAMPLES::
+
+            sage: R = Zp(17,5)
+            sage: S.<x> = R[]
+            sage: f = x^5 + 34*x^3 - 17*x^2 +289*x - 17
+            sage: W.<w> = R.ext(f)
+            sage: y = W.teichmuller(3,10); y
+            3 + 13*w^5 + 4*w^7 + 9*w^8 + 13*w^9 + O(w^10)
+            sage: y^17 == y
+            True
+            sage: g = x^3 + 9*x^2 + 1
+            sage: A.<a> = R.ext(g)
+            sage: b = A.teichmuller(1 + 2*a - a^2, 3); b
+            (16*a^2 + 2*a + 1) + (4*a^2 + 5*a + 3)*17 + (10*a^2 + 15*a + 11)*17^2 + O(17^3)
+            sage: b^(17^3) == b
+            True
+        """
+        cdef mpz_t u, xnew, value
+        cdef ZZ_c tmp, q, u_q
+        cdef ZZ_pX_c xnew_q
+        cdef ntl_ZZ_pContext_class c
+        cdef long mini = 0, minval = 0
+        if absprec == 0:
+            return 1
+        if absprec < 0:
+            absprec = -absprec
+        if self.e != 1:
+            mpz_init(value)
+            tmp = ZZ_p_rep(ZZ_pX_ConstTerm(a[0]))
+            ZZ_to_mpz(value, &tmp)
+            if mpz_divisible_p(value, self.prime.value) != 0:
+                mpz_clear(value)
+                return 1
+            self.pow_mpz_t_tmp(self.capdiv(absprec)) # sets self.temp_m
+            if mpz_sgn(value) < 0 or mpz_cmp(value, self.temp_m) >= 0:
+                mpz_mod(value, value, self.temp_m)
+            mpz_init(u)
+            mpz_init(xnew)
+            # u = 1 / Mod(1 - p, self.temp_m)
+            mpz_sub(u, self.temp_m, self.prime.value)
+            mpz_add_ui(u, u, 1)
+            mpz_invert(u, u, self.temp_m)
+            # Consider x as Mod(self.value, self.temp_m)
+            # xnew = x + u*(x^p - x)
+            mpz_powm(xnew, value, self.prime.value, self.temp_m)
+            mpz_sub(xnew, xnew, value)
+            mpz_mul(xnew, xnew, u)
+            mpz_add(xnew, xnew, value)
+            mpz_mod(xnew, xnew, self.temp_m)
+            # while x != xnew:
+            #     x = xnew
+            #     xnew = x + u*(x^p - x)
+            while mpz_cmp(value, xnew) != 0:
+                mpz_set(value, xnew)
+                mpz_powm(xnew, value, self.prime.value, self.temp_m)
+                mpz_sub(xnew, xnew, value)
+                mpz_mul(xnew, xnew, u)
+                mpz_add(xnew, xnew, value)
+                mpz_mod(xnew, xnew, self.temp_m)
+            mpz_clear(u)
+            mpz_clear(xnew)
+            mpz_to_ZZ(&tmp, value)
+            self.restore_context_capdiv(absprec)
+            if ZZ_pX_IsZero(x[0]): # shortcut for the case x = 0
+                ZZ_pX_SetCoeff(x[0], 0, ZZ_to_ZZ_p(tmp))
+            else:
+                ZZ_pX_SetX(x[0])
+                ZZ_pX_SetCoeff(x[0], 0, ZZ_to_ZZ_p(tmp))
+                ZZ_pX_SetCoeff_long(x[0], 1, 0)
+            mpz_clear(value)
+        else:
+            c = self.get_context(absprec)
+            c.restore_c()
+            q = self.pow_ZZ_tmp(self.f)[0]
+            ZZ_pX_min_val_coeff(minval, mini, a[0], self.pow_ZZ_tmp(1)[0])
+            if mini == -1 or minval > 0:
+                return 1
+            ZZ_pX_conv_modulus(x[0], a[0], c.x)
+            # u = 1 / Mod(1 - q, p^absprec)
+            ZZ_conv_from_long(u_q, 1)
+            ZZ_sub(u_q, u_q, q)
+            ZZ_rem(u_q, u_q, (<ntl_ZZ>c.p).x)
+            ZZ_InvMod(u_q, u_q, (<ntl_ZZ>c.p).x)
+            # xnew = x + u*(x^q - x)
+            ZZ_pX_PowerMod_pre(xnew_q, x[0], q, self.get_modulus(absprec)[0])
+            ZZ_pX_sub(xnew_q, xnew_q, x[0])
+            ZZ_pX_mul_ZZ_p(xnew_q, xnew_q, ZZ_to_ZZ_p(u_q))
+            ZZ_pX_add(xnew_q, xnew_q, x[0])
+            # while x != xnew:
+            #     x = xnew
+            #     xnew = x + u*(x^q - x)
+            while x[0] != xnew_q:
+                x[0] = xnew_q
+                ZZ_pX_PowerMod_pre(xnew_q, x[0], q, self.get_modulus(absprec)[0])
+                ZZ_pX_sub(xnew_q, xnew_q, x[0])
+                ZZ_pX_mul_ZZ_p(xnew_q, xnew_q, ZZ_to_ZZ_p(u_q))
+                ZZ_pX_add(xnew_q, xnew_q, x[0])
+        return 0
+
+
+cdef class PowComputer_ZZ_pX_FM(PowComputer_ZZ_pX):
+    r"""
+    This class only caches a context and modulus for p^prec_cap.
+
+    Designed for use with fixed modulus `p`-adic rings, in Eisenstein
+    and unramified extensions of `\ZZ_p`.
+    """
+
+    def __cinit__(self, Integer prime, long cache_limit, long prec_cap, long ram_prec_cap, bint in_field, poly, shift_seed=None):
+        """
+        Caches a context and modulus for ``prime^prec_cap``.
+
+        EXAMPLES::
+
+            sage: A = PowComputer_ext_maker(5, 3, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'FM', 'e',ntl.ZZ_pX([1],5^10))  # indirect doctest
+            sage: A
+            PowComputer_ext for 5, with polynomial [9765620 0 1]
+        """
+
+        # The __new__ method for PowComputer_ext has already run, so we have access to small_powers, top_power.
+
+        # We use ntl_ZZ_pContexts so that contexts are cached centrally.
+
+        self._prec_type = 'FM'
+        self._ext_type = 'u'
+        self.c = self.get_context(prec_cap)
+        self.c.restore_c()
+        # For now, we don't do anything complicated with poly
+        if isinstance(poly, ntl_ZZ_pX) and (<ntl_ZZ_pX>poly).c is self.c:
+            ZZ_pX_Modulus_build(self.mod, (<ntl_ZZ_pX>poly).x)
+            if prec_cap == ram_prec_cap:
+                self.e = 1
+                self.f = ZZ_pX_deg((<ntl_ZZ_pX>poly).x)
+            else:
+                self.e = ZZ_pX_deg((<ntl_ZZ_pX>poly).x)
+                self.f = 1
+            self.ram_prec_cap = ram_prec_cap
+        else:
+            raise NotImplementedError("NOT IMPLEMENTED IN PowComputer_ZZ_pX_FM")
+
+    cdef ntl_ZZ_pContext_class get_top_context(self):
+        """
+        Return a ``ZZ_pContext`` for ``self.prime^self.prec_cap``.
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 5, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'FM', 'e',ntl.ZZ_pX([1],5^10))
+            sage: PC._get_top_context_test()  # indirect doctest
+            NTL modulus 9765625
+        """
+        return self.c
+
+    cdef void restore_top_context(self) noexcept:
+        """
+        Restore the context corresponding to ``self.prime^self.prec_cap``.
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 5, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'FM', 'e',ntl.ZZ_pX([1],5^10))
+            sage: PC._restore_top_context_test()  # indirect doctest
+        """
+        self.c.restore_c()
+
+    cdef ZZ_pX_Modulus_c* get_top_modulus(self) noexcept:
+        """
+        Return the modulus corresponding to ``self.polynomial()``
+        (mod ``self.prime^self.prec_cap``).
+
+        EXAMPLES::
+
+            sage: A = PowComputer_ext_maker(5, 3, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'FM', 'e',ntl.ZZ_pX([1],5^10))
+            sage: a = ntl.ZZ_pX([129223,1231],5^10)
+            sage: b = ntl.ZZ_pX([289741,323],5^10)
+            sage: A._get_top_modulus_test(a, b)  # indirect doctest
+            [1783058 7785200]
+        """
+        return &self.mod
+
+    cdef ZZ_pX_Modulus_c* get_modulus(self, long n) noexcept:
+        """
+        Duplicates functionality of get_top_modulus if n == self.prec_cap.
+
+        If not, raise an exception (which will be ignored by Cython).
+
+        EXAMPLES::
+
+            sage: A = PowComputer_ext_maker(5, 3, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'FM', 'e',ntl.ZZ_pX([1],5^10))
+            sage: a = ntl.ZZ_pX([129223,1231],5^10)
+            sage: b = ntl.ZZ_pX([289741,323],5^10)
+            sage: A._get_modulus_test(a, b, 10)  # indirect doctest
+            [1783058 7785200]
+        """
+        if n == self.prec_cap:
+            return &self.mod
+        else:
+            # Exception will be ignored by Cython
+            raise ValueError("fixed modulus PowComputers only store top modulus")
+
+cdef class PowComputer_ZZ_pX_FM_Eis(PowComputer_ZZ_pX_FM):
+    """
+    This class computes and stores ``low_shifter`` and ``high_shifter``, which aid in right shifting elements.
+    """
+
+    def __cinit__(self, Integer prime, long cache_limit, long prec_cap, long ram_prec_cap, bint in_field, poly, shift_seed=None):
+        """
+        Call ``Eis_init``, which initializes ``high_shifter`` and
+        ``low_shifter``.
+
+        TESTS::
+
+            sage: A = PowComputer_ext_maker(5, 3, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'FM', 'e',ntl.ZZ_pX([1],5^10))  # indirect doctest
+        """
+        # The __new__ method for PowComputer_ZZ_pX_FM has already run, so we have access to self.mod
+        self._ext_type = 'e'
+        if not isinstance(shift_seed, ntl_ZZ_pX):
+            raise TypeError("shift_seed must be an ntl_ZZ_pX")
+        ZZ_pX_Eis_init(self, <ntl_ZZ_pX>shift_seed)
+
+    def _low_shifter(self, i):
+        """
+        Accessor function for low_shifter, which are the polynomials used to shift right.
+
+        If low_length is the number of low_shifters, then:
+            * if deg = 2, low_length = 1 (store p/x)
+            * if deg = 3,4, low_length = 2 (store p/x, p/x^2)
+            * if deg = 5,6,7,8, low_length = 3 (store p/x, p/x^2, p/x^4)
+            * if deg = 9,...,16, low_length = 4 (store p/x, p/x^2, p/x^4, p/x^8)
+
+        These polynomials are used to shift by amounts less than the degree of the defining polynomial.
+
+        EXAMPLES::
+
+            sage: A = PowComputer_ext_maker(5, 3, 10, 40, False, ntl.ZZ_pX([-5,75,15,0,1],5^10), 'FM', 'e',ntl.ZZ_pX([1,-15,-3],5^10))
+            sage: A._low_shifter(0)
+            [75 15 0 1]
+
+            Note that if we multiply this by x and reduce using the relation that x^4 = 5 - 75x - 15x^2, we just get 5.
+
+            sage: A._low_shifter(1)
+            [1140 225 1 15]
+
+            This one's a bit less obvious, but if we multiply by x^2, we get 5 (modulo x^4 = 5 - 75x - 15x^2).
+        """
+        cdef long _i = i
+        cdef ntl_ZZ_pX ans
+        if _i >= 0 and _i < self.low_length:
+            ans = ntl_ZZ_pX([], self.get_top_context())
+            ans.x = self.low_shifter[i].val()
+            return ans
+        else:
+            raise IndexError
+
+    def _high_shifter(self, i):
+        """
+        Accessor function for high_shifter, which are the polynomials used to shift right.
+
+        If high_length is the number of high_shifters, then:
+            * if prec_cap = 2, high_length = 1 (store p/x^e)
+            * if prec_cap = 3,4, high_length = 2 (store p/x^e, p^2/x^(2e))
+            * if prec_cap = 5,6,7,8, high_length = 3 (store p/x^e, p^2/x^(2e), p^4/x^(4e))
+            * if prec_cap = 9,...,16, high_length = 4 (store p/x, p^2/x^(2e), p^4/x^(4e), p^8/x^(8e))
+
+        These polynomials are used to shift by amounts greater than the degree of the defining polynomial, but less than e*prec_cap.
+
+        EXAMPLES::
+
+            sage: A = PowComputer_ext_maker(5, 3, 10, 40, False, ntl.ZZ_pX([-5,75,15,0,1],5^10), 'FM', 'e',ntl.ZZ_pX([1,-15,-3],5^10))
+            sage: A._high_shifter(0)
+            [263296 51990 228 3465]
+
+        If we take this and multiply by x^4, and reduce modulo x^4 + 15*x^2 + 75*x - 5, we should get 5.::
+
+            sage: R.<x> = ZZ[]
+            sage: f = 263296 + 51990*x + 228*x^2 + 3465*x^3
+            sage: g = x^4 + 15*x^2 + 75*x - 5
+            sage: f*x^4 % g
+            5
+
+            sage: A._high_shifter(1)
+            [1420786 9298230 2217816 6212495]
+
+        Similarly::
+
+            sage: f = 1420786 + 9298230*x + 2217816*x^2 + 6212495*x^3
+            sage: h = f*x^8 % g; h
+            -1328125000000*x^3 + 2962646484375*x^2 + 22094970703125*x - 1466308593725
+
+        Here, we need to remember that we're working modulo 5^10::
+
+            sage: h[0].valuation(5), h[1].valuation(5), h[2].valuation(5), h[3].valuation(5)
+            (2, 12, 13, 13)
+            sage: (h[0] - 25).valuation(5)
+            12
+        """
+        cdef long _i = i
+        cdef ntl_ZZ_pX ans
+        if _i >= 0 and _i < self.high_length:
+            ans = ntl_ZZ_pX([], self.get_top_context())
+            ans.x = self.high_shifter[i].val()
+            return ans
+        else:
+            raise IndexError
+
+    def __dealloc__(self):
+        """
+        Deallocate ``low_shifter`` and ``high_shifter``.
+
+        TESTS::
+
+            sage: A = PowComputer_ext_maker(5, 3, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'FM', 'e',ntl.ZZ_pX([1],5^10))
+            sage: del A  # indirect doctest
+        """
+        if self._initialized:
+            self.cleanup_ZZ_pX_FM_Eis()
+
+    cdef void cleanup_ZZ_pX_FM_Eis(self) noexcept:
+        """
+        Do the actual work of deallocating ``low_shifter`` and
+        ``high_shifter``.
+
+        TESTS::
+
+            sage: A = PowComputer_ext_maker(5, 3, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'FM', 'e',ntl.ZZ_pX([1],5^10))
+            sage: del A  # indirect doctest
+        """
+        Delete_ZZ_pX_Multiplier_array(self.low_shifter)
+        Delete_ZZ_pX_Multiplier_array(self.high_shifter)
+
+    cdef int eis_shift(self, ZZ_pX_c* x, ZZ_pX_c* a, long n, long finalprec) except -1:
+        """
+        Shift ``a`` right ``n`` pi-adic digits, where pi is considered modulo
+        the polynomial in ``self``.
+
+        Puts the result in ``x``.
+
+        EXAMPLES::
+
+            sage: from sage.rings.padics.pow_computer_ext import ZZ_pX_eis_shift_test
+            sage: A = PowComputer_ext_maker(5, 3, 10, 40, False, ntl.ZZ_pX([-5,75,15,0,1],5^10), 'FM', 'e',ntl.ZZ_pX([1,-15,-3],5^10))
+            sage: ZZ_pX_eis_shift_test(A, [0, 1], 1, 5)  # indirect doctest
+            [1]
+            sage: ZZ_pX_eis_shift_test(A, [0, 0, 1], 1, 5)
+            [0 1]
+            sage: ZZ_pX_eis_shift_test(A, [5], 1, 5)
+            [75 15 0 1]
+            sage: ZZ_pX_eis_shift_test(A, [1], 1, 5)
+            []
+            sage: ZZ_pX_eis_shift_test(A, [17, 91, 8, -2], 1, 5)
+            [316 53 3123 3]
+            sage: ZZ_pX_eis_shift_test(A, [316, 53, 3123, 3], -1, 5)
+            [15 91 8 3123]
+            sage: ZZ_pX_eis_shift_test(A, [15, 91, 8, 3123], 1, 5)
+            [316 53 3123 3]
+        """
+        return ZZ_pX_eis_shift_p(self, x, a, n, finalprec)
+
+#         cdef ZZ_pX_c low_part
+#         cdef ZZ_pX_c shifted_high_part
+#         cdef ZZ_pX_c high_shifter
+
+#         ##cdef ntl_ZZ_pX printer
+#         if n < 0:
+#             self.restore_top_context()
+#             ##printer = ntl_ZZ_pX([],self.get_top_context())
+#             ZZ_pX_PowerXMod_long_pre(high_shifter, -n, self.get_top_modulus()[0])
+#             ##printer.x = high_shifter
+#             ZZ_pX_MulMod_pre(x[0],high_shifter,a[0],self.get_top_modulus()[0])
+#             ##printer.x = x[0]
+#             return 0
+#         elif n == 0:
+#             if x != a:
+#                 x[0] = a[0]
+#             return 0
+#         cdef long pshift = n / self.e
+#         cdef long eis_part = n % self.e
+#         cdef long two_shift = 1
+#         cdef int i
+
+#         ##printer = ntl_ZZ_pX([],self.get_top_context())
+#         if x != a:
+#             x[0] = a[0]
+#         ##printer.x = a[0]
+#         if pshift:
+#             i = 0
+#             # This line restores the top context
+#             ZZ_pX_right_pshift(x[0], x[0], self.pow_ZZ_tmp(pshift)[0], self.get_top_context().x)
+#             ##printer.x = x[0]
+#             if pshift >= self.prec_cap:
+#                 # high_shifter = p^(2^(high_length - 1))/x^(e*2^(high_length - 1))
+#                 # if val = r + s * 2^(high_length - 1)
+#                 # then high_shifter = p^(s*2^(high_length - 1))/x^(e*s*2^(high_length - 1))
+#                 ZZ_pX_PowerMod_long_pre(high_shifter, self.high_shifter[self.high_length-1].val(), (pshift / (1L << (self.high_length - 1))), self.get_top_modulus()[0])
+#                 ##printer.x = high_shifter
+#                 ZZ_pX_MulMod_pre(x[0], x[0], high_shifter, self.get_top_modulus()[0])
+#                 ##printer.x = high_shifter
+#                 # Now we only need to multiply self.unit by p^r/x^(e*r) where r < 2^(high_length - 1), which is tractible.
+#                 pshift = pshift % (1L << (self.high_length - 1))
+#             while pshift > 0:
+#                 if pshift & 1:
+#                     ##printer.x = x[0]
+#                     ZZ_pX_MulMod_premul(x[0], x[0], self.high_shifter[i], self.get_top_modulus()[0])
+#                 i += 1
+#                 pshift = pshift >> 1
+#         else:
+#             self.restore_top_context()
+#         i = 0
+#         two_shift = 1
+#         while eis_part > 0:
+#             if eis_part & 1:
+#                 ZZ_pX_RightShift(shifted_high_part, x[0], two_shift)
+#                 ##printer.x = shifted_high_part
+#                 ZZ_pX_LeftShift(low_part, shifted_high_part, two_shift)
+#                 ZZ_pX_sub(low_part, x[0], low_part)
+#                 ##printer.x = low_part
+#                 ZZ_pX_right_pshift(low_part, low_part, self.pow_ZZ_tmp(1)[0], self.get_top_context().x)
+#                 ##printer.x = low_part
+#                 ZZ_pX_MulMod_premul(low_part, low_part, self.low_shifter[i], self.get_top_modulus()[0])
+#                 ##printer.x = low_part
+#                 ZZ_pX_add(x[0], low_part, shifted_high_part)
+#                 ##printer.x = x[0]
+#             i += 1
+#             two_shift = two_shift << 1
+#             eis_part = eis_part >> 1
+
+cdef class PowComputer_ZZ_pX_small(PowComputer_ZZ_pX):
+    """
+    This class caches contexts and moduli densely between 1 and cache_limit.  It requires cache_limit == prec_cap.
+
+    It is intended for use with capped relative and capped absolute rings and fields, in Eisenstein and unramified
+    extensions of the base `p`-adic fields.
+    """
+
+    def __cinit__(self, Integer prime, long cache_limit, long prec_cap, long ram_prec_cap, bint in_field, poly, shift_seed=None):
+        """
+        Caches contexts and moduli densely between 1 and cache_limit.
+
+        EXAMPLES::
+
+            sage: A = PowComputer_ext_maker(5, 10, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'small', 'e',ntl.ZZ_pX([1],5^10))  # indirect doctest
+            sage: A
+            PowComputer_ext for 5, with polynomial [9765620 0 1]
+        """
+        # The __new__ method for PowComputer_ext has already run, so we have access to small_powers, top_power.
+
+        # We use ntl_ZZ_pContexts so that contexts are cached centrally.
+
+        self._prec_type = 'small'
+        self._ext_type = 'u'
+        if not isinstance(poly, ntl_ZZ_pX):
+            self.cleanup_ext()
+            raise TypeError
+
+        if cache_limit != prec_cap:
+            self.cleanup_ext()
+            raise ValueError("prec_cap and cache_limit must be equal in the small case")
+
+        self.c = []
+        # We cache from 0 to cache_limit inclusive, and provide one extra slot to return moduli above the cache_limit
+        sig_on()
+        self.mod = Allocate_ZZ_pX_Modulus_array(cache_limit + 2)
+        sig_off()
+        if self.mod == NULL:
+            self.cleanup_ext()
+            raise MemoryError("out of memory allocating moduli")
+
+        cdef Py_ssize_t i
+        cdef ZZ_pX_c tmp, pol
+        if isinstance(poly, ntl_ZZ_pX):
+            pol = (<ntl_ZZ_pX>poly).x
+            self.c.append(None)
+            for i in range(1, cache_limit + 1):
+                self.c.append(PowComputer_ZZ_pX.get_context(self,i))
+
+            # create a temporary polynomial with the highest modulus to
+            # ensure all mod[i]'s will fit into it
+            (<ntl_ZZ_pContext_class>self.c[cache_limit]).restore_c()
+            tmp = (<ntl_ZZ_pX>poly).x
+
+            for i in range(1, cache_limit + 1):
+                (<ntl_ZZ_pContext_class>self.c[i]).restore_c()
+                ZZ_pX_conv_modulus(tmp, pol, (<ntl_ZZ_pContext_class>self.c[i]).x)
+                ZZ_pX_Modulus_build(self.mod[i], tmp)
+            if prec_cap == ram_prec_cap:
+                self.e = 1
+                self.f = ZZ_pX_deg((<ntl_ZZ_pX>poly).x)
+            else:
+                self.e = ZZ_pX_deg((<ntl_ZZ_pX>poly).x)
+                self.f = 1
+            self.ram_prec_cap = ram_prec_cap
+        else:
+            raise NotImplementedError("NOT IMPLEMENTED IN PowComputer_ZZ_pX_FM")
+
+    def __dealloc__(self):
+        """
+        Deallocate cache of contexts, moduli.
+
+        EXAMPLES::
+
+            sage: A = PowComputer_ext_maker(5, 10, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'small','e',ntl.ZZ_pX([1],5^10))
+            sage: del A  # indirect doctest
+        """
+        if self._initialized:
+            self.cleanup_ZZ_pX_small()
+
+    cdef void cleanup_ZZ_pX_small(self) noexcept:
+        """
+        Deallocate cache of contexts, moduli.
+
+        EXAMPLES::
+
+            sage: A = PowComputer_ext_maker(5, 10, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'small','e',ntl.ZZ_pX([1],5^10))
+            sage: del A  # indirect doctest
+        """
+        Delete_ZZ_pX_Modulus_array(self.mod)
+
+    cdef ntl_ZZ_pContext_class get_context(self, long n):
+        """
+        Return the context for p^n.  This will use the cache if
+        ``abs(n) <= self.cache_limit``.
+
+        INPUT:
+
+        - ``n`` -- nonzero long
+
+        OUTPUT: a context for p^n
+
+        EXAMPLES::
+
+            sage: A = PowComputer_ext_maker(5, 10, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'small','e',ntl.ZZ_pX([1],5^10))
+            sage: A._get_context_test(4)  # indirect doctest
+            NTL modulus 625
+        """
+        if n < 0:
+            n = -n
+        try:
+            return self.c[n]
+        except IndexError:
+            return PowComputer_ZZ_pX.get_context(self, n)
+
+    cdef restore_context(self, long n):
+        """
+        Restore the context for p^n.  This will use the cache if
+        ``abs(n) <= self.cache_limit``.
+
+        INPUT:
+
+        - ``n`` -- nonzero long
+
+        EXAMPLES::
+
+            sage: A = PowComputer_ext_maker(5, 10, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'small','e',ntl.ZZ_pX([1],5^10))
+            sage: A._restore_context_test(4)  # indirect doctest
+        """
+        if n < 0:
+            n = -n
+        try:
+            (<ntl_ZZ_pContext_class>self.c[n]).restore_c()
+        except IndexError:
+            (<ntl_ZZ_pContext_class>PowComputer_ZZ_pX.get_context(self, n)).restore_c()
+
+    cdef ntl_ZZ_pContext_class get_top_context(self):
+        """
+        Return a ``ZZ_pContext`` for ``self.prime^self.prec_cap``.
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 10, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'small','e',ntl.ZZ_pX([1],5^10))
+            sage: PC._get_top_context_test()  # indirect doctest
+            NTL modulus 9765625
+        """
+        return self.c[self.prec_cap]
+
+    cdef void restore_top_context(self) noexcept:
+        """
+        Restore the context corresponding to ``self.prime^self.prec_cap``.
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 10, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'small','e',ntl.ZZ_pX([1],5^10))
+            sage: PC._restore_top_context_test()  # indirect doctest
+        """
+        (<ntl_ZZ_pContext_class>self.c[self.prec_cap]).restore_c()
+
+    cdef ZZ_pX_Modulus_c* get_modulus(self, long n) noexcept:
+        """
+        Return the modulus corresponding to ``self.polynomial()`` (mod
+        ``self.prime^n``).
+
+        INPUT:
+
+        - ``n`` -- a long between 1 and ``self.cache_limit``, inclusive.
+          If `n` is larger, this function will return ``self.mod[prec_cap]``
+          lifted to that precision.
+
+        EXAMPLES::
+
+            sage: A = PowComputer_ext_maker(5, 10, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'small','e',ntl.ZZ_pX([1],5^10))
+            sage: a = ntl.ZZ_pX([4,2],5^2)
+            sage: b = ntl.ZZ_pX([6,3],5^2)
+            sage: A._get_modulus_test(a, b, 2)
+            [4 24]
+        """
+        cdef ZZ_pX_c tmp
+        if n < 0:
+            n = -n
+        if n <= self.prec_cap:
+            return &(self.mod[n])
+        else:
+            ZZ_pX_conv_modulus(tmp, self.mod[self.prec_cap].val(), (<ntl_ZZ_pContext_class>self.get_context(n)).x)
+            ZZ_pX_Modulus_build(self.mod[self.prec_cap+1], tmp)
+            return &(self.mod[self.prec_cap+1])
+
+    cdef ZZ_pX_Modulus_c* get_top_modulus(self) noexcept:
+        """
+        Return the modulus corresponding to ``self.polynomial()``
+        (mod ``self.prime^self.prec_cap``).
+
+        EXAMPLES::
+
+            sage: A = PowComputer_ext_maker(5, 10, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'small','e',ntl.ZZ_pX([1],5^10))
+            sage: a = ntl.ZZ_pX([129223,1231],5^10)
+            sage: b = ntl.ZZ_pX([289741,323],5^10)
+            sage: A._get_top_modulus_test(a, b)  # indirect doctest
+            [1783058 7785200]
+        """
+        return &(self.mod[self.prec_cap])
+
+cdef class PowComputer_ZZ_pX_small_Eis(PowComputer_ZZ_pX_small):
+    """
+    This class computes and stores ``low_shifter`` and ``high_shifter``, which aid in right shifting elements.
+    These are only stored at maximal precision: in order to get lower precision versions just reduce mod p^n.
+    """
+    def __cinit__(self, Integer prime, long cache_limit, long prec_cap, long ram_prec_cap, bint in_field, poly, shift_seed=None):
+        """
+        Initialization.
+
+        For input types see :func:`PowComputer_ext_maker`
+
+        TESTS::
+
+            sage: A = PowComputer_ext_maker(5, 10, 10, 40, False, ntl.ZZ_pX([-5,75,15,0,1],5^10), 'small', 'e',ntl.ZZ_pX([1,-15,-3],5^10))
+            sage: type(A)
+            <class 'sage.rings.padics.pow_computer_ext.PowComputer_ZZ_pX_small_Eis'>
+            sage: TestSuite(A).run()
+        """
+        self._ext_type = 'e'
+        if not isinstance(shift_seed, ntl_ZZ_pX):
+            raise TypeError("shift_seed must be an ntl_ZZ_pX")
+        ZZ_pX_Eis_init(self, <ntl_ZZ_pX>shift_seed)
+
+    def _low_shifter(self, i):
+        """
+        Accessor function for low_shifter, which are the polynomials used to shift right.
+
+        If low_length is the number of low_shifters, then:
+            * if deg = 2, low_length = 1 (store p/x)
+            * if deg = 3,4, low_length = 2 (store p/x, p/x^2)
+            * if deg = 5,6,7,8, low_length = 3 (store p/x, p/x^2, p/x^4)
+            * if deg = 9,...,16, low_length = 4 (store p/x, p/x^2, p/x^4, p/x^8)
+
+        These polynomials are used to shift by amounts less than the degree of the defining polynomial.
+
+        EXAMPLES::
+
+            sage: A = PowComputer_ext_maker(5, 10, 10, 40, False, ntl.ZZ_pX([-5,75,15,0,1],5^10), 'small', 'e',ntl.ZZ_pX([1,-15,-3],5^10))
+            sage: A._low_shifter(0)
+            [75 15 0 1]
+
+            Note that if we multiply this by x and reduce using the relation that x^4 = 5 - 75x - 15x^2, we just get 5.
+
+            sage: A._low_shifter(1)
+            [1140 225 1 15]
+
+            This one's a bit less obvious, but if we multiply by x^2, we get 5 (modulo x^4 = 5 - 75x - 15x^2).
+        """
+        cdef long _i = i
+        cdef ntl_ZZ_pX ans
+        if _i >= 0 and _i < self.low_length:
+            ans = ntl_ZZ_pX([], self.get_top_context())
+            ans.x = self.low_shifter[i]
+            return ans
+        else:
+            raise IndexError
+
+    def _high_shifter(self, i):
+        """
+        Accessor function for high_shifter, which are the polynomials used to shift right.
+
+        If high_length is the number of high_shifters, then:
+            * if prec_cap = 2, high_length = 1 (store p/x^e)
+            * if prec_cap = 3,4, high_length = 2 (store p/x^e, p^2/x^(2e))
+            * if prec_cap = 5,6,7,8, high_length = 3 (store p/x^e, p^2/x^(2e), p^4/x^(4e))
+            * if prec_cap = 9,...,16, high_length = 4 (store p/x, p^2/x^(2e), p^4/x^(4e), p^8/x^(8e))
+
+        These polynomials are used to shift by amounts greater than the degree of the defining polynomial, but less than e*prec_cap.
+
+        EXAMPLES::
+
+            sage: A = PowComputer_ext_maker(5, 10, 10, 40, False, ntl.ZZ_pX([-5,75,15,0,1],5^10), 'small', 'e',ntl.ZZ_pX([1,-15,-3],5^10))
+            sage: A._high_shifter(0)
+            [263296 51990 228 3465]
+
+        If we take this and multiply by x^4, and reduce modulo x^4 + 15*x^2 + 75*x - 5, we should get 5. ::
+
+            sage: R.<x> = ZZ[]
+            sage: f = 263296 + 51990*x + 228*x^2 + 3465*x^3
+            sage: g = x^4 + 15*x^2 + 75*x - 5
+            sage: f*x^4 % g
+            5
+
+            sage: A._high_shifter(1)
+            [1420786 9298230 2217816 6212495]
+
+        Similarly::
+
+            sage: f = 1420786 + 9298230*x + 2217816*x^2 + 6212495*x^3
+            sage: h = f*x^8 % g; h
+            -1328125000000*x^3 + 2962646484375*x^2 + 22094970703125*x - 1466308593725
+
+        Here, we need to remember that we're working modulo 5^10::
+
+            sage: h[0].valuation(5), h[1].valuation(5), h[2].valuation(5), h[3].valuation(5)
+            (2, 12, 13, 13)
+            sage: (h[0] - 25).valuation(5)
+            12
+        """
+        cdef long _i = i
+        cdef ntl_ZZ_pX ans
+        if _i >= 0 and _i < self.high_length:
+            ans = ntl_ZZ_pX([], self.get_top_context())
+            ans.x = self.high_shifter[i]
+            return ans
+        else:
+            raise IndexError
+
+    def __dealloc__(self):
+        """
+        Deallocate ``low_shifter`` and ``high_shifter``.
+
+        TESTS::
+
+            sage: A = PowComputer_ext_maker(5, 10, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'small', 'e',ntl.ZZ_pX([1],5^10))
+            sage: del A  # indirect doctest
+        """
+        if self._initialized:
+            self.cleanup_ZZ_pX_small_Eis()
+
+    cdef void cleanup_ZZ_pX_small_Eis(self) noexcept:
+        """
+        Do the actual work of deallocating ``low_shifter`` and
+        ``high_shifter``.
+
+        TESTS::
+
+            sage: A = PowComputer_ext_maker(5, 3, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'FM', 'e',ntl.ZZ_pX([1],5^10))
+            sage: del A  # indirect doctest
+        """
+        Delete_ZZ_pX_array(self.low_shifter)
+        Delete_ZZ_pX_array(self.high_shifter)
+
+    cdef int eis_shift(self, ZZ_pX_c* x, ZZ_pX_c* a, long n, long finalprec) except -1:
+        """
+        Shift ``a`` right ``n`` pi-adic digits, where pi is considered modulo
+        the polynomial in ``self``.
+
+        Puts the result in ``x``.
+
+        EXAMPLES::
+
+            sage: from sage.rings.padics.pow_computer_ext import ZZ_pX_eis_shift_test
+            sage: A = PowComputer_ext_maker(5, 10, 10, 40, False, ntl.ZZ_pX([-5,75,15,0,1],5^10), 'small', 'e',ntl.ZZ_pX([1,-15,-3],5^10))
+            sage: ZZ_pX_eis_shift_test(A, [0, 1], 1, 5)  # indirect doctest
+            [1]
+            sage: ZZ_pX_eis_shift_test(A, [0, 0, 1], 1, 5)
+            [0 1]
+            sage: ZZ_pX_eis_shift_test(A, [5], 1, 5)
+            [75 15 0 1]
+            sage: ZZ_pX_eis_shift_test(A, [1], 1, 5)
+            []
+            sage: ZZ_pX_eis_shift_test(A, [17, 91, 8, -2], 1, 5)
+            [316 53 3123 3]
+            sage: ZZ_pX_eis_shift_test(A, [316, 53, 3123, 3], -1, 5)
+            [15 91 8 3123]
+            sage: ZZ_pX_eis_shift_test(A, [15, 91, 8, 3123], 1, 5)
+            [316 53 3123 3]
+        """
+        return ZZ_pX_eis_shift_p(self, x, a, n, finalprec)
+
+cdef class PowComputer_ZZ_pX_big(PowComputer_ZZ_pX):
+    """
+    This class caches all contexts and moduli between 1 and cache_limit, and also caches for prec_cap.  In addition, it stores
+    a dictionary of contexts and moduli of
+    """
+
+    def __cinit__(self, Integer prime, long cache_limit, long prec_cap, long ram_prec_cap, bint in_field, poly, shift_seed=None):
+        """
+        Caches contexts and moduli densely between 1 and cache_limit.  Caches a context and modulus for prec_cap.
+        Also creates the dictionaries.
+
+        EXAMPLES::
+
+            sage: A = PowComputer_ext_maker(5, 6, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'big','e',ntl.ZZ_pX([1],5^10))  # indirect doctest
+            sage: A
+            PowComputer_ext for 5, with polynomial [9765620 0 1]
+        """
+        # The __new__ method for PowComputer_ext has already run, so we have access to small_powers, top_power.
+
+        # We use ntl_ZZ_pContexts so that contexts are cached centrally.
+
+        self._prec_type = 'big'
+        self._ext_type = 'u'
+        if not isinstance(poly, ntl_ZZ_pX):
+            self.cleanup_ext()
+            raise TypeError
+
+        self.context_list = []
+        #if self.c == NULL:
+        #    self.cleanup_ext()
+        #    raise MemoryError("out of memory allocating contexts")
+        sig_on()
+        self.modulus_list = Allocate_ZZ_pX_Modulus_array(cache_limit + 1)
+        sig_off()
+        if self.modulus_list == NULL:
+            self.cleanup_ext()
+            raise MemoryError("out of memory allocating moduli")
+
+        cdef Py_ssize_t i
+        cdef ZZ_pX_c tmp, pol
+        if isinstance(poly, ntl_ZZ_pX):
+            pol = (<ntl_ZZ_pX>poly).x
+            self.context_list.append(None)
+            for i in range(1, cache_limit + 1):
+                self.context_list.append(PowComputer_ZZ_pX.get_context(self,i))
+
+            # create a temporary polynomial with the highest modulus to
+            # ensure all mod[i]'s will fit into it
+            self.top_context = PowComputer_ZZ_pX.get_context(self, prec_cap)
+            (<ntl_ZZ_pContext_class>self.top_context).restore_c()
+            tmp = (<ntl_ZZ_pX>poly).x
+
+            for i in range(1, cache_limit + 1):
+                (<ntl_ZZ_pContext_class>self.context_list[i]).restore_c()
+                ZZ_pX_conv_modulus(tmp, pol, (<ntl_ZZ_pContext_class>self.context_list[i]).x)
+                ZZ_pX_Modulus_build(self.modulus_list[i], tmp)
+            (<ntl_ZZ_pContext_class>self.top_context).restore_c()
+            ZZ_pX_conv_modulus(tmp, pol, self.top_context.x)
+            ZZ_pX_Modulus_build(self.top_mod, tmp)
+            self.context_dict = {}
+            self.modulus_dict = {}
+            if prec_cap == ram_prec_cap:
+                self.e = 1
+                self.f = ZZ_pX_deg((<ntl_ZZ_pX>poly).x)
+            else:
+                self.e = ZZ_pX_deg((<ntl_ZZ_pX>poly).x)
+                self.f = 1
+            self.ram_prec_cap = ram_prec_cap
+        else:
+            raise NotImplementedError("NOT IMPLEMENTED IN PowComputer_ZZ_pX_FM")
+
+    def __dealloc__(self):
+        """
+        Deallocate the stored moduli and contexts.
+
+        EXAMPLES::
+
+            sage: A = PowComputer_ext_maker(5, 6, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'big','e',ntl.ZZ_pX([1],5^10))
+            sage: del A  # indirect doctest
+        """
+        if self._initialized:
+            self.cleanup_ZZ_pX_big()
+
+    cdef void cleanup_ZZ_pX_big(self) noexcept:
+        """
+        Deallocate the stored moduli and contexts.
+
+        EXAMPLES::
+
+            sage: A = PowComputer_ext_maker(5, 6, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'big','e',ntl.ZZ_pX([1],5^10))
+            sage: del A  # indirect doctest
+        """
+        Delete_ZZ_pX_Modulus_array(self.modulus_list)
+
+    def reset_dictionaries(self):
+        """
+        Reset the dictionaries.  Note that if there are elements
+        lying around that need access to these dictionaries, calling
+        this function and then doing arithmetic with those elements
+        could cause trouble (if the context object gets garbage
+        collected for example.  The bugs introduced could be very
+        subtle, because NTL will generate a new context object and use
+        it, but there's the potential for the object to be
+        incompatible with the different context object).
+
+        EXAMPLES::
+
+            sage: A = PowComputer_ext_maker(5, 6, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'big','e',ntl.ZZ_pX([1],5^10))
+            sage: P = A._get_context_test(8)
+            sage: A._context_dict()
+            {8: NTL modulus 390625}
+            sage: A.reset_dictionaries()
+            sage: A._context_dict()
+            {}
+        """
+        self.context_dict = {}
+        self.modulus_dict = {}
+
+    def _context_dict(self):
+        """
+        Return the context dictionary.
+
+        EXAMPLES::
+
+            sage: A = PowComputer_ext_maker(5, 6, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'big','e',ntl.ZZ_pX([1],5^10))
+            sage: P = A._get_context_test(8)
+            sage: A._context_dict()
+            {8: NTL modulus 390625}
+        """
+        return self.context_dict
+
+    def _modulus_dict(self):
+        """
+        Return the context dictionary.
+
+        EXAMPLES::
+
+            sage: A = PowComputer_ext_maker(5, 6, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'big','e',ntl.ZZ_pX([1],5^10))
+            sage: P = A._get_context_test(8)
+            sage: A._modulus_dict()
+            {}
+            sage: a = ntl.ZZ_pX([4,2],5^8)
+            sage: b = ntl.ZZ_pX([6,3],5^8)
+            sage: A._get_modulus_test(a, b, 8)
+            [54 24]
+            sage: A._modulus_dict()
+            {8: NTL ZZ_pXModulus [390620 0 1] (mod 390625)}
+        """
+        return self.modulus_dict
+
+    cdef ntl_ZZ_pContext_class get_context(self, long n):
+        """
+        Return the context for p^n.
+
+        INPUT:
+
+        - ``n`` -- nonzero long
+
+        OUTPUT: a context for p^n
+
+        EXAMPLES::
+
+            sage: A = PowComputer_ext_maker(5, 6, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'big')
+            sage: A._get_context_test(4)  # indirect doctest
+            NTL modulus 625
+            sage: A._get_context_test(8)  # indirect doctest
+            NTL modulus 390625
+        """
+        if n == 0:
+            # Exception will be ignored by Cython
+            raise ValueError("n must be nonzero")
+        if n < 0:
+            n = -n
+        if n <= self.cache_limit:
+            return self.context_list[n]
+        elif n == self.prec_cap:
+            return self.top_context
+        else:
+            try:
+                return self.context_dict[n]
+            except KeyError:
+                self.context_dict[n] = PowComputer_ZZ_pX.get_context(self, n)
+                return self.context_dict[n]
+
+    cdef ntl_ZZ_pContext_class get_top_context(self):
+        """
+        Return a ``ZZ_pContext`` for ``self.prime^self.prec_cap``.
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 5, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'big','e',ntl.ZZ_pX([1],5^10))
+            sage: PC._get_top_context_test()  # indirect doctest
+            NTL modulus 9765625
+        """
+        return self.top_context
+
+    cdef void restore_top_context(self) noexcept:
+        """
+        Restore the context corresponding to ``self.prime^self.prec_cap``.
+
+        EXAMPLES::
+
+            sage: PC = PowComputer_ext_maker(5, 5, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'big','e',ntl.ZZ_pX([1],5^10))
+            sage: PC._restore_top_context_test()  # indirect doctest
+        """
+        self.top_context.restore_c()
+
+    cdef ZZ_pX_Modulus_c* get_modulus(self, long n) noexcept:
+        """
+        Return the modulus corresponding to ``self.polynomial()`` (mod
+        ``self.prime^n``).
+
+        INPUT:
+
+        - ``n`` -- nonzero long
+
+        EXAMPLES::
+
+            sage: A = PowComputer_ext_maker(5, 3, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'big','e',ntl.ZZ_pX([1],5^10))
+            sage: a = ntl.ZZ_pX([4,2],5^2)
+            sage: b = ntl.ZZ_pX([6,3],5^2)
+            sage: A._get_modulus_test(a, b, 2)  # indirect doctest
+            [4 24]
+            sage: a = ntl.ZZ_pX([4,2],5^6)
+            sage: b = ntl.ZZ_pX([6,3],5^6)
+            sage: A._get_modulus_test(a, b, 6)  # indirect doctest
+            [54 24]
+            sage: A._get_modulus_test(a, b, 6)  # indirect doctest
+            [54 24]
+        """
+        cdef ntl_ZZ_pX tmp
+        cdef ntl_ZZ_pX_Modulus holder
+        cdef ntl_ZZ_pContext_class c
+        if n == 0:
+            # Exception will be ignored by Cython
+            raise ValueError("n must be nonzero")
+        if n < 0:
+            n = -n
+        elif n <= self.cache_limit:
+            return &(self.modulus_list[n])
+        elif n == self.prec_cap:
+            return &self.top_mod
+        else:
+            if n in self.modulus_dict:
+                return &((<ntl_ZZ_pX_Modulus>self.modulus_dict[n]).x)
+            else:
+                c = self.get_context(n)
+                c.restore_c()
+                tmp = ntl_ZZ_pX.__new__(ntl_ZZ_pX)
+                tmp.c = c
+                ZZ_pX_conv_modulus(tmp.x, self.top_mod.val(), c.x)
+                holder = ntl_ZZ_pX_Modulus(tmp)
+                self.modulus_dict[n] = holder
+                return &(holder.x)
+
+    cdef ZZ_pX_Modulus_c* get_top_modulus(self) noexcept:
+        """
+        Return the modulus corresponding to ``self.polynomial()``
+        (mod ``self.prime^self.prec_cap``).
+
+        EXAMPLES::
+
+            sage: A = PowComputer_ext_maker(5, 5, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'big','e',ntl.ZZ_pX([1],5^10))
+            sage: a = ntl.ZZ_pX([129223,1231],5^10)
+            sage: b = ntl.ZZ_pX([289741,323],5^10)
+            sage: A._get_top_modulus_test(a, b)  # indirect doctest
+            [1783058 7785200]
+        """
+        return &self.top_mod
+
+cdef class PowComputer_ZZ_pX_big_Eis(PowComputer_ZZ_pX_big):
+    """
+    This class computes and stores ``low_shifter`` and ``high_shifter``, which
+    aid in right shifting elements.
+    These are only stored at maximal precision: in order to get lower precision
+    versions just reduce mod p^n.
+    """
+    def __cinit__(self, Integer prime, long cache_limit, long prec_cap, long ram_prec_cap, bint in_field, poly, shift_seed=None):
+        """
+        Initialization.
+
+        For input types see :func:`PowComputer_ext_maker`
+
+        TESTS::
+
+            sage: A = PowComputer_ext_maker(5, 3, 10, 40, False, ntl.ZZ_pX([-5,75,15,0,1],5^10), 'big', 'e',ntl.ZZ_pX([1,-15,-3],5^10))
+            sage: type(A)
+            <class 'sage.rings.padics.pow_computer_ext.PowComputer_ZZ_pX_big_Eis'>
+            sage: TestSuite(A).run()
+        """
+        self._ext_type = 'e'
+        if not isinstance(shift_seed, ntl_ZZ_pX):
+            raise TypeError("shift_seed must be an ntl_ZZ_pX")
+        ZZ_pX_Eis_init(self, <ntl_ZZ_pX>shift_seed)
+
+    def _low_shifter(self, i):
+        """
+        Accessor function for low_shifter, which are the polynomials used to shift right.
+
+        If low_length is the number of low_shifters, then:
+            * if deg = 2, low_length = 1 (store p/x)
+            * if deg = 3,4, low_length = 2 (store p/x, p/x^2)
+            * if deg = 5,6,7,8, low_length = 3 (store p/x, p/x^2, p/x^4)
+            * if deg = 9,...,16, low_length = 4 (store p/x, p/x^2, p/x^4, p/x^8)
+
+        These polynomials are used to shift by amounts less than the degree of the defining polynomial.
+
+        EXAMPLES::
+
+            sage: A = PowComputer_ext_maker(5, 3, 10, 40, False, ntl.ZZ_pX([-5,75,15,0,1],5^10), 'big', 'e',ntl.ZZ_pX([1,-15,-3],5^10))
+            sage: A._low_shifter(0)
+            [75 15 0 1]
+
+            Note that if we multiply this by x and reduce using the relation that x^4 = 5 - 75x - 15x^2, we just get 5.
+
+            sage: A._low_shifter(1)
+            [1140 225 1 15]
+
+            This one's a bit less obvious, but if we multiply by x^2, we get 5 (modulo x^4 = 5 - 75x - 15x^2).
+        """
+        cdef long _i = i
+        cdef ntl_ZZ_pX ans
+        if _i >= 0 and _i < self.low_length:
+            ans = ntl_ZZ_pX([], self.get_top_context())
+            ans.x = self.low_shifter[i]
+            return ans
+        else:
+            raise IndexError
+
+    def _high_shifter(self, i):
+        """
+        Accessor function for high_shifter, which are the polynomials used to shift right.
+
+        If high_length is the number of high_shifters, then:
+            * if prec_cap = 2, high_length = 1 (store p/x^e)
+            * if prec_cap = 3,4, high_length = 2 (store p/x^e, p^2/x^(2e))
+            * if prec_cap = 5,6,7,8, high_length = 3 (store p/x^e, p^2/x^(2e), p^4/x^(4e))
+            * if prec_cap = 9,...,16, high_length = 4 (store p/x, p^2/x^(2e), p^4/x^(4e), p^8/x^(8e))
+
+        These polynomials are used to shift by amounts greater than the degree of the defining polynomial, but less than e*prec_cap.
+
+        EXAMPLES::
+
+            sage: A = PowComputer_ext_maker(5, 3, 10, 40, False, ntl.ZZ_pX([-5,75,15,0,1],5^10), 'big', 'e',ntl.ZZ_pX([1,-15,-3],5^10))
+            sage: A._high_shifter(0)
+            [263296 51990 228 3465]
+
+        If we take this and multiply by x^4, and reduce modulo x^4 + 15*x^2 + 75*x - 5, we should get 5. ::
+
+            sage: R.<x> = ZZ[]
+            sage: f = 263296 + 51990*x + 228*x^2 + 3465*x^3
+            sage: g = x^4 + 15*x^2 + 75*x - 5
+            sage: f*x^4 % g
+            5
+
+            sage: A._high_shifter(1)
+            [1420786 9298230 2217816 6212495]
+
+        Similarly::
+
+            sage: f = 1420786 + 9298230*x + 2217816*x^2 + 6212495*x^3
+            sage: h = f*x^8 % g; h
+            -1328125000000*x^3 + 2962646484375*x^2 + 22094970703125*x - 1466308593725
+
+        Here, we need to remember that we're working modulo 5^10::
+
+            sage: h[0].valuation(5), h[1].valuation(5), h[2].valuation(5), h[3].valuation(5)
+            (2, 12, 13, 13)
+            sage: (h[0] - 25).valuation(5)
+            12
+        """
+        cdef long _i = i
+        cdef ntl_ZZ_pX ans
+        if _i >= 0 and _i < self.high_length:
+            ans = ntl_ZZ_pX([], self.get_top_context())
+            ans.x = self.high_shifter[i]
+            return ans
+        else:
+            raise IndexError
+
+    def __dealloc__(self):
+        """
+        Deallocate ``low_shifter`` and ``high_shifter``.
+
+        TESTS::
+
+            sage: A = PowComputer_ext_maker(5, 10, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'big', 'e',ntl.ZZ_pX([1],5^10))
+            sage: del A  # indirect doctest
+        """
+        if self._initialized:
+            self.cleanup_ZZ_pX_big_Eis()
+
+    cdef void cleanup_ZZ_pX_big_Eis(self) noexcept:
+        """
+        Do the actual work of deallocating ``low_shifter`` and
+        ``high_shifter``.
+
+        TESTS::
+
+            sage: A = PowComputer_ext_maker(5, 3, 10, 20, False, ntl.ZZ_pX([-5,0,1],5^10), 'FM', 'e',ntl.ZZ_pX([1],5^10))
+            sage: del A  # indirect doctest
+        """
+        Delete_ZZ_pX_array(self.low_shifter)
+        Delete_ZZ_pX_array(self.high_shifter)
+
+    cdef int eis_shift(self, ZZ_pX_c* x, ZZ_pX_c* a, long n, long finalprec) except -1:
+        """
+        Shift ``a`` right ``n`` pi-adic digits, where pi is considered modulo
+        the polynomial in ``self``.
+
+        Puts the result in ``x``.
+
+        EXAMPLES::
+
+            sage: from sage.rings.padics.pow_computer_ext import ZZ_pX_eis_shift_test
+            sage: A = PowComputer_ext_maker(5, 10, 10, 40, False, ntl.ZZ_pX([-5,75,15,0,1],5^10), 'big', 'e',ntl.ZZ_pX([1,-15,-3],5^10))
+            sage: ZZ_pX_eis_shift_test(A, [0, 1], 1, 5)  # indirect doctest
+            [1]
+            sage: ZZ_pX_eis_shift_test(A, [0, 0, 1], 1, 5)
+            [0 1]
+            sage: ZZ_pX_eis_shift_test(A, [5], 1, 5)
+            [75 15 0 1]
+            sage: ZZ_pX_eis_shift_test(A, [1], 1, 5)
+            []
+            sage: ZZ_pX_eis_shift_test(A, [17, 91, 8, -2], 1, 5)
+            [316 53 3123 3]
+            sage: ZZ_pX_eis_shift_test(A, [316, 53, 3123, 3], -1, 5)
+            [15 91 8 3123]
+            sage: ZZ_pX_eis_shift_test(A, [15, 91, 8, 3123], 1, 5)
+            [316 53 3123 3]
+        """
+        return ZZ_pX_eis_shift_p(self, x, a, n, finalprec)
+
+
+def PowComputer_ext_maker(prime, cache_limit, prec_cap, ram_prec_cap, in_field, poly, prec_type="small", ext_type="u", shift_seed=None):
+    r"""
+    Return a ``PowComputer`` that caches the values `1, p, p^2, \ldots, p^C`,
+    where `C` is ``cache_limit``.
+
+    Once you create a ``PowComputer``, merely call it to get values out.
+    You can input any integer, even if it's outside of the precomputed range.
+
+    INPUT:
+
+    - ``prime`` -- integer; the base that you want to exponentiate
+
+    - ``cache_limit`` -- positive integer that you want to cache
+      powers up to
+
+    - ``prec_cap`` -- the cap on precisions of elements.  For ramified
+      extensions, p^((prec_cap - 1) // e) will be the largest
+      power of p distinguishable from zero.
+
+    - ``in_field`` -- boolean indicating whether this PowComputer is
+      attached to a field or not
+
+    - ``poly`` -- an ``ntl_ZZ_pX`` or ``ntl_ZZ_pEX`` defining the extension.
+      It should be defined modulo ``p^((prec_cap - 1) // e + 1)``.
+
+    - ``prec_type`` -- ``'FM'``, ``'small'``, or ``'big'``, defining how
+      caching is done
+
+    - ``ext_type`` -- ``'u'`` = unramified, ``'e'`` = Eisenstein, ``'t'`` =
+      two-step
+
+    - ``shift_seed`` -- (required only for Eisenstein and two-step)
+      for Eisenstein and two-step extensions, if f = a_n x^n - p
+      a_{n-1} x^{n-1} - ... - p a_0 with a_n a unit, then
+      shift_seed should be 1/a_n (a_{n-1} x^{n-1} + ... + a_0)
+
+    EXAMPLES::
+
+        sage: PC = PowComputer_ext_maker(5, 10, 10, 20, False, ntl.ZZ_pX([-5, 0, 1], 5^10), 'small','e',ntl.ZZ_pX([1],5^10))
+        sage: PC
+        PowComputer_ext for 5, with polynomial [9765620 0 1]
+    """
+    cdef Integer _prime = <Integer>Integer(prime)
+    cdef long _cache_limit = mpz_get_si((<Integer>Integer(cache_limit)).value)
+    cdef long _prec_cap = mpz_get_si((<Integer>Integer(prec_cap)).value)
+    cdef long _ram_prec_cap = mpz_get_si((<Integer>Integer(ram_prec_cap)).value)
+    cdef bint inf = in_field
+    if ext_type != "u" and shift_seed is None:
+        raise ValueError("must provide shift seed")
+    if prec_type == "small" and ext_type == "u":
+        return PowComputer_ZZ_pX_small(_prime, _cache_limit, _prec_cap, _ram_prec_cap, inf, poly, None)
+    elif prec_type == "small" and ext_type == "e":
+        return PowComputer_ZZ_pX_small_Eis(_prime, _cache_limit, _prec_cap, _ram_prec_cap, inf, poly, shift_seed)
+    elif prec_type == "big" and ext_type == "u":
+        return PowComputer_ZZ_pX_big(_prime, _cache_limit, _prec_cap, _ram_prec_cap, inf, poly, None)
+    elif prec_type == "big" and ext_type == "e":
+        return PowComputer_ZZ_pX_big_Eis(_prime, _cache_limit, _prec_cap, _ram_prec_cap, inf, poly, shift_seed)
+    elif prec_type == "FM" and ext_type == "u":
+        return PowComputer_ZZ_pX_FM(_prime, _cache_limit, _prec_cap, _ram_prec_cap, inf, poly, None)
+    elif prec_type == "FM" and ext_type == "e":
+        return PowComputer_ZZ_pX_FM_Eis(_prime, _cache_limit, _prec_cap, _ram_prec_cap, inf, poly, shift_seed)
+    else:
+        raise ValueError("prec_type must be one of 'small', 'big' or 'FM' and ext_type must be one of 'u' or 'e' or 't'")