def _finite_field_ext_pari_(self):
"""
Return a FiniteField_ext_pari isomorphic to self with the same
defining polynomial.
This method will vanish eventually because that implementation of
finite fields will be deprecated.
EXAMPLES::
sage: k.<a> = GF(2^20)
sage: kP = k._finite_field_ext_pari_()
sage: kP
Finite Field in a of size 2^20
sage: type(kP)
<class 'sage.rings.finite_rings.finite_field_ext_pari.FiniteField_ext_pari_with_category'>
"""
f = self.polynomial()
return FiniteField_ext_pari(self.order(), self.variable_name(), f)
def create_object(self,
version,
key,
check_irreducible=True,
elem_cache=None,
names=None,
**kwds):
"""
EXAMPLES::
sage: K = GF(19)
sage: TestSuite(K).run()
"""
# IMPORTANT! If you add a new class to the list of classes
# that get cached by this factor object, then you *must* add
# the following method to that class in order to fully support
# pickling:
#
# def __reduce__(self): # and include good doctests, please!
# return self._factory_data[0].reduce_data(self)
#
# This is not in the base class for finite fields, since some finite
# fields need not be created using this factory object, e.g., residue
# class fields.
if len(key) == 5:
# for backward compatibility of pickles (see trac 10975).
order, name, modulus, impl, _ = key
p, n = arith.factor(order)[0]
proof = True
else:
order, name, modulus, impl, _, p, n, proof = key
if isinstance(modulus, str) and modulus.startswith("random"):
modulus = "random"
if elem_cache is None:
elem_cache = order < 500
if n == 1 and (impl is None or impl == 'modn'):
from finite_field_prime_modn import FiniteField_prime_modn
# Using a check option here is probably a worthwhile
# compromise since this constructor is simple and used a
# huge amount.
K = FiniteField_prime_modn(order, check=False, **kwds)
else:
# We have to do this with block so that the finite field
# constructors below will use the proof flag that was
# passed in when checking for primality, factoring, etc.
# Otherwise, we would have to complicate all of their
# constructors with check options (like above).
from sage.structure.proof.all import WithProof
with WithProof('arithmetic', proof):
if check_irreducible and polynomial_element.is_Polynomial(
modulus):
if modulus.parent().base_ring().characteristic() == 0:
modulus = modulus.change_ring(FiniteField(p))
if not modulus.is_irreducible():
raise ValueError(
"finite field modulus must be irreducible but it is not."
)
if modulus.degree() != n:
raise ValueError(
"The degree of the modulus does not correspond to the cardinality of the field."
)
if name is None:
raise TypeError("you must specify the generator name.")
if order < zech_log_bound:
# DO *NOT* use for prime subfield, since that would lead to
# a circular reference in the call to ParentWithGens in the
# __init__ method.
K = FiniteField_givaro(order,
name,
modulus,
cache=elem_cache,
**kwds)
else:
if order % 2 == 0 and (impl is None or impl == 'ntl'):
from element_ntl_gf2e import FiniteField_ntl_gf2e
K = FiniteField_ntl_gf2e(order, name, modulus, **kwds)
else:
from finite_field_ext_pari import FiniteField_ext_pari
K = FiniteField_ext_pari(order, name, modulus, **kwds)
return K
def create_object(self, version, key, **kwds):
"""
EXAMPLES::
sage: K = GF(19) # indirect doctest
sage: TestSuite(K).run()
We try to create finite fields with various implementations::
sage: k = GF(2, impl='modn')
sage: k = GF(2, impl='givaro')
sage: k = GF(2, impl='ntl')
sage: k = GF(2, impl='pari_ffelt')
Traceback (most recent call last):
...
ValueError: the degree must be at least 2
sage: k = GF(2, impl='pari_mod')
Traceback (most recent call last):
...
ValueError: The size of the finite field must not be prime.
sage: k = GF(2, impl='supercalifragilisticexpialidocious')
Traceback (most recent call last):
...
ValueError: no such finite field implementation: 'supercalifragilisticexpialidocious'
sage: k.<a> = GF(2^15, impl='modn')
Traceback (most recent call last):
...
ValueError: the 'modn' implementation requires a prime order
sage: k.<a> = GF(2^15, impl='givaro')
sage: k.<a> = GF(2^15, impl='ntl')
sage: k.<a> = GF(2^15, impl='pari_ffelt')
sage: k.<a> = GF(2^15, impl='pari_mod')
sage: k.<a> = GF(3^60, impl='modn')
Traceback (most recent call last):
...
ValueError: the 'modn' implementation requires a prime order
sage: k.<a> = GF(3^60, impl='givaro')
Traceback (most recent call last):
...
ValueError: q must be < 2^16
sage: k.<a> = GF(3^60, impl='ntl')
Traceback (most recent call last):
...
ValueError: q must be a 2-power
sage: k.<a> = GF(3^60, impl='pari_ffelt')
sage: k.<a> = GF(3^60, impl='pari_mod')
"""
# IMPORTANT! If you add a new class to the list of classes
# that get cached by this factor object, then you *must* add
# the following method to that class in order to fully support
# pickling:
#
# def __reduce__(self): # and include good doctests, please!
# return self._factory_data[0].reduce_data(self)
#
# This is not in the base class for finite fields, since some finite
# fields need not be created using this factory object, e.g., residue
# class fields.
if len(key) == 5:
# for backward compatibility of pickles (see trac 10975).
order, name, modulus, impl, _ = key
p, n = Integer(order).factor()[0]
proof = True
else:
order, name, modulus, impl, _, p, n, proof = key
if impl == 'modn':
if n != 1:
raise ValueError(
"the 'modn' implementation requires a prime order")
from finite_field_prime_modn import FiniteField_prime_modn
# Using a check option here is probably a worthwhile
# compromise since this constructor is simple and used a
# huge amount.
K = FiniteField_prime_modn(order, check=False, modulus=modulus)
else:
# We have to do this with block so that the finite field
# constructors below will use the proof flag that was
# passed in when checking for primality, factoring, etc.
# Otherwise, we would have to complicate all of their
# constructors with check options.
from sage.structure.proof.all import WithProof
with WithProof('arithmetic', proof):
if impl == 'givaro':
repr = kwds.get('repr', 'poly')
elem_cache = kwds.get('elem_cache', order < 500)
K = FiniteField_givaro(order,
name,
modulus,
repr=repr,
cache=elem_cache)
elif impl == 'ntl':
from finite_field_ntl_gf2e import FiniteField_ntl_gf2e
K = FiniteField_ntl_gf2e(order, name, modulus)
elif impl == 'pari_ffelt':
from finite_field_pari_ffelt import FiniteField_pari_ffelt
K = FiniteField_pari_ffelt(p, modulus, name)
elif (impl == 'pari_mod'
or impl == 'pari'): # for unpickling old pickles
# This implementation is deprecated, a warning will
# be given when this field is created.
# See http://trac.sagemath.org/ticket/17297
from finite_field_ext_pari import FiniteField_ext_pari
K = FiniteField_ext_pari(order, name, modulus)
else:
raise ValueError(
"no such finite field implementation: %r" % impl)
# Temporary; see create_key_and_extra_args() above.
if 'prefix' in kwds:
K._prefix = kwds['prefix']
return K