glossary -- glossary
IntroductionThis glossary explains some of the terms that are used throughout the MuPAD documentation.
| arithmetical expression | Syntactically, this is an object of Type::Arithmetical. In
particular, this type includes numbers, identifiers and expressions of
domain type DOM_EXPR. |
| domain |
The phrase ``domain'' is synonymous with ``data type''. Every
MuPAD object has a data type referred to as its ``domain type''.
It may be queried via the function There are ``basic domains'' provided by the system kernel. These
include various types of numbers, sets, lists, arrays, tables,
expressions, polynomials etc. The documentation refers to these data
types as ``kernel domains''. The name of the kernel domains are of the
form In addition, MuPAD's programming language allows to introduce
new data types via the keyword See For a concise description of MuPAD's domain concept, see the technical document ``Axioms, Categories and Domains''. |
| domain element | The phrase ``x is an element of the
domain d'' is synonymous with ``x is of
domain type d'', i.e., ``domtype(x) = d''. In
many cases, the help pages refer to ``domain elements'' as objects of
library domains, i.e., the corresponding domain is implemented in the
MuPAD language. |
| domain type | The domain type of an object is the data type of the
object. It may be queried via domtype. |
| flattening | Sequences such as a := (x, y) or b
:= (u, v) consist of objects separated by commas. Several
sequences may be combined to a longer sequence: (a, b) is
``flattened'' to the sequence (x, y, u, v) consisting of 4
elements. Most functions flatten their arguments, i.e., the call
f(a, b) is interpreted as the call f(x, y, u,
v) with 4 arguments. Note, however, that some functions (e.g.,
the operand function op) do
not flatten their arguments: op(a, 1) is a call with 2
arguments.
The concept of flattening also applies to some functions such as
|
| function | Typically, functions are represented by a procedure or a function
environment. Also functional expressions such as sin@exp +
id^2: x -> sin(exp(x) - x^2 represent functions.
Also numbers can be used as (constant) functions. For example, the call
3(x) yields the number 3 for any argument
x. |
| number | A number may be an integer (of type DOM_INT), or a rational number (of
type DOM_RAT), or a
real floating point number (of type DOM_FLOAT), or a complex number
(of type DOM_COMPLEX).
The type |
| numerical expression | This is an expression that does not contain any
symbolic variable apart from the special constants PI, E, EULER, and CATALAN. A numerical expression such
as I^(1/3) + sqrt(PI)*exp(17) is an exact representation
of a real or a complex number; it may be composed of numbers, radicals
and calls to special functions. It may be converted to a real or
complex floating point number via float. |
| overloading | The help page of a system function only documents the
admissible arguments that are of some basic type provided by the
MuPAD kernel. If the system function f, say, is
declared as ``overloadable'', the user may extend its functionality. He
can implement his own domain or function
environment with a corresponding slot
"f". An element of this domain is then accepted by the
system function f which calls the user-defined slot
function.
See also the domain documentation. |
| polynomial | Syntactically, a polynomial such as poly(x^2 +
2, [x]) is an object of type DOM_POLY. It must be created by a
call to the function poly. Most functions that operate on
such polynomials are overloaded by other polynomial domains of the
MuPAD library. |
| polynomial expression | This is an arithmetical expression in which symbolic
variables and combinations of such variables only enter via positive
integer powers. Examples are x^2 + 2 or x*y + (z +
1)^2. |
| rational expression | This is an arithmetical expression in which symbolic
variables and combinations of such variables only enter via integer
powers. Examples are x^(-2) + x + 2 or x*y + 1/(z +
1)^2. Every polynomial expression is also a rational expression,
but the two previous expressions are not polynomial expressions. |