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()