def parent_to_repr_short(P):
r"""
Helper method which generates a short(er) representation string
out of a parent.
INPUT:
- ``P`` -- a parent.
OUTPUT:
A string.
EXAMPLES::
sage: from sage.rings.asymptotic.misc import parent_to_repr_short
sage: parent_to_repr_short(ZZ)
'ZZ'
sage: parent_to_repr_short(QQ)
'QQ'
sage: parent_to_repr_short(SR)
'SR'
sage: parent_to_repr_short(ZZ['x'])
'ZZ[x]'
sage: parent_to_repr_short(QQ['d, k'])
'QQ[d, k]'
sage: parent_to_repr_short(QQ['e'])
'QQ[e]'
sage: parent_to_repr_short(SR[['a, r']])
'SR[[a, r]]'
sage: parent_to_repr_short(Zmod(3))
'Ring of integers modulo 3'
sage: parent_to_repr_short(Zmod(3)['g'])
'Univariate Polynomial Ring in g over Ring of integers modulo 3'
"""
def abbreviate(P):
if P is sage.rings.integer_ring.ZZ:
return 'ZZ'
elif P is sage.rings.rational_field.QQ:
return 'QQ'
elif P is sage.symbolic.ring.SR:
return 'SR'
raise ValueError('Cannot abbreviate %s.' % (P,))
poly = sage.rings.polynomial.polynomial_ring.is_PolynomialRing(P) or \
sage.rings.polynomial.multi_polynomial_ring_generic.is_MPolynomialRing(P)
from sage.rings import multi_power_series_ring
power = sage.rings.power_series_ring.is_PowerSeriesRing(P) or \
multi_power_series_ring.is_MPowerSeriesRing(P)
if poly or power:
if poly:
op, cl = ('[', ']')
else:
op, cl = ('[[', ']]')
try:
s = abbreviate(P.base_ring()) + op + ', '.join(P.variable_names()) + cl
except ValueError:
s = str(P)
else:
try:
s = abbreviate(P)
except ValueError:
s = str(P)
return s
def parent_to_repr_short(P):
r"""
Helper method which generates a short(er) representation string
out of a parent.
INPUT:
- ``P`` -- a parent.
OUTPUT:
A string.
EXAMPLES::
sage: from sage.rings.asymptotic.misc import parent_to_repr_short
sage: parent_to_repr_short(ZZ)
'ZZ'
sage: parent_to_repr_short(QQ)
'QQ'
sage: parent_to_repr_short(SR)
'SR'
sage: parent_to_repr_short(RR)
'RR'
sage: parent_to_repr_short(CC)
'CC'
sage: parent_to_repr_short(ZZ['x'])
'ZZ[x]'
sage: parent_to_repr_short(QQ['d, k'])
'QQ[d, k]'
sage: parent_to_repr_short(QQ['e'])
'QQ[e]'
sage: parent_to_repr_short(SR[['a, r']])
'SR[[a, r]]'
sage: parent_to_repr_short(Zmod(3))
'Ring of integers modulo 3'
sage: parent_to_repr_short(Zmod(3)['g'])
'Univariate Polynomial Ring in g over Ring of integers modulo 3'
"""
from sage.rings.all import RR, CC, RIF, CIF, RBF, CBF
from sage.rings.integer_ring import ZZ
from sage.rings.rational_field import QQ
from sage.symbolic.ring import SR
from sage.rings.polynomial.polynomial_ring import is_PolynomialRing
from sage.rings.polynomial.multi_polynomial_ring_base import is_MPolynomialRing
from sage.rings.power_series_ring import is_PowerSeriesRing
def abbreviate(P):
try:
return P._repr_short_()
except AttributeError:
pass
abbreviations = {ZZ: 'ZZ', QQ: 'QQ', SR: 'SR',
RR: 'RR', CC: 'CC',
RIF: 'RIF', CIF: 'CIF',
RBF: 'RBF', CBF: 'CBF'}
try:
return abbreviations[P]
except KeyError:
pass
raise ValueError('Cannot abbreviate %s.' % (P,))
poly = is_PolynomialRing(P) or is_MPolynomialRing(P)
from sage.rings import multi_power_series_ring
power = is_PowerSeriesRing(P) or \
multi_power_series_ring.is_MPowerSeriesRing(P)
if poly or power:
if poly:
op, cl = ('[', ']')
else:
op, cl = ('[[', ']]')
try:
s = abbreviate(P.base_ring()) + op + ', '.join(P.variable_names()) + cl
except ValueError:
s = str(P)
else:
try:
s = abbreviate(P)
except ValueError:
s = str(P)
return s
def __init__(self, parent, x=0, prec=infinity, is_gen=False, check=False):
"""
input x can be an MPowerSeries, or an element of
- the background univariate power series ring
- the foreground polynomial ring
- a ring that coerces to one of the above two
TESTS::
sage: S.<s,t> = PowerSeriesRing(ZZ)
sage: f = s + 4*t + 3*s*t
sage: f in S
True
sage: f = f.add_bigoh(4); f
s + 4*t + 3*s*t + O(s, t)^4
sage: g = 1 + s + t - s*t + S.O(5); g
1 + s + t - s*t + O(s, t)^5
sage: B.<s, t> = PowerSeriesRing(QQ)
sage: C.<z> = PowerSeriesRing(QQ)
sage: B(z)
Traceback (most recent call last):
...
TypeError: Cannot coerce input to polynomial ring.
sage: D.<s> = PowerSeriesRing(QQ)
sage: s.parent() is D
True
sage: B(s) in B
True
sage: d = D.random_element(20)
sage: b = B(d) # test coercion from univariate power series ring
sage: b in B
True
"""
PowerSeries.__init__(self, parent, prec, is_gen=is_gen)
self._PowerSeries__is_gen = is_gen
try:
prec = min(prec, x.prec()) # use precision of input, if defined
except AttributeError:
pass
# set the correct background value, depending on what type of input x is
try:
xparent = x.parent() # 'int' types have no parent
except AttributeError:
xparent = None
# test whether x coerces to background univariate
# power series ring of parent
from sage.rings.multi_power_series_ring import is_MPowerSeriesRing
if is_PowerSeriesRing(xparent) or is_MPowerSeriesRing(xparent):
# x is either a multivariate or univariate power series
#
# test whether x coerces directly to designated parent
if is_MPowerSeries(x):
try:
self._bg_value = parent._bg_ps_ring(x._bg_value)
except TypeError:
raise TypeError("Unable to coerce into background ring.")
# test whether x coerces to background univariate
# power series ring of parent
elif xparent == parent._bg_ps_ring():
self._bg_value = x
elif parent._bg_ps_ring().has_coerce_map_from(xparent):
# previous test may fail if precision or term orderings of
# base rings do not match
self._bg_value = parent._bg_ps_ring(x)
else:
# x is a univariate power series, but not from the
# background power series ring
#
# convert x to a polynomial and send to background
# ring of parent
x = x.polynomial()
self._bg_value = parent._send_to_bg(x).add_bigoh(prec)
# test whether x coerces to underlying polynomial ring of parent
elif is_PolynomialRing(xparent):
self._bg_value = parent._send_to_bg(x).add_bigoh(prec)
else:
try:
x = parent._poly_ring(x)
#self._value = x
self._bg_value = parent._send_to_bg(x).add_bigoh(prec)
except (TypeError, AttributeError):
raise TypeError("Input does not coerce to any of the expected rings.")
self._go_to_fg = parent._send_to_fg
self._prec = self._bg_value.prec()
# self._parent is used a lot by the class PowerSeries
self._parent = self.parent()
def __init__(self, parent, x=0, prec=infinity, is_gen=False, check=False):
"""
input x can be an MPowerSeries, or an element of
- the background univariate power series ring
- the foreground polynomial ring
- a ring that coerces to one of the above two
TESTS::
sage: S.<s,t> = PowerSeriesRing(ZZ)
sage: f = s + 4*t + 3*s*t
sage: f in S
True
sage: f = f.add_bigoh(4); f
s + 4*t + 3*s*t + O(s, t)^4
sage: g = 1 + s + t - s*t + S.O(5); g
1 + s + t - s*t + O(s, t)^5
sage: B.<s, t> = PowerSeriesRing(QQ)
sage: C.<z> = PowerSeriesRing(QQ)
sage: B(z)
Traceback (most recent call last):
...
TypeError: Cannot coerce input to polynomial ring.
sage: D.<s> = PowerSeriesRing(QQ)
sage: s.parent() is D
True
sage: B(s) in B
True
sage: d = D.random_element(20)
sage: b = B(d) # test coercion from univariate power series ring
sage: b in B
True
"""
PowerSeries.__init__(self, parent, prec, is_gen=is_gen)
self._PowerSeries__is_gen = is_gen
try:
prec = min(prec, x.prec()) # use precision of input, if defined
except AttributeError:
pass
# set the correct background value, depending on what type of input x is
try:
xparent = x.parent() # 'int' types have no parent
except AttributeError:
xparent = None
# test whether x coerces to background univariate
# power series ring of parent
from sage.rings.multi_power_series_ring import is_MPowerSeriesRing
if is_PowerSeriesRing(xparent) or is_MPowerSeriesRing(xparent):
# x is either a multivariate or univariate power series
#
# test whether x coerces directly to designated parent
if is_MPowerSeries(x):
try:
self._bg_value = parent._bg_ps_ring(x._bg_value)
except TypeError:
raise TypeError("Unable to coerce into background ring.")
# test whether x coerces to background univariate
# power series ring of parent
elif xparent == parent._bg_ps_ring():
self._bg_value = x
elif parent._bg_ps_ring().has_coerce_map_from(xparent):
# previous test may fail if precision or term orderings of
# base rings do not match
self._bg_value = parent._bg_ps_ring(x)
else:
# x is a univariate power series, but not from the
# background power series ring
#
# convert x to a polynomial and send to background
# ring of parent
x = x.polynomial()
self._bg_value = parent._send_to_bg(x).add_bigoh(prec)
# test whether x coerces to underlying polynomial ring of parent
elif is_PolynomialRing(xparent):
self._bg_value = parent._send_to_bg(x).add_bigoh(prec)
else:
try:
x = parent._poly_ring(x)
#self._value = x
self._bg_value = parent._send_to_bg(x).add_bigoh(prec)
except (TypeError, AttributeError):
raise TypeError(
"Input does not coerce to any of the expected rings.")
self._go_to_fg = parent._send_to_fg
self._prec = self._bg_value.prec()
# self._parent is used a lot by the class PowerSeries
self._parent = self.parent()
