Dom::BaseDomain
-- the root
of the domain hierarchyDom::BaseDomain
is the root of the domain hierarchy of
the Dom
package. Every
domain of the package inherits from it.
Dom::BaseDomain()
Dom::BaseDomain
is the root of the domain hierarchy as
defined by the Dom
package. Every domain of the package inherits from it.Dom::BaseDomain
is to supply all
domains of the package with some basic methods like
"hasProp"
. Elements of Dom::BaseDomain
cannot
be created.Cat::BaseCategory
This domain entry is used to revive the domain when it is read from a binary MCode stream.
If this entry is present it is written to the MCode stream instead of the contents of the domain. When the stream is read it is used to create the domain.
If this entry does not exist all entries of the domain are written to the stream and read in later to create the domain.
Dom::BaseDomain
defines "create_dom"
to
have the same value as the key of the domain, as stored in the entry
"key"
. All domains of the Dom
package inherit this entry,
thus they must be created by the reader of the MCode stream by
evaluating the expression stored in the key.
equal(dom x, dom
y)
TRUE
if it can decide that
x
is equal to y
in the mathematical sense
imposed by this domain. It must return FALSE
if it can
decide that x
is not equal to y
mathematically. If the method cannot decide the equality it must return
UNKNOWN
, see Cat::BaseCategory
.Ax::canonicalRep
, which implies
that two domain elements are mathematically equal if and only if they
are structurally equal, the kernel function _equal
is used to decide the
equality. In this case UNKNOWN
is never returned.Ax::canonicalRep
does not hold the
method will return TRUE
if x
and
y
are structurally equal (in the sense of the function
_equal
) and
UNKNOWN
otherwise.convert_to(dom x, type T)
T
. It returns FAIL
if a conversion
is not possible.x
to an
element of this domain (the trivial case) or to an element of Dom::Expression
(by using the
method "expr"
, see Cat::BaseCategory
).TeX(dom x)
x
.x
into an expression using the method "expr"
and then uses
the function generate::TeX
to convert the
expression.allAxioms()
allCategories()
allEntries()
allSuperDomains()
Dom
package is
Dom::BaseDomain
.getAxioms()
getCategories()
getSuperDomain()
hasProp(DOM_DOMAIN d)
d
is this domain or a super-domain
of this domain.hasProp(DomainConstructor dc)
dc
.hasProp(Axiom a)
a
.hasProp(AxiomConstructor ac)
ac
.hasProp(Category c)
c
.hasProp(CategoryConstructor
cc)
cc
.info()
info
."info_str"
, which must be a string, is
defined for this domain it is used to print the header line.printMethods( <function sort,> Table)
printMethods( <function sort,> Tree)
adt::Tree
. The tree is both printed out
and returned by the method.printMethods( <function
sort>)
dom::printMethods(sort, Table)
.subs(dom x, ...)
subs
. The implementation provided here
simply returns x
in any case, so it avoids unwanted
substitutions inside of domain elements.subsex(dom x, ...)
subsex
. The implementation provided
here simply returns x
in any case, so it avoids unwanted
substitutions inside of domain elements.undefinedEntries()
whichEntry(e)
e
.FAIL
is returned if no entry with the given name is
defined for this domain."create_dom"
and
"printMethods"
.