Documentation |
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, hfarrays, 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_HFARRAY, DOM_TABLE, etc.). In addition, the MuPAD 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. |
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: 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. |
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. |