Indexed Generators¶
- class sage.structure.indexed_generators.IndexedGenerators(indices, prefix='x', **kwds)¶
Bases:
object
Abstract base class for parents whose elements consist of generators indexed by an arbitrary set.
Options controlling the printing of elements:
prefix
– string, prefix used for printing elements of this module (optional, default ‘x’). With the default, a monomial indexed by ‘a’ would be printed asx['a']
.latex_prefix
– string orNone
, prefix used in the \(\LaTeX\) representation of elements (optional, defaultNone
). If this is anything except the empty string, it prints the index as a subscript. If this isNone
, it uses the setting forprefix
, so ifprefix
is set to “B”, then a monomial indexed by ‘a’ would be printed asB_{a}
. If this is the empty string, then don’t print monomials as subscripts: the monomial indexed by ‘a’ would be printed asa
, or as[a]
iflatex_bracket
isTrue
.names
– dict with strings as values or list of strings (optional): a mapping from the indices of the generators to strings giving the generators explicit names. This is used instead of the print optionsprefix
andbracket
whennames
is specified.latex_names
– dict with strings as values or list of strings (optional): same asnames
except using the \(\LaTeX\) representationbracket
–None
, bool, string, or list or tuple of strings (optional, defaultNone
): ifNone
, use the value of the attributeself._repr_option_bracket
, which has default valueTrue
. (self._repr_option_bracket
is available for backwards compatibility. Users should setbracket
instead. Ifbracket
is set to anything exceptNone
, it overrides the value ofself._repr_option_bracket
.) IfFalse
, do not include brackets when printing elements: a monomial indexed by ‘a’ would be printed asB'a'
, and a monomial indexed by (1,2,3) would be printed asB(1,2,3)
. If True, use “[” and “]” as brackets. If it is one of “[”, “(”, or “{”, use it and its partner as brackets. If it is any other string, use it as both brackets. If it is a list or tuple of strings, use the first entry as the left bracket and the second entry as the right bracket.latex_bracket
– bool, string, or list or tuple of strings (optional, default False): ifFalse
, do not include brackets in the LaTeX representation of elements. This option is only relevant iflatex_prefix
is the empty string; otherwise, brackets are not used regardless. IfTrue
, use “left[” and “right]” as brackets. If this is one of “[”, “(”, “\{”, “|”, or “||”, use it and its partner, prepended with “left” and “right”, as brackets. If this is any other string, use it as both brackets. If this is a list or tuple of strings, use the first entry as the left bracket and the second entry as the right bracket.scalar_mult
– string to use for scalar multiplication in the print representation (optional, default “*”)latex_scalar_mult
– string orNone
(default:None
), string to use for scalar multiplication in the latex representation. If None, use the empty string ifscalar_mult
is set to “*”, otherwise use the value ofscalar_mult
.tensor_symbol
– string orNone
(default:None
), string to use for tensor product in the print representation. IfNone
, usesage.categories.tensor.symbol
andsage.categories.tensor.unicode_symbol
.sorting_key
– a key function (default:lambda x: x
), to use for sorting elements in the output of elementssorting_reverse
– bool (default:False
), ifTrue
sort elements in reverse order in the output of elementsstring_quotes
– bool (default:True
), ifTrue
then display string indices with quotesiterate_key
– bool (default:False
) iterate through the elements of the key and print the result as comma separated objects for string output
Note
These print options may also be accessed and modified using the
print_options()
method, after the parent has been defined.EXAMPLES:
We demonstrate a variety of the input options:
sage: from sage.structure.indexed_generators import IndexedGenerators sage: I = IndexedGenerators(ZZ, prefix='A') sage: I._repr_generator(2) 'A[2]' sage: I._latex_generator(2) 'A_{2}' sage: I = IndexedGenerators(ZZ, bracket='(') sage: I._repr_generator(2) 'x(2)' sage: I._latex_generator(2) 'x_{2}' sage: I = IndexedGenerators(ZZ, prefix="", latex_bracket='(') sage: I._repr_generator(2) '[2]' sage: I._latex_generator(2) \left( 2 \right) sage: I = IndexedGenerators(ZZ, bracket=['|', '>']) sage: I._repr_generator(2) 'x|2>'
- indices()¶
Return the indices of
self
.EXAMPLES:
sage: F = CombinatorialFreeModule(QQ, ['a', 'b', 'c']) sage: F.indices() {'a', 'b', 'c'}
- prefix()¶
Return the prefix used when displaying elements of self.
EXAMPLES:
sage: F = CombinatorialFreeModule(QQ, ['a', 'b', 'c']) sage: F.prefix() 'B'
sage: X = SchubertPolynomialRing(QQ) sage: X.prefix() 'X'
- print_options(**kwds)¶
Return the current print options, or set an option.
INPUT: all of the input is optional; if present, it should be in the form of keyword pairs, such as
latex_bracket='('
. The allowable keywords are:prefix
latex_prefix
names
latex_names
bracket
latex_bracket
scalar_mult
latex_scalar_mult
tensor_symbol
string_quotes
sorting_key
sorting_reverse
iterate_key
See the documentation for
IndexedGenerators
for descriptions of the effects of setting each of these options.OUTPUT: if the user provides any input, set the appropriate option(s) and return nothing. Otherwise, return the dictionary of settings for print and LaTeX representations.
EXAMPLES:
sage: F = CombinatorialFreeModule(ZZ, [1,2,3], prefix='x') sage: F.print_options() {...'prefix': 'x'...} sage: F.print_options(bracket='(') sage: F.print_options() {...'bracket': '('...}
- sage.structure.indexed_generators.parse_indices_names(names, index_set, prefix, kwds=None)¶
Parse the names, index set, and prefix input, along with setting default values for keyword arguments
kwds
.OUTPUT:
The triple
(N, I, p)
:N
is the tuple of variable names,I
is the index set, andp
is the prefix.
This modifies the dictionary
kwds
.Note
When the indices, names, or prefix have not been given, it should be passed to this function as
None
.Note
For handling default prefixes, if the result will be
None
if it is not processed in this function.EXAMPLES:
sage: from sage.structure.indexed_generators import parse_indices_names sage: d = {} sage: parse_indices_names('x,y,z', ZZ, None, d) (('x', 'y', 'z'), Integer Ring, None) sage: d {} sage: d = {} sage: parse_indices_names('x,y,z', None, None, d) (('x', 'y', 'z'), {'x', 'y', 'z'}, '') sage: d {'string_quotes': False} sage: d = {} sage: parse_indices_names(None, ZZ, None, d) (None, Integer Ring, None) sage: d {}
sage: d = {'string_quotes':True, 'bracket':'['} sage: parse_indices_names(['a','b','c'], ZZ, 'x', d) (('a', 'b', 'c'), Integer Ring, 'x') sage: d {'bracket': '[', 'string_quotes': True} sage: parse_indices_names('x,y,z', None, 'A', d) (('x', 'y', 'z'), {'x', 'y', 'z'}, 'A') sage: d {'bracket': '[', 'string_quotes': True}
- sage.structure.indexed_generators.split_index_keywords(kwds)¶
Split the dictionary
kwds
into two dictionaries, one containing keywords forIndexedGenerators
, and the other is everything else.OUTPUT:
The dictionary containing only they keywords for
IndexedGenerators
. This modifies the dictionarykwds
.Warning
This modifies the input dictionary
kwds
.EXAMPLES:
sage: from sage.structure.indexed_generators import split_index_keywords sage: d = {'string_quotes': False, 'bracket': None, 'base': QQ} sage: split_index_keywords(d) {'bracket': None, 'string_quotes': False} sage: d {'base': Rational Field}
- sage.structure.indexed_generators.standardize_names_index_set(names=None, index_set=None, ngens=None)¶
Standardize the
names
andindex_set
inputs.INPUT:
names
– (optional) the variable namesindex_set
– (optional) the index setngens
– (optional) the number of generators
If
ngens
is a negative number, then this does not check that the number of variable names matches the size of the index set.OUTPUT:
A pair
(names_std, index_set_std)
, wherenames_std
is eitherNone
or a tuple of strings, and whereindex_set_std
is a finite enumerated set. The purpose ofindex_set_std
is to index the generators of some object (e.g., the basis of a module); the strings innames_std
, when they exist, are used for printing these indices. Thengens
If
names
contains exactly one nameX
andngens
is greater than 1, thennames_std
areXi
fori
inrange(ngens)
.