def _repr_(self):
r"""
Return a string representation of ``self``.
Supports printing in exponential coordinates of the first and
second kinds, depending on the default coordinate system.
EXAMPLES::
sage: L = LieAlgebra(QQ, 2, step=2)
sage: G = L.lie_group('H')
sage: g = G.point([1, 2, 3]); g
exp(X_1 + 2*X_2 + 3*X_12)
sage: G.set_default_chart(G.chart_exp2())
sage: g
exp(4*X_12)exp(2*X_2)exp(X_1)
"""
G = self.parent()
chart = G.default_chart()
if chart != G._Exp1:
if chart != G.chart_exp2():
chart = G._Exp1
x = self.coordinates(chart=chart)
B = G.lie_algebra().basis()
nonzero_pairs = [(Xk, xk) for Xk, xk in zip(B, x) if xk]
if chart == G._Exp1:
s = repr_lincomb(nonzero_pairs)
else:
s = ")exp(".join(repr_lincomb([(Xk, xk)])
for Xk, xk in reversed(nonzero_pairs))
if not s:
s = "0"
return "exp(%s)" % s
def _repr_(self):
r"""
Return a string representation of ``self``.
OUTPUT:
- string.
TESTS::
sage: R.<x, y> = ZZ[]
sage: S = Spec(R)
sage: from sage.schemes.generic.divisor import Divisor_generic
sage: from sage.schemes.generic.divisor_group import DivisorGroup
sage: Div = DivisorGroup(S)
sage: D = Divisor_generic([(4, x), (-5, y), (1, x+2*y)], Div)
sage: D._repr_()
'V(x + 2*y) + 4*V(x) - 5*V(y)'
"""
# The default representation coming from formal sums does not look
# very nice for divisors
terms = list(self)
# We sort the terms by variety. The order is "reversed" to keep it
# straight - as the test above demonstrates, it results in the first
# generator being in front of the second one
terms.sort(key=lambda x: x[1], reverse=True)
return repr_lincomb([("V(%s)" % v, c) for c, v in terms])
def _repr_(self):
"""
Return string representation of self.
EXAMPLES::
sage: A.<x,y,z> = FreeAlgebra(ZZ,3)
sage: repr(-x+3*y*z) # indirect doctest
'-x + 3*y*z'
Trac ticket :trac:`11068` enables the use of local variable names::
sage: from sage.structure.parent_gens import localvars
sage: with localvars(A, ['a','b','c']):
....: print(-x+3*y*z)
-a + 3*b*c
"""
v = sorted(self._monomial_coefficients.items())
P = self.parent()
M = P.monoid()
from sage.structure.parent_gens import localvars
with localvars(M, P.variable_names(), normalize=False):
x = repr_lincomb(v, strip_one=True)
return x
def _latex_(self):
r"""
Return a LaTeX representation of ``self``.
OUTPUT:
- string.
TESTS::
sage: R.<x, y> = ZZ[]
sage: S = Spec(R)
sage: from sage.schemes.generic.divisor import Divisor_generic
sage: from sage.schemes.generic.divisor_group import DivisorGroup
sage: Div = DivisorGroup(S)
sage: D = Divisor_generic([(4, x), (-5, y), (1, x+2*y)], Div)
sage: D._latex_()
'\\mathrm{V}\\left(x + 2 y\\right)
+ 4 \\mathrm{V}\\left(x\\right)
- 5 \\mathrm{V}\\left(y\\right)'
"""
# The code is copied from _repr_ with latex adjustments
terms = list(self)
# We sort the terms by variety. The order is "reversed" to keep it
# straight - as the test above demonstrates, it results in the first
# generator being in front of the second one
terms.sort(key=lambda x: x[1], reverse=True)
return repr_lincomb([(r"\mathrm{V}\left(%s\right)" % latex(v), c)
for c, v in terms],
is_latex=True)
def _repr_(self):
"""
EXAMPLES::
sage: a = FormalSum([(1,2/3), (-3,4/5), (7,Mod(2,3))])
sage: a # random, since comparing Mod(2,3) and rationals ill-defined
sage: a._repr_() # random
'2/3 - 3*4/5 + 7*2'
"""
return repr_lincomb([t, c] for c, t in self)
def __repr__(self):
from cutgeneratingfunctionology.spam.parametric_real_field_element import is_parametric_element
# Following the Sage convention of returning a pretty-printed
# expression in __repr__ (rather than __str__).
if not(is_parametric_element(self._slope) or is_parametric_element(self._intercept)):
# repr_lincomb tests for 0, don't do this for parametric elements.
try:
return '<FastLinearFunction ' + repr_lincomb([('x', self._slope), (1, self._intercept)], strip_one = True) + '>'
except TypeError:
pass
return '<FastLinearFunction (%s)*x + (%s)>' % (self._slope, self._intercept)
def _latex_(self):
r"""
EXAMPLES::
sage: latex(FormalSum([(1,2), (5, 8/9), (-3, 7)]))
2 + 5\cdot \frac{8}{9} - 3\cdot 7
"""
from sage.misc.latex import repr_lincomb
symbols = [z[1] for z in self]
coeffs = [z[0] for z in self]
return repr_lincomb(symbols, coeffs)
def _repr_(self):
"""
Return the string representation of ``self``.
EXAMPLES::
sage: ModularSymbols(Gamma0(11), 2).boundary_space()(Cusp(0))._repr_()
'[0]'
sage: (-6*ModularSymbols(Gamma0(11), 2).boundary_space()(Cusp(0)))._repr_()
'-6*[0]'
"""
return repr_lincomb([('[' + repr(self.parent()._known_gens[i]) + ']',
c) for i, c in sorted(self.__x.items())])
def _latex_(self):
"""
EXAMPLES::
sage: H, (i,j,k) = sage.algebras.free_algebra_quotient.hamilton_quatalg(QQ)
sage: ((2/3)*i - j)._latex_()
'\\frac{2}{3} i - j'
"""
Q = self.parent()
M = Q.monoid()
with localvars(M, Q.variable_names()):
cffs = tuple(self.__vector)
mons = Q.monomial_basis()
return repr_lincomb(zip(mons, cffs), is_latex=True, strip_one=True)
def _repr_(self):
"""
EXAMPLES::
sage: H, (i,j,k) = sage.algebras.free_algebra_quotient.hamilton_quatalg(ZZ)
sage: i._repr_()
'i'
"""
Q = self.parent()
M = Q.monoid()
with localvars(M, Q.variable_names()):
cffs = list(self.__vector)
mons = Q.monomial_basis()
return repr_lincomb(zip(mons, cffs), strip_one=True)
def _latex_(self):
r"""
A visual representation of this element.
For a free generator `L`, the element `\frac{T^{j}}{j!}L` is
denoted by ``T^(j)L``.
EXAMPLES::
sage: V = lie_conformal_algebras.Virasoro(QQ); V.inject_variables()
Defining L, C
sage: latex(L.T(2))
2T^{(2)}L
sage: R = lie_conformal_algebras.Affine(QQbar, 'A1', names=('e','h','f')); R.inject_variables()
Defining e, h, f, K
sage: latex(e.bracket(f))
\left\{0 : h, 1 : K\right\}
sage: latex(e.T(3))
6T^{(3)}e
sage: R = lie_conformal_algebras.Affine(QQbar, 'A1')
sage: latex(R.0.bracket(R.2))
\left\{0 : \alpha^\vee_{1}, 1 : \text{\texttt{K}}\right\}
sage: R = lie_conformal_algebras.Affine(QQ, 'A1'); latex(R.0.T(3))
6T^{(3)}\alpha_{1}
"""
if self.is_zero():
return "0"
p = self.parent()
try:
names = p.latex_variable_names()
except ValueError:
names = None
if names:
terms = [("T^{{({0})}}{1}".format(k[1],
names[p._index_to_pos[k[0]]]),v) if k[1] > 1 \
else("T{}".format(names[p._index_to_pos[k[0]]]),v)\
if k[1] == 1\
else ("{}".format(names[p._index_to_pos[k[0]]]),v)\
for k,v in self.monomial_coefficients().items()]
else:
terms = [("T^{{({0})}}{1}".format(k[1], latex(k[0])),v) if k[1] > 1 \
else("T{}".format(latex(k[0])),v) if k[1] == 1 \
else ("{}".format(latex(k[0])),v)\
for k,v in self.monomial_coefficients().items()]
return repr_lincomb(terms, is_latex=True, strip_one=True)
def _latex_(self):
r"""
Return latex representation of self.
EXAMPLES::
sage: A.<x,y,z>=FreeAlgebra(ZZ,3)
sage: latex(-x+3*y^20*z) # indirect doctest
-x + 3 y^{20}z
sage: alpha,beta,gamma=FreeAlgebra(ZZ,3,'alpha,beta,gamma').gens()
sage: latex(alpha-beta)
\alpha - \beta
"""
v = sorted(self._monomial_coefficients.items())
return repr_lincomb(v, strip_one=True, is_latex=True)
def _repr_(self):
r"""
Return a string representation.
OUTPUT:
A string.
EXAMPLES::
sage: E = EllipticCurve([0, 0, 1, -1, 0])
sage: E.divisor( E(0,0) )._repr_()
'(x, y)'
"""
return repr_lincomb([(tuple(I.gens()), c) for c, I in self])
def _repr_(self):
r"""
A visual representation of this element.
For a free generator `L`, the element `\frac{T^{j}}{j!}L` is
denoted by ``T^(j)L``.
EXAMPLES::
sage: V = lie_conformal_algebras.Virasoro(QQ); V.inject_variables()
Defining L, C
sage: v = L.T(5).nproduct(L,6); v
-1440*L
sage: L.T(2) + L + C
2*T^(2)L + L + C
sage: L.T(4)
24*T^(4)L
sage: R = lie_conformal_algebras.Affine(QQ, 'B3')
sage: R.2.T()+3*R.3
TB[alpha[1]] + 3*B[alpha[2] + alpha[3]]
"""
if self.is_zero():
return "0"
p = self.parent()
if p._names:
terms = [("T^({0}){1}".format(k[1],
p._names[p._index_to_pos[k[0]]]),v) if k[1] > 1 \
else("T{}".format(p._names[p._index_to_pos[k[0]]]),v) \
if k[1] == 1 \
else ("{}".format(p._names[p._index_to_pos[k[0]]]),v)\
for k,v in self.monomial_coefficients().items()]
else:
terms = [("T^({0}){1}".format(k[1], p._repr_generator(k[0])),v)\
if k[1] > 1 else("T{}".format(p._repr_generator(k[0])),v)\
if k[1] == 1 else ("{}".format(p._repr_generator(k[0])),
v) for k,v in self.monomial_coefficients().items()]
return repr_lincomb(terms, strip_one=True)
def _repr_(self):
r"""
String representation of self. The output will depend on the global
modular symbols print mode setting controlled by the function
``set_modsym_print_mode``.
EXAMPLES::
sage: M = ModularSymbols(13, 4)
sage: set_modsym_print_mode('manin'); M.0._repr_()
'[X^2,(0,1)]'
sage: set_modsym_print_mode('modular'); M.0._repr_()
'X^2*{0, Infinity}'
sage: set_modsym_print_mode('vector'); M.0._repr_()
'(1, 0, 0, 0, 0, 0, 0, 0)'
sage: set_modsym_print_mode()
"""
if _print_mode == "vector":
return str(self.element())
elif _print_mode == "manin":
m = self.manin_symbol_rep()
elif _print_mode == "modular":
m = self.modular_symbol_rep()
return repr_lincomb([(t, c) for c, t in m])
