## `glossary` -- glossary

#### Introduction

This 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 `domtype`. 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 `DOM_XXX` (e.g., `DOM_INT`, `DOM_SET`, `DOM_LIST`, `DOM_ARRAY`, `DOM_TABLE`, etc.). Details of kernel domains can be found in the document ``Basic MuPAD Data Types''. In addition, MuPAD's programming language allows to introduce new data types via the keyword `domain` or the function `newDomain`. The MuPAD library provides many such domains. For example, series expansions, matrices, piecewise defined objects etc. are domains implemented in the MuPAD language. The documentation refers to such data types as ``library domains''. In particular, the library `Dom` provides a variety of predefined data types such as matrices, residue classes, intervals etc. See `DOM_DOMAIN` for general explanations on data types. Here you also find some simple examples demonstrating how the user can implement her own domains. 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 `max`, where it refers to simplification rules such as `max(a, max(b, c)) = max(a, b, c)`.
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 `DOM_COMPLEX` encompasses the Gaussian integers such as `3 + 7*I`, the Gaussian rationals such as `3/4 + 7/4*I`, and complex floating point numbers such as `1.2 + 3.4*I`.
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.

Do you have questions or comments?
Copyright © SciFace Software GmbH & Co. KG 2000