def __init__(self):
r"""
TESTS::
sage: TestSuite(CFF(1/3)).run()
sage: TestSuite(CFF([1,2,3])).run()
"""
Field.__init__(self, self)
def __init__(self):
r"""
TESTS::
sage: TestSuite(CFF(1/3)).run()
sage: TestSuite(CFF([1,2,3])).run()
"""
Field.__init__(self, self)
def __init__(self, names=None):
r"""
TESTS::
sage: UCF = UniversalCyclotomicField()
sage: TestSuite(UCF).run()
"""
from sage.categories.fields import Fields
Field.__init__(self, base_ring=QQ, category=Fields().Infinite())
self._populate_coercion_lists_(embedding=UCFtoQQbar(self))
late_import()
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, names=None):
r"""
TESTS::
sage: UCF = UniversalCyclotomicField()
sage: TestSuite(UCF).run()
"""
from sage.categories.fields import Fields
Field.__init__(self, base_ring=QQ, category=Fields().Infinite())
self._populate_coercion_lists_(embedding=UCFtoQQbar(self))
late_import()
def __init__(self, base_ring, name, category=None):
"""
TESTS::
sage: from sage.rings.algebraic_closure_finite_field import AlgebraicClosureFiniteField_generic
sage: F = AlgebraicClosureFiniteField_generic(GF(5), 'z')
sage: F
Algebraic closure of Finite Field of size 5
"""
Field.__init__(self, base_ring=base_ring, names=name,
normalize=False, category=category)
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, base_ring, name, category=None):
"""
TEST::
sage: from sage.rings.algebraic_closure_finite_field import AlgebraicClosureFiniteField_generic
sage: F = AlgebraicClosureFiniteField_generic(GF(5), 'z')
sage: F
Algebraic closure of Finite Field of size 5
"""
Field.__init__(self, base_ring=base_ring, names=name,
normalize=False, category=category)
def __init__(self,
constant_field,
names,
element_class=FunctionFieldElement_rational,
category=CAT):
"""
Create a rational function field in one variable.
INPUT:
- ``constant_field`` -- an arbitrary field
- ``names`` -- a string or tuple of length 1
- ``category`` -- default: FunctionFields()
EXAMPLES::
sage: K.<t> = FunctionField(CC); K
Rational function field in t over Complex Field with 53 bits of precision
sage: K.category()
Category of function fields
sage: FunctionField(QQ[I], 'alpha')
Rational function field in alpha over Number Field in I with defining polynomial x^2 + 1
Must be over a field::
sage: FunctionField(ZZ, 't')
Traceback (most recent call last):
...
TypeError: constant_field must be a field
"""
if names is None:
raise ValueError("variable name must be specified")
elif not isinstance(names, tuple):
names = (names, )
if not constant_field.is_field():
raise TypeError("constant_field must be a field")
self._element_class = element_class
self._element_init_pass_parent = False
Field.__init__(self, self, names=names, category=category)
R = constant_field[names[0]]
self._hash = hash((constant_field, names))
self._constant_field = constant_field
self._ring = R
self._field = R.fraction_field()
self._populate_coercion_lists_(coerce_list=[self._field])
self._gen = self(R.gen())
def __init__(self, base):
if base not in IntegralDomains():
raise ValueError("%s is no integral domain" % base)
if (not isinstance(base, LazyIntegralDomain)):
base = LazyDomain(base)
Field.__init__(self, base, category=QuotientFields())
self.base().register_conversion(LFFSimpleMorphism(self, self.base()))
self.base().base().register_conversion(
LFFSimpleMorphism(self,
self.base().base()))
try:
self.base().base().fraction_field().register_conversion(
LFFSimpleMorphism(self,
self.base().base().fraction_field()))
except Exception:
pass
def __init__(self, constant_field, names,
element_class = FunctionFieldElement_rational,
category=CAT):
"""
Create a rational function field in one variable.
INPUT:
- ``constant_field`` -- an arbitrary field
- ``names`` -- a string or tuple of length 1
- ``category`` -- default: FunctionFields()
EXAMPLES::
sage: K.<t> = FunctionField(CC); K
Rational function field in t over Complex Field with 53 bits of precision
sage: K.category()
Category of function fields
sage: FunctionField(QQ[I], 'alpha')
Rational function field in alpha over Number Field in I with defining polynomial x^2 + 1
Must be over a field::
sage: FunctionField(ZZ, 't')
Traceback (most recent call last):
...
TypeError: constant_field must be a field
"""
if names is None:
raise ValueError, "variable name must be specified"
elif not isinstance(names, tuple):
names = (names, )
if not constant_field.is_field():
raise TypeError, "constant_field must be a field"
self._element_class = element_class
self._element_init_pass_parent = False
Field.__init__(self, self, names=names, category = category)
R = constant_field[names[0]]
self._hash = hash((constant_field, names))
self._constant_field = constant_field
self._ring = R
self._field = R.fraction_field()
self._populate_coercion_lists_(coerce_list=[self._field])
self._gen = self(R.gen())