def __init__(self, q, name="a", modulus=None, repr="poly", cache=False):
"""
Initialize ``self``.
EXAMPLES::
sage: k.<a> = GF(2^3)
sage: j.<b> = GF(3^4)
sage: k == j
False
sage: GF(2^3,'a') == copy(GF(2^3,'a'))
True
sage: TestSuite(GF(2^3, 'a')).run()
"""
self._kwargs = {}
if repr not in ["int", "log", "poly"]:
raise ValueError, "Unknown representation %s" % repr
q = Integer(q)
if q < 2:
raise ValueError, "q must be a prime power"
F = q.factor()
if len(F) > 1:
raise ValueError, "q must be a prime power"
p = F[0][0]
k = F[0][1]
if q >= 1 << 16:
raise ValueError, "q must be < 2^16"
import constructor
FiniteField.__init__(self, constructor.FiniteField(p), name, normalize=False)
self._kwargs["repr"] = repr
self._kwargs["cache"] = cache
self._is_conway = False
if modulus is None or modulus == "conway":
if k == 1:
modulus = "random" # this will use the gfq_factory_pk function.
elif ConwayPolynomials().has_polynomial(p, k):
from sage.rings.finite_rings.constructor import conway_polynomial
modulus = conway_polynomial(p, k)
self._is_conway = True
elif modulus is None:
modulus = "random"
else:
raise ValueError, "Conway polynomial not found"
from sage.rings.polynomial.all import is_Polynomial
if is_Polynomial(modulus):
modulus = modulus.list()
self._cache = Cache_givaro(self, p, k, modulus, repr, cache)
def __init__(self, q, name="a", modulus=None, repr="poly", cache=False):
"""
Initialize ``self``.
EXAMPLES::
sage: k.<a> = GF(2^3)
sage: j.<b> = GF(3^4)
sage: k == j
False
sage: GF(2^3,'a') == copy(GF(2^3,'a'))
True
sage: TestSuite(GF(2^3, 'a')).run()
"""
self._kwargs = {}
if repr not in ['int', 'log', 'poly']:
raise ValueError, "Unknown representation %s" % repr
q = Integer(q)
if q < 2:
raise ValueError, "q must be a prime power"
F = q.factor()
if len(F) > 1:
raise ValueError, "q must be a prime power"
p = F[0][0]
k = F[0][1]
if q >= 1 << 16:
raise ValueError, "q must be < 2^16"
import constructor
FiniteField.__init__(self,
constructor.FiniteField(p),
name,
normalize=False)
self._kwargs['repr'] = repr
self._kwargs['cache'] = cache
self._is_conway = False
if modulus is None or modulus == 'conway':
if k == 1:
modulus = 'random' # this will use the gfq_factory_pk function.
elif ConwayPolynomials().has_polynomial(p, k):
from sage.rings.finite_rings.constructor import conway_polynomial
modulus = conway_polynomial(p, k)
self._is_conway = True
elif modulus is None:
modulus = 'random'
else:
raise ValueError, "Conway polynomial not found"
from sage.rings.polynomial.all import is_Polynomial
if is_Polynomial(modulus):
modulus = modulus.list()
self._cache = Cache_givaro(self, p, k, modulus, repr, cache)
def __init__(self,
polynomial,
names,
element_class=FunctionFieldElement_polymod,
category=CAT):
"""
Create a function field defined as an extension of another
function field by adjoining a root of a univariate polynomial.
INPUT:
- ``polynomial`` -- a univariate polynomial over a function field
- ``names`` -- variable names (as a tuple of length 1 or string)
- ``category`` -- a category (defaults to category of function fields)
EXAMPLES::
We create an extension of a function field::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]
sage: L = K.extension(y^5 - x^3 - 3*x + x*y); L
Function field in y defined by y^5 + x*y - x^3 - 3*x
Note the type::
sage: type(L)
<class 'sage.rings.function_field.function_field.FunctionField_polymod_with_category'>
We can set the variable name, which doesn't have to be y::
sage: L.<w> = K.extension(y^5 - x^3 - 3*x + x*y); L
Function field in w defined by y^5 + x*y - x^3 - 3*x
"""
from sage.rings.polynomial.all import is_Polynomial
if polynomial.parent().ngens() > 1 or not is_Polynomial(polynomial):
raise TypeError("polynomial must be univariate a polynomial")
if names is None:
names = (polynomial.variable_name(), )
if polynomial.degree() <= 0:
raise ValueError("polynomial must have positive degree")
base_field = polynomial.base_ring()
if not isinstance(base_field, FunctionField):
raise TypeError("polynomial must be over a FunctionField")
self._element_class = element_class
self._element_init_pass_parent = False
self._base_field = base_field
self._polynomial = polynomial
Field.__init__(self, base_field, names=names, category=category)
self._hash = hash(polynomial)
self._ring = self._polynomial.parent()
self._populate_coercion_lists_(coerce_list=[base_field, self._ring])
self._gen = self(self._ring.gen())
def __init__(self, polynomial, names,
element_class = FunctionFieldElement_polymod,
category=CAT):
"""
Create a function field defined as an extension of another
function field by adjoining a root of a univariate polynomial.
INPUT:
- ``polynomial`` -- a univariate polynomial over a function field
- ``names`` -- variable names (as a tuple of length 1 or string)
- ``category`` -- a category (defaults to category of function fields)
EXAMPLES::
We create an extension of a function field::
sage: K.<x> = FunctionField(QQ); R.<y> = K[]
sage: L = K.extension(y^5 - x^3 - 3*x + x*y); L
Function field in y defined by y^5 + x*y - x^3 - 3*x
Note the type::
sage: type(L)
<class 'sage.rings.function_field.function_field.FunctionField_polymod_with_category'>
We can set the variable name, which doesn't have to be y::
sage: L.<w> = K.extension(y^5 - x^3 - 3*x + x*y); L
Function field in w defined by y^5 + x*y - x^3 - 3*x
"""
from sage.rings.polynomial.all import is_Polynomial
if polynomial.parent().ngens()>1 or not is_Polynomial(polynomial):
raise TypeError, "polynomial must be univariate a polynomial"
if names is None:
names = (polynomial.variable_name(), )
if polynomial.degree() <= 0:
raise ValueError, "polynomial must have positive degree"
base_field = polynomial.base_ring()
if not isinstance(base_field, FunctionField):
raise TypeError, "polynomial must be over a FunctionField"
self._element_class = element_class
self._element_init_pass_parent = False
self._base_field = base_field
self._polynomial = polynomial
Field.__init__(self, base_field,
names=names, category = category)
self._hash = hash(polynomial)
self._ring = self._polynomial.parent()
self._populate_coercion_lists_(coerce_list=[base_field, self._ring])
self._gen = self(self._ring.gen())
def __init__(self, q, name="a", modulus=None, repr="poly", cache=False):
"""
Finite Field. These are implemented using Zech logs and the
cardinality must be < 2^16. By default conway polynomials are
used as minimal polynomial.
INPUT:
q -- p^n (must be prime power)
name -- variable used for poly_repr (default: 'a')
modulus -- you may provide a minimal polynomial to use for
reduction or 'random' to force a random
irreducible polynomial. (default: None, a conway
polynomial is used if found. Otherwise a random
polynomial is used)
repr -- controls the way elements are printed to the user:
(default: 'poly')
'log': repr is element.log_repr()
'int': repr is element.int_repr()
'poly': repr is element.poly_repr()
cache -- if True a cache of all elements of this field is
created. Thus, arithmetic does not create new
elements which speeds calculations up. Also, if
many elements are needed during a calculation
this cache reduces the memory requirement as at
most self.order() elements are created. (default: False)
OUTPUT:
Givaro finite field with characteristic p and cardinality p^n.
EXAMPLES:
By default conway polynomials are used:
sage: k.<a> = GF(2**8)
sage: -a ^ k.degree()
a^4 + a^3 + a^2 + 1
sage: f = k.modulus(); f
x^8 + x^4 + x^3 + x^2 + 1
You may enforce a modulus:
sage: P.<x> = PolynomialRing(GF(2))
sage: f = x^8 + x^4 + x^3 + x + 1 # Rijndael Polynomial
sage: k.<a> = GF(2^8, modulus=f)
sage: k.modulus()
x^8 + x^4 + x^3 + x + 1
sage: a^(2^8)
a
You may enforce a random modulus:
sage: k = GF(3**5, 'a', modulus='random')
sage: k.modulus() # random polynomial
x^5 + 2*x^4 + 2*x^3 + x^2 + 2
Three different representations are possible:
sage: sage.rings.finite_rings.finite_field_givaro.FiniteField_givaro(9,repr='poly').gen()
a
sage: sage.rings.finite_rings.finite_field_givaro.FiniteField_givaro(9,repr='int').gen()
3
sage: sage.rings.finite_rings.finite_field_givaro.FiniteField_givaro(9,repr='log').gen()
5
sage: k.<a> = GF(2^3)
sage: j.<b> = GF(3^4)
sage: k == j
False
sage: GF(2^3,'a') == copy(GF(2^3,'a'))
True
sage: TestSuite(j).run()
"""
self._kwargs = {}
if repr not in ['int', 'log', 'poly']:
raise ValueError, "Unknown representation %s"%repr
q = Integer(q)
if q < 2:
raise ValueError, "q must be a prime power"
F = q.factor()
if len(F) > 1:
raise ValueError, "q must be a prime power"
p = F[0][0]
k = F[0][1]
if q >= 1<<16:
raise ValueError, "q must be < 2^16"
import constructor
FiniteField.__init__(self, constructor.FiniteField(p), name, normalize=False)
self._kwargs['repr'] = repr
self._kwargs['cache'] = cache
self._is_conway = False
if modulus is None or modulus == 'conway':
if k == 1:
modulus = 'random' # this will use the gfq_factory_pk function.
elif ConwayPolynomials().has_polynomial(p, k):
from sage.rings.finite_rings.constructor import conway_polynomial
modulus = conway_polynomial(p, k)
self._is_conway = True
elif modulus is None:
modulus = 'random'
else:
raise ValueError, "Conway polynomial not found"
from sage.rings.polynomial.all import is_Polynomial
if is_Polynomial(modulus):
modulus = modulus.list()
self._cache = Cache_givaro(self, p, k, modulus, repr, cache)
def __init__(self, q, name="a", modulus=None, repr="poly", cache=False):
"""
Finite Field. These are implemented using Zech logs and the
cardinality must be < 2^16. By default conway polynomials are
used as minimal polynomial.
INPUT:
q -- p^n (must be prime power)
name -- variable used for poly_repr (default: 'a')
modulus -- you may provide a minimal polynomial to use for
reduction or 'random' to force a random
irreducible polynomial. (default: None, a conway
polynomial is used if found. Otherwise a random
polynomial is used)
repr -- controls the way elements are printed to the user:
(default: 'poly')
'log': repr is element.log_repr()
'int': repr is element.int_repr()
'poly': repr is element.poly_repr()
cache -- if True a cache of all elements of this field is
created. Thus, arithmetic does not create new
elements which speeds calculations up. Also, if
many elements are needed during a calculation
this cache reduces the memory requirement as at
most self.order() elements are created. (default: False)
OUTPUT:
Givaro finite field with characteristic p and cardinality p^n.
EXAMPLES:
By default conway polynomials are used:
sage: k.<a> = GF(2**8)
sage: -a ^ k.degree()
a^4 + a^3 + a^2 + 1
sage: f = k.modulus(); f
x^8 + x^4 + x^3 + x^2 + 1
You may enforce a modulus:
sage: P.<x> = PolynomialRing(GF(2))
sage: f = x^8 + x^4 + x^3 + x + 1 # Rijndael Polynomial
sage: k.<a> = GF(2^8, modulus=f)
sage: k.modulus()
x^8 + x^4 + x^3 + x + 1
sage: a^(2^8)
a
You may enforce a random modulus:
sage: k = GF(3**5, 'a', modulus='random')
sage: k.modulus() # random polynomial
x^5 + 2*x^4 + 2*x^3 + x^2 + 2
Three different representations are possible:
sage: sage.rings.finite_rings.finite_field_givaro.FiniteField_givaro(9,repr='poly').gen()
a
sage: sage.rings.finite_rings.finite_field_givaro.FiniteField_givaro(9,repr='int').gen()
3
sage: sage.rings.finite_rings.finite_field_givaro.FiniteField_givaro(9,repr='log').gen()
5
sage: k.<a> = GF(2^3)
sage: j.<b> = GF(3^4)
sage: k == j
False
sage: GF(2^3,'a') == copy(GF(2^3,'a'))
True
sage: TestSuite(j).run()
"""
self._kwargs = {}
if repr not in ['int', 'log', 'poly']:
raise ValueError, "Unknown representation %s" % repr
q = Integer(q)
if q < 2:
raise ValueError, "q must be a prime power"
F = q.factor()
if len(F) > 1:
raise ValueError, "q must be a prime power"
p = F[0][0]
k = F[0][1]
if q >= 1 << 16:
raise ValueError, "q must be < 2^16"
import constructor
FiniteField.__init__(self,
constructor.FiniteField(p),
name,
normalize=False)
self._kwargs['repr'] = repr
self._kwargs['cache'] = cache
self._is_conway = False
if modulus is None or modulus == 'conway':
if k == 1:
modulus = 'random' # this will use the gfq_factory_pk function.
elif ConwayPolynomials().has_polynomial(p, k):
from sage.rings.finite_rings.constructor import conway_polynomial
modulus = conway_polynomial(p, k)
self._is_conway = True
elif modulus is None:
modulus = 'random'
else:
raise ValueError, "Conway polynomial not found"
from sage.rings.polynomial.all import is_Polynomial
if is_Polynomial(modulus):
modulus = modulus.list()
self._cache = Cache_givaro(self, p, k, modulus, repr, cache)