glossary
-- glossaryThis 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. |