Ticket #4302: polynomial_gf2x.patch

sage/libs/ntl/ntl_GF2X.pyx

@@ -23 +23 @@
 
 from ntl_ZZ import unpickle_class_value
 from ntl_GF2 cimport ntl_GF2
+
 
 ##############################################################################
 #
@@ -123 +124 @@
         from sage.rings.finite_field_givaro import FiniteField_givaroElement
         from sage.rings.finite_field_ntl_gf2e import FiniteField_ntl_gf2eElement
         from sage.rings.ring import FiniteField
-        from sage.rings.polynomial.polynomial_modn_dense_ntl import Polynomial_dense_mod_p
+        from sage.rings.polynomial.polynomial_gf2x import Polynomial_GF2X
 
         cdef long _x
         
@@ -141 +142 @@
         if PY_TYPE_CHECK(x, Integer):
             #binary repr, reversed, and "["..."]" added
             x="["+x.binary()[::-1].replace(""," ")+"]"
-        elif PY_TYPE_CHECK(x, Polynomial_dense_mod_p):
-                x=x.ntl_ZZ_pX()
+        elif PY_TYPE_CHECK(x, Polynomial_GF2X):
+            x = x.list() # this is slow but cimport leads to circular imports
         elif PY_TYPE_CHECK(x, FiniteField):
             if x.characteristic() == 2:
                 x= list(x.modulus())

new file sage/libs/ntl/ntl_GF2X_decl.pxd

@@ +1 @@
+from sage.libs.ntl.ntl_GF2_decl cimport GF2_c
+from sage.libs.ntl.ntl_ZZ_decl cimport ZZ_c
+
+cdef extern from "ntl_wrap.h":
+    ctypedef struct GF2X_c "struct GF2X":
+        pass
+
+    long *GF2XHexOutput_c "(&GF2X::HexOutput)" # work-around for Cython bug
+
+    GF2X_c* GF2X_new "New<GF2X>"()
+    GF2X_c* GF2X_construct "Construct<GF2X>"(void *mem)
+    void GF2X_destruct "Destruct<GF2X>"(GF2X_c *mem)
+    void GF2X_delete "Delete<GF2X>"(GF2X_c *mem)
+    void GF2X_from_str "_from_str<GF2X>"(GF2X_c* dest, char* s)
+    object GF2X_to_PyString "_to_PyString<GF2X>"(GF2X_c *x)
+    int GF2X_equal "_equal<GF2X>"(GF2X_c x, GF2X_c y)
+    int GF2X_IsOne "IsOne"(GF2X_c x)
+    int GF2X_IsZero "IsZero"(GF2X_c x)
+    int GF2X_IsX "IsX"(GF2X_c x)
+
+    void GF2X_add "add"( GF2X_c x, GF2X_c a, GF2X_c b)
+    void GF2X_sub "sub"( GF2X_c x, GF2X_c a, GF2X_c b)
+    void GF2X_mul "mul"( GF2X_c x, GF2X_c a, GF2X_c b)
+    void GF2X_negate "negate"(GF2X_c x, GF2X_c a)
+    void GF2X_power "power"(GF2X_c t, GF2X_c x, long e)
+    long GF2X_deg "deg"(GF2X_c x)
+
+    void GF2X_conv_long "conv" (GF2X_c x, long a)
+    void GF2X_conv_GF2 "conv" (GF2X_c x, GF2_c a)
+
+    void GF2X_LeftShift "LeftShift"( GF2X_c r, GF2X_c a, long offset)
+    void GF2X_RightShift "RightShift"( GF2X_c r, GF2X_c a, long offset)
+
+    void GF2X_DivRem "DivRem"(GF2X_c q, GF2X_c r, GF2X_c a, GF2X_c b)
+    void GF2X_div "div" (GF2X_c q, GF2X_c a, GF2X_c b)
+    void GF2X_rem "rem" (GF2X_c r, GF2X_c a, GF2X_c b)
+    long GF2X_divide "divide"(GF2X_c q, GF2X_c a, GF2X_c b)
+
+    void GF2X_GCD "GCD" (GF2X_c r, GF2X_c a, GF2X_c b)
+    void GF2X_XGCD "XGCD" (GF2X_c r, GF2X_c s, GF2X_c t, GF2X_c a, GF2X_c b)
+
+    void GF2XFromBytes(GF2X_c a, unsigned char *p, long n)
+    void BytesFromGF2X "BytesFromGF2X" (unsigned char *p, GF2X_c a, long n)
+
+    GF2_c GF2X_coeff "coeff"(GF2X_c a, long i)
+    GF2_c GF2X_LeadCoeff "LeadCoeff"(GF2X_c a)
+    GF2_c GF2X_ConstTerm "ConstTerm"(GF2X_c a)
+    void GF2X_SetCoeff "SetCoeff"(GF2X_c x, long i, GF2_c a)
+    void GF2X_SetCoeff_long "SetCoeff"(GF2X_c x, long i, long a)
+
+    GF2X_c GF2X_diff "diff"(GF2X_c a)
+    GF2X_c GF2X_reverse "reverse"(GF2X_c a, long hi)
+
+    long GF2X_weight "weight"(GF2X_c a)
+    long GF2X_NumBits "NumBits" (GF2X_c a)
+    long GF2X_NumBytes "NumBytes"(GF2X_c a)
+
+    #### GF2XFactoring
+    void GF2X_BuildSparseIrred "BuildSparseIrred" (GF2X_c f, long n)
+    void GF2X_BuildRandomIrred "BuildRandomIrred" (GF2X_c f, GF2X_c g)
+
+    #### GF2XModulus_c
+    ctypedef struct GF2XModulus_c "struct GF2XModulus":
+        pass
+
+    GF2XModulus_c* GF2XModulus_new "New<GF2XModulus>"()
+    GF2XModulus_c* GF2XModulus_construct "Construct<GF2XModulus>"(void *mem)
+    void GF2XModulus_destruct "Destruct<GF2XModulus>"(GF2XModulus_c *mem)
+    void GF2XModulus_delete "Delete<GF2XModulus>"(GF2XModulus_c *mem)
+    void GF2XModulus_from_str "_from_str<GF2XModulus>"(GF2XModulus_c* dest, char* s)
+    void GF2XModulus_build "build"(GF2XModulus_c F, GF2X_c f) # MUST be called before using the modulus
+    long GF2XModulus_deg "deg"(GF2XModulus_c F)
+
+
+    GF2X_c GF2XModulus_GF2X "GF2X" (GF2XModulus_c m)
+
+    GF2X_c GF2X_IrredPolyMod "IrredPolyMod" (GF2X_c g, GF2XModulus_c F)
+
+    void GF2X_MulMod_pre "MulMod"(GF2X_c x, GF2X_c a, GF2X_c b, GF2XModulus_c F)
+    void GF2X_SqrMod_pre "SqrMod"(GF2X_c x, GF2X_c a, GF2XModulus_c F)
+    void GF2X_PowerMod_pre "PowerMod"(GF2X_c x, GF2X_c a, ZZ_c e, GF2XModulus_c F)
+    void GF2X_PowerMod_long_pre "PowerMod"(GF2X_c x, GF2X_c a, long e, GF2XModulus_c F)
+    void GF2X_PowerXMod_pre "PowerXMod"(GF2X_c x, ZZ_c e, GF2XModulus_c F)
+    void GF2X_PowerXMod_long_pre "PowerXMod"(GF2X_c x, long e, GF2XModulus_c F)
+    void GF2X_PowerXPlusAMod_pre "PowerXPlusAMod"(GF2X_c x, GF2_c a, GF2_c e, GF2XModulus_c F)
+    void GF2X_PowerXPlusAMod_long_pre "PowerXPlusAMod"(GF2X_c x, GF2_c a, long e, GF2XModulus_c F)
+
+    
+    # x = g(h) mod f; deg(h) < n
+    void GF2X_CompMod "CompMod"(GF2X_c x, GF2X_c g, GF2X_c h, GF2XModulus_c F)
+    # xi = gi(h) mod f (i=1,2), deg(h) < n.
+    void GF2X_Comp2Mod "Comp2Mod"(GF2X_c x1, GF2X_c x2, GF2X_c g1, GF2X_c g2, GF2X_c h, GF2XModulus_c F)
+
+    # xi = gi(h) mod f (i=1,2,3), deg(h) < n.
+    void GF2X_CompMod3 "Comp2Mod"(GF2X_c x1, GF2X_c x2, GF2X_c x3, GF2X_c g1, GF2X_c g2, GF2X_c g3, GF2X_c h, GF2XModulus_c F)

new file sage/libs/ntl/ntl_GF2X_linkage.pxi

@@ +1 @@
+r"""
+Linkage for arithmetic with NTL's GF2X elements.
+
+This file provides the backend for \class{Polynomial_GF2X} via
+templating.
+
+AUTHOR:
+    -- Martin Albrecht (2008-10): initial version
+"""
+#*****************************************************************************
+#       Copyright (C) 2008 Martin Albrecht <M.R.Albrecht@rhul.ac.uk>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  http://www.gnu.org/licenses/
+#*****************************************************************************
+
+from sage.libs.ntl.ntl_GF2_decl cimport *, GF2_c
+from sage.libs.ntl.ntl_GF2X_decl cimport *, GF2X_c, GF2XModulus_c
+
+cdef int celement_construct(GF2X_c *e, parent):
+    """
+    EXAMPLE:
+        sage: P.<x> = GF(2)[]
+    """
+    GF2X_construct(e)
+
+cdef int celement_destruct(GF2X_c *e, parent):
+    """
+    EXAMPLE:
+        sage: P.<x> = GF(2)[]
+        sage: del x
+    """
+    GF2X_destruct(e)
+
+cdef int celement_gen(GF2X_c *e, long i, parent) except -2:
+    """
+    EXAMPLE:
+        sage: P.<x> = GF(2)[]
+    """
+    cdef unsigned char g = 2
+    GF2XFromBytes(e[0], <unsigned char *>(&g), 1)
+
+cdef object celement_repr(GF2X_c *e, parent):
+    """
+    We ignore NTL's printing.
+
+    EXAMPLE:
+        sage: P.<x> = GF(2)[]
+        sage: x
+        x
+    """
+    #return GF2X_to_PyString(e)
+    raise NotImplementedError
+
+cdef inline int celement_set(GF2X_c* res, GF2X_c* a, parent) except -2:
+    """
+    EXAMPLE:
+        sage: P.<x> = GF(2)[]
+        sage: y = x; y
+        x
+    """
+    res[0] = a[0]
+
+cdef inline int celement_set_si(GF2X_c* res, long i, parent) except -2:
+    """
+    EXAMPLE:
+        sage: P.<x> = GF(2)[]
+        sage: P(0)
+        0
+        sage: P(2)
+        0
+        sage: P(1)
+        1
+    """
+    GF2X_conv_long(res[0], i)
+
+cdef inline long celement_get_si(GF2X_c* res, parent) except -2:
+    raise NotImplementedError
+    
+cdef inline bint celement_is_zero(GF2X_c* a, parent) except -2:
+    """
+    EXAMPLE:
+        sage: P.<x> = GF(2)[]
+        sage: bool(x), x.is_zero()
+        (True, False)
+        sage: bool(P(0)), P(0).is_zero()
+        (False, True)
+    """
+    return GF2X_IsZero(a[0])
+
+cdef inline bint celement_is_one(GF2X_c *a, parent) except -2:
+    """
+    EXAMPLE:
+        sage: P.<x> = GF(2)[]
+        sage: x.is_one()
+        False
+        sage: P(1).is_one()
+        True
+    """
+    return GF2X_IsOne(a[0])
+
+cdef inline bint celement_equal(GF2X_c *a, GF2X_c *b, parent) except -2:
+    """
+    EXAMPLE:
+        sage: P.<x> = GF(2)[]
+        sage: x == x
+        True
+        sage: y = x; x == y
+        True
+        sage: x^2 + 1 == x^2 + x
+        False
+    """
+    return GF2X_equal(a[0], b[0])
+
+cdef inline int celement_cmp(GF2X_c *a, GF2X_c *b, parent) except -2:
+    """
+    EXAMPLE:
+        sage: P.<x> = GF(2)[]
+        sage: x != 1
+        True
+        sage: x < 1
+        False
+        sage: x > 1
+        True
+    """
+    cdef bint t
+    cdef long diff
+    diff = GF2X_NumBits(a[0]) - GF2X_NumBits(b[0])
+    if diff > 0:
+        return 1
+    elif diff == 0:
+        t = GF2X_equal(a[0], b[0])
+        return not t
+    else:
+        return -1
+
+cdef inline long celement_hash(GF2X_c *a, parent) except -2:
+    """
+    EXAMPLE:
+        sage: P.<x> = GF(2)[]
+        sage: {x:1}
+        {x: 1}
+    """
+    cdef long _hex = GF2XHexOutput_c[0]
+    GF2XHexOutput_c[0] = 1
+    s = GF2X_to_PyString(a)
+    GF2XHexOutput_c[0] = _hex
+    return hash(s)
+
+cdef long celement_len(GF2X_c *a, parent) except -2:
+    """
+    EXAMPLE:
+        sage: P.<x> = GF(2)[]
+        sage: len(x)
+        2
+        sage: len(x+1)
+        2
+    """
+    return int(GF2X_NumBits(a[0]))
+
+cdef inline int celement_add(GF2X_c *res, GF2X_c *a, GF2X_c *b, parent) except -2:
+    """
+    EXAMPLE:
+        sage: P.<x> = GF(2)[]
+        sage: x + 1
+        x + 1
+    """
+    GF2X_add(res[0], a[0], b[0])
+
+cdef inline int celement_sub(GF2X_c* res, GF2X_c* a, GF2X_c* b, parent) except -2:
+    """
+    EXAMPLE:
+        sage: P.<x> = GF(2)[]
+        sage: x - 1
+        x + 1
+    """
+    GF2X_sub(res[0], a[0], b[0])
+
+cdef inline int celement_neg(GF2X_c* res, GF2X_c* a, parent) except -2:
+    """
+    EXAMPLE:
+        sage: P.<x> = GF(2)[]
+        sage: -x
+        x
+    """
+    res[0] = a[0]
+
+cdef inline int celement_mul(GF2X_c* res, GF2X_c* a, GF2X_c* b, parent) except -2:
+    """
+    EXAMPLE:
+        sage: P.<x> = GF(2)[]
+        sage: x*(x+1)
+        x^2 + x
+    """
+    GF2X_mul(res[0], a[0], b[0])
+
+cdef inline int celement_div(GF2X_c* res, GF2X_c* a, GF2X_c* b, parent) except -2:
+    """
+    EXAMPLE:
+        sage: P.<x> = GF(2)[]
+    """
+    return GF2X_divide(res[0], a[0], b[0])
+
+cdef inline int celement_floordiv(GF2X_c* res, GF2X_c* a, GF2X_c* b, parent) except -2:
+    """
+    EXAMPLE:
+        sage: P.<x> = GF(2)[]
+        sage: x//(x + 1)
+        1
+        sage: (x + 1)//x
+        1
+    """
+    GF2X_div(res[0], a[0], b[0])
+
+cdef inline int celement_mod(GF2X_c* res, GF2X_c* a, GF2X_c* b, parent) except -2:
+    """
+    EXAMPLE:
+        sage: P.<x> = GF(2)[]
+        sage: (x^2 + 1) % x^2
+        1
+    """
+    GF2X_rem(res[0], a[0], b[0])
+
+cdef inline int celement_quorem(GF2X_c* q, GF2X_c* r, GF2X_c* a, GF2X_c* b, parent) except -2:
+    """
+    EXAMPLE:
+        sage: P.<x> = GF(2)[]
+        sage: f = x^2 + x + 1
+        sage: f.quo_rem(x + 1)
+        (x, 1)
+    """
+    GF2X_DivRem(q[0], r[0], a[0], b[0])
+
+cdef inline int celement_inv(GF2X_c* res, GF2X_c* a, parent) except -2:
+    """
+    We ignore NTL here and use the fraction field constructor.
+
+    EXAMPLE:
+        sage: P.<x> = GF(2)[]
+    """
+    raise NotImplementedError
+
+cdef inline int celement_pow(GF2X_c* res, GF2X_c* x, long e, GF2X_c *modulus, parent) except -2:
+    """
+    EXAMPLE:
+        sage: P.<x> = GF(2)[]
+        sage: x^1000
+        x^1000
+        sage: (x+1)^2
+        x^2 + 1
+        sage: (x+1)^(-2)
+        1/(x^2 + 1)
+        sage: f = x^9 + x^7 + x^6 + x^5 + x^4 + x^2 + x
+        sage: h = x^10 + x^7 + x^6 + x^5 + x^4 + x^3 + x^2 + 1
+        sage: (f^2) % h
+        x^9 + x^8 + x^7 + x^5 + x^3
+        sage: pow(f, 2, h)
+        x^9 + x^8 + x^7 + x^5 + x^3
+    """
+    cdef GF2XModulus_c mod
+
+    if modulus == NULL:
+        if GF2X_IsX(x[0]):
+                GF2X_LeftShift(res[0], x[0], e - 1)
+        else:
+            do_sig = GF2X_deg(x[0]) > 1e5
+            if do_sig: _sig_on
+            GF2X_power(res[0], x[0], e)
+            if do_sig: _sig_off
+    else:
+        GF2XModulus_build(mod, modulus[0])
+            
+        do_sig = GF2X_deg(x[0]) > 1e5
+        if do_sig: _sig_on
+        GF2X_PowerMod_long_pre(res[0], x[0], e, mod)
+        if do_sig: _sig_off
+
+cdef inline int celement_gcd(GF2X_c* res, GF2X_c* a, GF2X_c *b, parent) except -2:
+    """
+    EXAMPLE:
+        sage: P.<x> = GF(2)[]
+        sage: f = x*(x+1)
+        sage: f.gcd(x+1)
+        x + 1
+        sage: f.gcd(x^2)
+        x
+    """
+    GF2X_GCD(res[0], a[0], b[0])    

new file sage/libs/ntl/ntl_GF2_decl.pxd

@@ +1 @@
+cdef extern from "ntl_wrap.h":
+    ctypedef struct GF2_c "struct GF2":
+        pass
+
+    GF2_c* GF2_new "New<GF2>"()
+    GF2_c* GF2_construct "Construct<GF2>"(void *mem)
+    void GF2_destruct "Destruct<GF2>"(GF2_c *mem)
+    void GF2_delete "Delete<GF2>"(GF2_c *mem)
+    void GF2_from_str "_from_str<GF2>"(GF2_c* dest, char* s)
+    object GF2_to_PyString "_to_PyString<GF2>"(GF2_c *x)
+    int GF2_equal "_equal<GF2>"(GF2_c x, GF2_c y)
+    int GF2_IsOne "IsOne"(GF2_c x)
+    int GF2_IsZero "IsZero"(GF2_c x)
+
+    void GF2_add "add"( GF2_c x, GF2_c a, GF2_c b)
+    void GF2_sub "sub"( GF2_c x, GF2_c a, GF2_c b)
+    void GF2_mul "mul"( GF2_c x, GF2_c a, GF2_c b)
+    void GF2_div "div"( GF2_c x, GF2_c a, GF2_c b)
+    void GF2_negate "negate"(GF2_c x, GF2_c a)
+    void GF2_power "power"(GF2_c t, GF2_c x, long e)
+    long GF2_deg "deg"(GF2_c x)
+
+    void GF2_conv_long "conv" (GF2_c x, long i)
+    long GF2_conv_to_long "rep" (GF2_c x)

sage/matrix/matrix_mod2_dense.pyx

@@ -1403 +1403 @@
         gdImageDestroy(im)
         return unpickle_matrix_mod2_dense_v1, (r,c, data, size)
 
-
 # Used for hashing
 cdef int i, k
 cdef unsigned long parity_table[256]
@@ -1565 +1564 @@
     gdImageDestroy(im)
     fclose(out)
 
-
-
-
 # This is basically test code, do not call it will break Sage's
 # assumptions about matrices (malb).
 

sage/rings/polynomial/polynomial_element.pyx

@@ -986 +986 @@
         return RingElement.__div__(self, right)
         
         
-    def __pow__(self, right, dummy):
+    def __pow__(self, right, modulus):
         """
         EXAMPLES:
             sage: R.<x> = ZZ[]
@@ -997 +997 @@
             x^3 - 3*x^2 + 3*x - 1            
         """
         if self.degree() <= 0:
-            return self.parent()(self[0]**right)
-        if right < 0:
-            return (~self)**(-right)
-        if (<Polynomial>self)._is_gen:   # special case x**n should be faster!
+            r = self.parent()(self[0]**right)
+        elif right < 0:
+            r = (~self)**(-right)
+        elif (<Polynomial>self) == self.parent().gen():   # special case x**n should be faster!
             P = self.parent()
             R = P.base_ring()
             if P.is_sparse():
                 v = {right:R(1)}
             else:
                 v = [R(0)]*right + [R(1)]
-            return self.parent()(v, check=False)
-        return generic_power(self, right)
+            r = self.parent()(v, check=False)
+        else:
+            r = generic_power(self, right)
+        if modulus:
+            return r % modulus
+        else:
+            return r
         
     def _pow(self, right):
         # TODO: fit __pow__ into the arithmetic structure
@@ -1016 +1021 @@
             return self.parent()(self[0]**right)
         if right < 0:
             return (~self)**(-right)
-        if (<Polynomial>self)._is_gen:   # special case x**n should be faster!
+        if (<Polynomial>self) == self.parent().gen():   # special case x**n should be faster!
             v = [0]*right + [1]
             return self.parent()(v, check=True)
         return generic_power(self, right)
@@ -2188 +2193 @@
             pari.set_real_precision(n)  # restore precision
         return Factorization(F, unit)
 
+    def lcm(self, other):
+        """
+        Let f and g be two polynomials.  Then this function
+        returns the monic least common multiple of f and g.
+        """
+        f = self*other
+        g = self.gcd(other)
+        q = f//g 
+        return ~(q.leading_coefficient())*q
+
     def _lcm(self, other):
         """
         Let f and g be two polynomials.  Then this function
@@ -2197 +2212 @@
         g = self.gcd(other)
         q = f//g  
         return ~(q.leading_coefficient())*q  # make monic  (~ is inverse in python)
+
+    def is_primitive(self):
+        """
+        Identifies whether a polynomial is primitive.
+        A polynomial can only be primitive if it is irreducible.
+
+        EXAMPLES:
+            sage: R.<x> = GF(2)['x']
+            sage: f = x^4+x^3+x^2+x+1
+            sage: f.is_irreducible(), f.is_primitive()
+            (True, False)
+            sage: f = x^3+x+1
+            sage: f.is_irreducible(), f.is_primitive()
+            (True, True)
+            sage: R.<x> = GF(3)[]
+            sage: f = x^3-x+1
+            sage: f.is_irreducible(), f.is_primitive()
+            (True, True)
+            sage: f = x^2+1
+            sage: f.is_irreducible(), f.is_primitive()
+            (True, False)
+            sage: R.<x> = GF(5)[]
+            sage: f = x^2+x+1
+            sage: f.is_primitive()
+            False
+            sage: f = x^2-x+2
+            sage: f.is_primitive()
+            True
+        """
+        if not self.is_irreducible():
+            return False
+        p = self.parent().characteristic()
+        n = p ** self.degree() - 1
+        y = self.parent().quo(self).gen()
+        for d in n.prime_divisors():
+            if ( y ** (n//d) ) == 1:
+                return False
+        return True
 
     def is_constant(self):
         """

new file sage/rings/polynomial/polynomial_gf2x.pxd

@@ +1 @@
+from sage.libs.ntl.ntl_GF2X_decl cimport GF2X_c
+
+ctypedef GF2X_c celement
+
+include "polynomial_template_header.pxi"
+
+cdef class Polynomial_GF2X(Polynomial_template):
+    pass
+    

new file sage/rings/polynomial/polynomial_gf2x.pyx

@@ +1 @@
+"""
+Univariate Polynomials over GF(2) via NTL's GF2X.
+
+AUTHOR:
+    -- Martin Albrecht (2008-10) initial implementation
+"""
+
+include "../../libs/ntl/ntl_GF2X_linkage.pxi"
+
+include "polynomial_template.pxi"
+
+from sage.libs.all import pari
+
+#ctypedef unsigned long long word "word"
+
+from sage.matrix.matrix_mod2_dense cimport mzd_write_bit, mzd_read_bit, Matrix_mod2_dense, word
+
+cdef class Polynomial_GF2X(Polynomial_template):
+    """
+    Univariate Polynomials over GF(2) via NTL's GF2X.
+
+    EXAMPLE:
+        sage: P.<x> = GF(2)[]
+        sage: x^3 + x^2 + 1
+        x^3 + x^2 + 1
+    """
+    def __init__(self, parent, x=None, check=True, is_gen=False, construct=False):
+        """
+        Create a new univariate polynomials over GF(2).
+        
+        EXAMPLE:
+            sage: P.<x> = GF(2)[]
+            sage: x^3 + x^2 + 1
+            x^3 + x^2 + 1
+        """
+        try:
+            if x.parent() is parent.base_ring() or x.parent() == parent.base_ring():
+                x = int(x)
+        except AttributeError:
+            pass
+        Polynomial_template.__init__(self, parent, x, check, is_gen, construct)
+
+    def __getitem__(self, int i):
+        """
+        EXAMPLE:
+            sage: P.<x> = GF(2)[]
+            sage: f = x^3 + x^2 + 1; f
+            x^3 + x^2 + 1
+            sage: f[0]
+            1
+            sage: f[1]
+            0
+        """
+        cdef long c
+        if 0 <= i < GF2X_NumBits(self.x):
+            c = GF2_conv_to_long(GF2X_coeff(self.x, i))
+        return self._parent.base_ring()(c)
+
+    def _pari_(self, variable=None):
+        """
+        EXAMPLE:
+            sage: P.<x> = GF(2)[]
+            sage: f = x^3 + x^2 + 1
+            sage: pari(f)
+            Mod(1, 2)*x^3 + Mod(1, 2)*x^2 + Mod(1, 2)
+        """
+        #TODO: put this in a superclass
+        parent = self._parent
+        if variable is None:
+            variable = parent.variable_name()
+        return pari(self.list()).Polrev(variable) * pari(1).Mod(2)
+
+    def modular_composition(Polynomial_GF2X self, Polynomial_GF2X g, Polynomial_GF2X h, algorithm=None):
+        """
+        Compute f(g) % h.
+
+        Both implementations Use Brent-Kung's Algorithm 2.1 (Fast
+        Algorithms for Manipulation Formal Power Series, JACM 1978)
+
+        INPUT:
+            g -- a polynomial
+            h -- a polynomial
+            algorithm -- either 'native' or 'ntl' (default: 'native')
+
+        EXAMPLE:
+            sage: P.<x> = GF(2)[]
+            sage: r = 279
+            sage: f = x^r + x +1
+            sage: g = x^r
+            sage: g.modular_composition(g, f) == g(g) % f
+            True
+
+        AUTHORS:
+             -- Paul Zimmermann (2008-10) initial implementation
+             -- Martin Albrecht (2008-10) performance improvements
+        """
+        if g.parent() is not self.parent() or h.parent() is not self.parent():
+            raise TypeError("Parents of the first three parameters must match.")
+
+        from sage.misc.misc import verbose, cputime
+        from sage.calculus.calculus import ceil
+        from sage.matrix.constructor import Matrix
+        from sage.rings.all import FiniteField as GF
+
+        cdef Polynomial_GF2X res
+        cdef GF2XModulus_c modulus
+        GF2XModulus_build(modulus, (<Polynomial_GF2X>h).x)
+
+        res = <Polynomial_GF2X>PY_NEW(Polynomial_GF2X)
+        res._parent = self._parent
+
+        if algorithm == "ntl":
+            t = cputime()
+            _sig_on
+            GF2X_CompMod(res.x, self.x, g.x, modulus)
+            _sig_off
+            verbose("NTL %5.3f s"%cputime(t),level=1)
+            return res
+
+        cdef Py_ssize_t i, j, k, l, n, maxlength
+        cdef Matrix_mod2_dense F, G, H
+
+        cdef GF2X_c _f = (<Polynomial_GF2X>self).x
+        cdef GF2X_c _g = (<Polynomial_GF2X>g).x
+        cdef GF2X_c gpow, tt
+        GF2X_conv_long(gpow, 1)
+
+        maxlength = GF2X_NumBits(_f)
+
+        t = cputime()
+
+        n = h.degree()
+
+        k = ceil(Integer(n+1).sqrt_approx())
+        l = ceil((self.degree() + 1) / k)
+
+        # we store all matrices transposed for performance reasons
+        G = <Matrix_mod2_dense>Matrix(GF(2), k, n)
+
+        # first compute g^j mod h, 2 <= j < k
+        for j in range(0, k):
+            for i from 0 <= i < GF2X_NumBits(gpow):
+                mzd_write_bit(G._entries, j, i, GF2_conv_to_long(GF2X_coeff(gpow, i)))
+            #gpow = (gpow * g) % h # we'll need g^k below
+            GF2X_MulMod_pre(gpow, gpow, _g, modulus)
+        verbose("G %d x %d %5.3f s"%(G.nrows(), G.ncols(),cputime(t)),level=1)
+
+        # split f in chunks of degree < k
+        t = cputime()
+        F = <Matrix_mod2_dense>Matrix(GF(2), l, k)
+        for j in range(0, l):
+            if j*k+k <= maxlength:
+                for i from j*k <= i < j*k+k:
+                    mzd_write_bit(F._entries, j, i-j*k, GF2_conv_to_long(GF2X_coeff(_f, i)))
+            else:
+                for i from j*k <= i < maxlength:
+                    mzd_write_bit(F._entries, j, i-j*k, GF2_conv_to_long(GF2X_coeff(_f, i)))
+                
+        verbose("F %d x %d %5.3f s"%(F.nrows(), F.ncols(), cputime(t)),level=1)
+
+        t = cputime()
+        H = <Matrix_mod2_dense>(F * G)
+        verbose("H %d x %d %5.3f s"%(H.nrows(), H.ncols(), cputime(t)),level=1)
+
+        t = cputime()
+        # H is a n x l matrix now H[i,j] = sum(G[i,m]*F[m,j],
+        # m=0..k-1) = sum(g^m[i] * f[j*k+m], m=0..k-1) where g^m[i] is
+        # the coefficient of degree i in g^m and f[j*k+m] is the
+        # coefficient of degree j*k+m in f thus f[j*k+m]*g^m[i] should
+        # be multiplied by g^(j*k) gpow = (g^k) % h
+        
+        GF2X_conv_long(res.x, 0)
+        j = l - 1
+        while j >= 0:
+            #res = (res * gpow) % h
+            GF2X_MulMod_pre(res.x, res.x, gpow, modulus)
+
+            # res = res + parent([H[j,i] for i in range(0,n)])
+            GF2X_conv_long(tt, 0)
+            for i from 0<= i < n:
+                GF2X_SetCoeff_long(tt, i, mzd_read_bit(H._entries, j, i))
+            GF2X_add(res.x, res.x, tt)
+            j = j - 1
+
+        verbose("Res %5.3f s"%cputime(t),level=1)
+        return res

sage/rings/polynomial/polynomial_modn_dense_ntl.pyx

@@ -1684 +1684 @@
     #    self.parent()._ntl_set_modulus()
     #    F = [(self.parent()(f, construct=True), n) for f, n in M.ntl_ZZ_pX().factor(verbose)]
     #    return factorization.Factorization(F)
-
-    def is_primitive(self):
-        """
-        Identifies whether a polynomial is primitive.
-        A polynomial can only be primitive if it is irreducible.
-
-        EXAMPLES:
-            sage: R.<x> = GF(2)['x']
-            sage: f = x^4+x^3+x^2+x+1
-            sage: f.is_irreducible(), f.is_primitive()
-            (True, False)
-            sage: f = x^3+x+1
-            sage: f.is_irreducible(), f.is_primitive()
-            (True, True)
-            sage: R.<x> = GF(3)[]
-            sage: f = x^3-x+1
-            sage: f.is_irreducible(), f.is_primitive()
-            (True, True)
-            sage: f = x^2+1
-            sage: f.is_irreducible(), f.is_primitive()
-            (True, False)
-            sage: R.<x> = GF(5)[]
-            sage: f = x^2+x+1
-            sage: f.is_primitive()
-            False
-            sage: f = x^2-x+2
-            sage: f.is_primitive()
-            True
-        """
-        if not self.is_irreducible():
-            return False
-        p = self.parent().characteristic()
-        n = p ** self.degree() - 1
-        y = self.parent().quo(self).gen()
-        for d in n.prime_divisors():
-            if ( y ** (n//d) ) == 1:
-                return False
-        return True
-    

sage/rings/polynomial/polynomial_ring.py

@@ -1135 +1135 @@
                 raise TypeError,"Unable to coerce string"
         elif hasattr(x, '_polynomial_'):
             return x._polynomial_(self)
-        return polynomial_modn_dense_ntl.Polynomial_dense_mod_p(self, x, check, is_gen,construct=construct)
+        if self.modulus() == 2:
+            import sage.rings.polynomial.polynomial_gf2x as polynomial_gf2x
+            return polynomial_gf2x.Polynomial_GF2X(self, x, check, is_gen,construct=construct)
+        else:
+            return polynomial_modn_dense_ntl.Polynomial_dense_mod_p(self, x, check, is_gen,construct=construct)
 
 
 def polygen(ring_or_element, name="x"):

new file sage/rings/polynomial/polynomial_template.pxi

@@ +1 @@
+"""
+Polynomial Template for C/C++ Library Interfaces
+
+AUTHOR:
+    -- Robert Bradshaw (2008-10) original idea for templating
+    -- Martin Albrecht (2008-10) initial implementation
+
+This file implements a simple templating engine for linking univariate
+polynomials to their C/C++ library implementations. It requires a
+'linkage' file which implements the \code{celement_} functions (see
+\code{sage.libs.ntl.ntl_GF2X_linkage} for an example). Both parts are
+then pluygged together by inclusion of the linkage file when
+inheriting from this class. See
+\code{sage.rings.polynomial.polynomial_gf2x} for an example.
+
+We illustrate the generic glueing using univariate polynomials over
+GF(2).
+
+NOTE:
+Implementations using this template MUST implement coercion from base
+ring elements and \code{__getitem__}. See \code{Polynomial_GF2X} for an example.
+"""
+#*****************************************************************************
+#       Copyright (C) 2008 Martin Albrecht <M.R.Albrecht@rhul.ac.uk>
+#       Copyright (C) 2008 Robert Bradshaw
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  http://www.gnu.org/licenses/
+#*****************************************************************************
+
+include "../../ext/interrupt.pxi"
+include "../../ext/stdsage.pxi"
+
+from sage.rings.polynomial.polynomial_element cimport Polynomial
+from sage.structure.element cimport ModuleElement, Element, RingElement
+from sage.rings.integer cimport Integer
+from sage.libs.all import pari_gen
+
+def make_element(parent, args):
+    return parent(*args)
+
+cdef class Polynomial_template(Polynomial):
+    def __init__(self, parent, x=None, check=True, is_gen=False, construct=False):
+        """
+        EXAMPLE:
+            sage: P.<x> = GF(2)[]
+            sage: P(0)
+            0
+            sage: P(GF(2)(1))
+            1
+            sage: P(3)
+            1
+            sage: P([1,0,1])
+            x^2 + 1
+            sage: P(map(GF(2),[1,0,1]))
+            x^2 + 1
+        """
+        cdef celement gen, monomial, coeff
+        cdef Py_ssize_t deg
+
+        Polynomial.__init__(self, parent, is_gen=is_gen)
+
+        if is_gen:
+            celement_gen(&self.x, 0, parent)
+
+        elif PY_TYPE_CHECK(x, Polynomial_template):
+            try:
+                celement_set(&self.x, &(<Polynomial_template>x).x, parent)
+            except NotImplementedError:
+                raise TypeError("%s not understood."%x)
+
+        elif PY_TYPE_CHECK(x, int) or PY_TYPE_CHECK(x, Integer):
+            try:
+                celement_set_si(&self.x, int(x), parent)
+            except NotImplementedError:
+                raise TypeError("%s not understood."%x)
+
+        elif PY_TYPE_CHECK(x, list) or PY_TYPE_CHECK(x, tuple):
+            parent = (<Polynomial_template>self)._parent
+
+            celement_set_si(&self.x, 0, parent)
+            celement_gen(&gen, 0, parent)
+
+            deg = 0
+            for e in x:
+                # r += parent(e)*power
+                celement_pow(&monomial, &gen, deg, NULL, parent)
+                coeff = (<Polynomial_template>parent(e)).x
+                celement_mul(&monomial, &coeff, &monomial, parent)
+                celement_add(&self.x, &self.x, &monomial, parent)
+                deg += 1
+
+        elif PY_TYPE_CHECK(x, pari_gen):
+            k = (<Polynomial_template>self)._parent.base_ring()
+            x = [k(w) for w in x.Vecrev()]
+            Polynomial_template.__init__(self, parent, x, check=True, is_gen=False, construct=construct)
+        elif PY_TYPE_CHECK(x, Polynomial):
+            k = (<Polynomial_template>self)._parent.base_ring()
+            x = [k(w) for w in list(x)]
+            Polynomial_template.__init__(self, parent, x, check=True, is_gen=False, construct=construct)
+        else:
+            raise TypeError("Coercion from parent %s not supported."%x.parent())
+
+    def __reduce__(self):
+        """
+        EXAMPLE:
+            sage: P.<x> = GF(2)[]
+            sage: loads(dumps(x)) == x
+            True
+        """
+        return make_element, ((<Polynomial_template>self)._parent, (self.list(), False, self.is_gen()))
+
+    def list(self):
+        """
+        EXAMPLE:
+            sage: P.<x> = GF(2)[]
+            sage: x.list()
+            [0, 1]
+            sage: list(x)
+            [0, 1]
+        """
+        cdef Py_ssize_t i
+        return [self[i] for i in range(celement_len(&self.x,(<Polynomial_template>self)._parent))]
+
+    def __cinit__(self):
+        """
+        EXAMPLE:
+            sage: P.<x> = GF(2)[]
+        """
+        celement_construct(&self.x, (<Polynomial_template>self)._parent)
+
+    def __dealloc__(self):
+        """
+        EXAMPLE:
+            sage: P.<x> = GF(2)[]
+            sage: del x
+        """
+        celement_destruct(&self.x, (<Polynomial_template>self)._parent)
+
+    cpdef ModuleElement _add_(self, ModuleElement right):
+        """
+        EXAMPLE:
+            sage: P.<x> = GF(2)[]
+            sage: x + 1
+            x + 1
+        """
+        cdef Polynomial_template r = <Polynomial_template>PY_NEW(self.__class__)
+        r._parent = (<Polynomial_template>self)._parent
+        celement_add(&r.x, &(<Polynomial_template>self).x, &(<Polynomial_template>right).x, (<Polynomial_template>self)._parent)
+        return r
+
+    cpdef ModuleElement _sub_(self, ModuleElement right):
+        """
+        EXAMPLE:
+            sage: P.<x> = GF(2)[]
+            sage: x - 1
+            x + 1
+        """
+        cdef Polynomial_template r = <Polynomial_template>PY_NEW(self.__class__)
+        r._parent = (<Polynomial_template>self)._parent
+        celement_add(&r.x, &(<Polynomial_template>self).x, &(<Polynomial_template>right).x, (<Polynomial_template>self)._parent)
+        return r
+
+    def __neg__(self):
+        """
+        EXAMPLE:
+            sage: P.<x> = GF(2)[]
+            sage: -x
+            x
+        """
+        cdef Polynomial_template r = <Polynomial_template>PY_NEW(self.__class__)
+        r._parent = (<Polynomial_template>self)._parent
+        celement_neg(&r.x, &self.x, (<Polynomial_template>self)._parent)
+        return r
+
+    cpdef RingElement _mul_(self, RingElement right):
+        """
+        EXAMPLE:
+            sage: P.<x> = GF(2)[]
+            sage: x*(x+1)
+            x^2 + x
+        """
+        cdef Polynomial_template r = <Polynomial_template>PY_NEW(self.__class__)
+        r._parent = (<Polynomial_template>self)._parent
+        celement_mul(&r.x, &(<Polynomial_template>self).x, &(<Polynomial_template>right).x, (<Polynomial_template>self)._parent)
+        return r
+
+    def gcd(self, Polynomial_template other):
+        """
+        EXAMPLE:
+            sage: P.<x> = GF(2)[]
+            sage: f = x*(x+1)
+            sage: f.gcd(x+1)
+            x + 1
+            sage: f.gcd(x^2)
+            x
+        """
+        cdef Polynomial_template r = <Polynomial_template>PY_NEW(self.__class__)
+        r._parent = (<Polynomial_template>self)._parent
+        celement_gcd(&r.x, &(<Polynomial_template>self).x, &(<Polynomial_template>other).x, (<Polynomial_template>self)._parent)
+        return r
+
+    def __floordiv__(self, right):
+        """
+        EXAMPLE:
+            sage: P.<x> = GF(2)[]
+            sage: x//(x + 1)
+            1
+            sage: (x + 1)//x
+            1
+        """
+        right = (<Polynomial_template>self)._parent._coerce_(right)
+        cdef Polynomial_template r = <Polynomial_template>PY_NEW(self.__class__)
+        r._parent = (<Polynomial_template>self)._parent
+        celement_floordiv(&r.x, &(<Polynomial_template>self).x, &(<Polynomial_template>right).x, (<Polynomial_template>self)._parent)
+        return r
+
+    def __mod__(self, other):
+        """
+        EXAMPLE:
+            sage: P.<x> = GF(2)[]
+            sage: (x^2 + 1) % x^2
+            1
+        """
+        other = (<Polynomial_template>self)._parent._coerce_(other)
+        cdef Polynomial_template r = <Polynomial_template>PY_NEW(self.__class__)
+        r._parent = (<Polynomial_template>self)._parent
+        celement_mod(&r.x, &(<Polynomial_template>self).x, &(<Polynomial_template>other).x, (<Polynomial_template>self)._parent)
+        return r
+
+    def quo_rem(self, right):
+        """
+        EXAMPLE:
+            sage: P.<x> = GF(2)[]
+            sage: f = x^2 + x + 1
+            sage: f.quo_rem(x + 1)
+            (x, 1)
+        """
+        right = (<Polynomial_template>self)._parent._coerce_(right)
+        cdef Polynomial_template q = <Polynomial_template>PY_NEW(self.__class__)
+        q._parent = (<Polynomial_template>self)._parent
+        cdef Polynomial_template r = <Polynomial_template>PY_NEW(self.__class__)
+        r._parent = (<Polynomial_template>self)._parent
+        celement_quorem(&q.x, &r.x, &(<Polynomial_template>self).x, &(<Polynomial_template>right).x, (<Polynomial_template>self)._parent)
+        return q,r
+        
+    def __long__(self):
+        """
+        EXAMPLE:
+            sage: P.<x> = GF(2)[]
+            sage: int(x)
+            Traceback (most recent call last):
+            ...
+            TypeError: cannot coerce nonconstant polynomial to int
+
+            sage: int(P(1))
+            1
+        """
+        if celement_len(&self.x, (<Polynomial_template>self)._parent) > 1:
+            raise ValueError("Cannot coerce polynomial with degree %d to integer."%(self.degree()))
+        return int(self[0])
+
+    def __nonzero__(self):
+        """
+        EXAMPLE:
+            sage: P.<x> = GF(2)[]
+            sage: bool(x), x.is_zero()
+            (True, False)
+            sage: bool(P(0)), P(0).is_zero()
+            (False, True)
+        """
+        return not celement_is_zero(&self.x, (<Polynomial_template>self)._parent)
+
+    def __richcmp__(left, right, int op):
+        """
+        EXAMPLE:
+            sage: P.<x> = GF(2)[]
+            sage: x != 1
+            True
+            sage: x < 1
+            False
+            sage: x > 1
+            True
+        """
+        return (<Element>left)._richcmp(right, op)
+    
+    cdef int _cmp_c_impl(left, Element right) except -2:
+        """
+        EXAMPLE:
+            sage: P.<x> = GF(2)[]
+        """
+        return celement_cmp(&(<Polynomial_template>left).x, &(<Polynomial_template>right).x, (<Polynomial_template>left)._parent)
+
+    def __hash__(self):
+        """
+        EXAMPLE:
+            sage: P.<x> = GF(2)[]
+            sage: {x:1}
+            {x: 1}
+        """
+        return celement_hash(&self.x, (<Polynomial_template>self)._parent)
+
+    def __len__(self):
+        """
+        EXAMPLE:
+            sage: P.<x> = GF(2)[]
+            sage: P.<x> = GF(2)[]
+            sage: len(x)
+            2
+            sage: len(x+1)
+            2
+        """
+        return celement_len(&self.x, (<Polynomial_template>self)._parent)
+
+    def __pow__(self, ee, modulus):
+        """
+        EXAMPLE:
+            sage: P.<x> = GF(2)[]
+            sage: P.<x> = GF(2)[]
+            sage: x^1000
+            x^1000
+            sage: (x+1)^2
+            x^2 + 1
+            sage: (x+1)^(-2)
+            1/(x^2 + 1)
+            sage: f = x^9 + x^7 + x^6 + x^5 + x^4 + x^2 + x
+            sage: h = x^10 + x^7 + x^6 + x^5 + x^4 + x^3 + x^2 + 1
+            sage: (f^2) % h
+            x^9 + x^8 + x^7 + x^5 + x^3
+            sage: pow(f, 2, h)
+            x^9 + x^8 + x^7 + x^5 + x^3
+        """
+        if not PY_TYPE_CHECK(self, Polynomial_template):
+            raise NotImplementedError("%s^%s not defined."%(ee,self))
+        cdef bint recip = 0, do_sig
+        cdef long e = ee
+        if e != ee:
+            raise TypeError("Only integral powers defined.")
+        elif e < 0:
+            recip = 1 # delay because powering frac field elements is slow
+            e = -e
+        if not self:
+            if e == 0:
+                raise ArithmeticError, "0^0 is undefined."
+        cdef Polynomial_template r = <Polynomial_template>PY_NEW(self.__class__)
+        r._parent = (<Polynomial_template>self)._parent
+
+        if modulus is None:
+            celement_pow(&r.x, &(<Polynomial_template>self).x, e, NULL, (<Polynomial_template>self)._parent)
+        else:
+            modulus = (<Polynomial_template>self)._parent._coerce_(modulus)
+            celement_pow(&r.x, &(<Polynomial_template>self).x, e, &(<Polynomial_template>modulus).x, (<Polynomial_template>self)._parent)
+        if recip:
+            return ~r
+        else:
+            return r
+        
+    def is_gen(self):
+        """
+        EXAMPLE:
+            sage: P.<x> = GF(2)[]
+            sage: x.is_gen()
+            True
+            sage: (x+1).is_gen()
+            False
+        """
+        cdef celement gen
+        celement_gen(&gen, 0, (<Polynomial_template>self)._parent)
+        return celement_equal(&self.x, &gen, (<Polynomial_template>self)._parent)
+
+    def shift(self, int n):
+        """
+        EXAMPLE:
+            sage: P.<x> = GF(2)[]
+            sage: f = x^3 + x^2 + 1
+            sage: f.shift(1)
+            x^4 + x^3 + x
+            sage: f.shift(-1)
+            x^2 + x
+        """
+        cdef celement gen
+        cdef Polynomial_template r
+        if n == 0:
+            return self
+
+        parent = (<Polynomial_template>self)._parent
+        celement_gen(&gen, 0, parent)
+        celement_pow(&gen, &gen, abs(n), NULL, parent)
+        r = <Polynomial_template>PY_NEW(self.__class__)
+        r._parent = parent
+        
+        if n > 0:
+            celement_mul(&r.x, &self.x, &gen, parent)
+        else:
+            celement_floordiv(&r.x, &self.x, &gen, parent)
+        return r
+
+    def __lshift__(self, int n):
+        """
+        EXAMPLE:
+            sage: P.<x> = GF(2)[]
+            sage: f = x^3 + x^2 + 1
+            sage: f << 1
+            x^4 + x^3 + x
+        """
+        if not PY_TYPE_CHECK(self, Polynomial_template):
+            raise TypeError("Cannot %s << %n."%(self, n))
+        cdef celement gen
+        cdef Polynomial_template r
+        if n == 0:
+            return self
+        elif n < 0:
+            return self >> -n
+
+        parent = (<Polynomial_template>self)._parent
+        celement_gen(&gen, 0, parent)
+        celement_pow(&gen, &gen, n, NULL, parent)
+        r = <Polynomial_template>PY_NEW(self.__class__)
+        r._parent = parent
+        celement_mul(&r.x, &(<Polynomial_template>self).x, &gen, parent)
+        return r
+
+    def __rshift__(self, int n):
+        """
+        EXAMPLE:
+            sage: P.<x> = GF(2)[]
+        """
+        if not PY_TYPE_CHECK(self, Polynomial_template):
+            raise TypeError("Cannot %s >> %n."%(self, n))
+        cdef celement gen
+        cdef Polynomial_template r
+        if n == 0:
+            return self
+        elif n < 0:
+            return self >> -n
+
+        parent = (<Polynomial_template>self)._parent
+        celement_gen(&gen, 0, parent)
+        celement_pow(&gen, &gen, n, NULL, parent)
+        r = <Polynomial_template>PY_NEW(self.__class__)
+        r._parent = parent
+        
+        celement_floordiv(&r.x, &(<Polynomial_template>self).x, &gen, parent)
+        return r
+
+    def is_zero(self):
+        """
+        EXAMPLE:
+            sage: P.<x> = GF(2)[]
+        """
+        return celement_is_zero(&self.x, (<Polynomial_template>self)._parent)
+
+    def is_one(self):
+        """
+        EXAMPLE:
+            sage: P.<x> = GF(2)[]
+        """
+        return celement_is_one(&self.x, (<Polynomial_template>self)._parent)
+
+    def degree(self):
+        """
+        EXAMPLE:
+            sage: P.<x> = GF(2)[]
+        """
+        return Integer(celement_len(&self.x, (<Polynomial_template>self)._parent)-1)
+
+    def truncate(self, n):
+        """
+        Returns this polynomial mod $x^n$.
+        
+        EXAMPLES: 
+            sage: R.<x> =GF(2)[]
+            sage: f = sum(x^n for n in range(10)); f
+            x^9 + x^8 + x^7 + x^6 + x^5 + x^4 + x^3 + x^2 + x + 1
+            sage: f.truncate(6)
+            x^5 + x^4 + x^3 + x^2 + x + 1
+        """
+        if n < 0:
+            raise ValueError(" n must be >= 0.")
+        parent = (<Polynomial_template>self)._parent
+        cdef celement gen
+        celement_gen(&gen, 0, parent)
+        celement_pow(&gen, &gen, n, NULL, parent)
+
+        cdef Polynomial_template r = <Polynomial_template>PY_NEW(self.__class__)
+        r._parent = parent
+        celement_mod(&r.x, &self.x, &gen, parent)
+        return r

new file sage/rings/polynomial/polynomial_template_header.pxi

@@ +1 @@
+"""
+Polynomial Template for C/C++ Library Interfaces
+"""
+
+from sage.rings.polynomial.polynomial_element cimport Polynomial
+
+cdef class Polynomial_template(Polynomial):
+    cdef celement x
+

setup.py

@@ -917 +917 @@
                  language = 'c++',
                  include_dirs=debian_include_dirs + ['sage/libs/ntl/']), \
 
+    Extension('sage.rings.polynomial.polynomial_gf2x',
+                 sources = ['sage/rings/polynomial/polynomial_gf2x.pyx'],
+                 libraries = ['ntl', 'stdc++', 'gmp'],
+                 language = 'c++',
+                 include_dirs=debian_include_dirs + ['sage/libs/ntl/']), \
+
     Extension('sage.rings.polynomial.polynomial_real_mpfr_dense',
                  sources = ['sage/rings/polynomial/polynomial_real_mpfr_dense.pyx'],
                  libraries = ['mpfr', 'gmp']), \