symbol is short for Symbolic Name. A value of type
represents a variable name possibly with some integer subscripts
attached. Its primary use is for input and output of polynomials: the
name of each indeterminate in a
PolyRing is a
symbol value has two components:
_s (note no other characters allowed)
symbols are: (in standard printed forms)
It is also possible to create anonymous symbols: they are useful for building (temporary) polynomial extensions of unknown coefficient rings (which may contain any symbol) to guarantee no name conflicts.
Each newly created anonymous symbol has a subscript strictly greater
than that of any previous anonymous symbol. For better readability,
an anonymous symbol prints out as a hash sign followed by the
head be a
n machine integers,
symbolwith no subscripts
symbol(head, ind)-- a
symbolwith a single subscript
symbol(head, ind1, ind2)-- a
symbolwith a two subscripts
symbol(head, inds)-- a
symbolwith the given subscripts
NewSymbol()-- a new anonymous symbol (printed form is like this
Several polynomial ring pseudo-constructors expect a
symbols to specify the names of the indeterminates. There are
several convenience functions for constructing commonly used
symbols(str)-- create a
vector<symbol>containing comma-separated symbols in
SymbolRange(hd, lo, hi)-- create vector of
hd[hi]. Note that these symbols each have just a single subscript
SymbolRange(sym1, sym2)-- create vector of cartesian product of the subscripts, e.g. given
NewSymbols(n)-- create vector of
nnew anonymous symbols
sym2 be objects of type
head(sym)-- head of
symas a const ref to
NumSubscripts(sym)-- number of subscripts
symhas (0 if sym has no subscripts)
subscript(sym, n)-- gives
n-th subscript of
cmp(sym1, sym2)-- <0, =0, >0 according as
sym1< = >
sym2(for more info see Maintainer section)
sym1 < sym2-- comparisons defined in terms of
sym1 <= sym2-- ...
sym1 > sym2-- ...
sym1 >= sym2-- ...
sym1 == sym2-- ...
sym1 != sym2-- ...
out << sym-- print
in >> sym-- read a symbol into
sym(but also see Bugs section) (expected format is x, y, z[2,3], etc.)
AreDistinct(vecsyms)-- true iff all symbols are distinct
AreArityConsistent(vecsyms)-- true iff all symbols with the same head have the same arity
Note: I have used
MachineInt as the type for fn args containing
index values because it is safer, and I believe that the run-time
penalty is unimportant. This is a considered exception to the guideline
which says to use
long for indexes.
I have decided not to allow big integers as subscripts because I don't see when it could ever be genuinely useful.
The implementation is extremely simple. Efficiency does not seem to be
SymbolRange copy the vector upon returning).
The implementation of
SymbolRange is mildly delicate when we have to make
checks to avoid integer overflow -- see comments in the code.
To make "anonymous" symbols I opted to use a private ctor which
accepts just a single subscript; this ctor is called only by
The printing fn (
myOutputSelf) has to check for an empty head, and if
found it prints the string in
We believe a total ordering on
symbols could be useful; for instance,
if someone wants to make a
symbols. Currently the
total order is Lex on the heads then lex on the subscript vectors; this
is simple, and is probably fast enough.
symbol::myInput is a stop-gap implementation.
The member function
myInput handles white space wrongly. For CoCoALib
whitespace is space, TAB, or backslash-newline; newline without backslash
is not considered white space.
In redmine 747 there is a suggestion to allow
we decided (2016-02-01) to postpone extending
symbol in this way.
It might be nice to have a function which returns the vector of subscripts of a name.
I wonder what sending a
symbol on an OpenMath channel would mean
(given that OpenMath is supposed to preserve semantics, and a symbolic
name is by definition devoid of semantics).