
Introduction
Dom::ArithmeticalExpression creates the domain of
arithmetical expressions built up by the system functions and operators
like + and *.
Creating
Elements
Dom::ArithmeticalExpression(x)
Parameters
x |
- |
an arithmetical expression |
Categories
Cat::BaseCategory
Related
Domains
Dom::Expression
Details
Dom::ArithmeticalExpression is a faēcade domain of
arithmetical expressions built up by the system functions and operators
like + and *.
- This domain has almost no algebraic structure because unqualified
expressions have no normal form. (For example, there are rational
expressions for zero which are not normalized to
0.) The
main purpose of Dom::ArithmeticalExpression is to provide
implementations for methods used by faēcade sub-domains like Dom::Integer which are represented
by a subset of the arithmetical expressions.
- Elements of
Dom::ArithmeticalExpression are usually
not created explicitly. However, if one creates elements using the
usual syntax, the input is converted to an expression using expr, then it is checked whether
the result is an arithmetical expression.
Entries
- key
-
The name of this domain.
- one
-
The neutral element w.r.t. "_mult": the constant
1.
- zero
-
The neutral element w.r.t. "_plus": the constant
0.
Method _divide: divides arithmetical expressions
_divide(dom f, dom
g)
-
- Returns the arithmetical expression
f/g.
- This method overloads the function
_divide.
- For details, please see
_divide.
Method _invert: inverts an arithmetical expression
_invert(dom f)
-
- Returns the arithmetical expression
1/f.
- This method overloads the function
_invert.
- For details, please see
_invert.
Method _mult: multiplies arithmetical expressions
_mult( <f,g...> )
-
- Multiplies an arbitrary number of arithmetical expressions and
returns the (simplified) arithmetical expression
f*g*...
- This method overloads the function
_mult.
- For details, please see
_mult.
Method _negate: negates an arithmetical expression
_negate(dom f)
-
- Returns the arithmetical expression
-f.
- This method overloads the function
_negate.
- For details, please see
_negate.
Method _plus: adds arithmetical expressions
_plus( <f,g...> )
-
- Adds an arbitrary number of arithmetical expressions and returns
the (simplified) arithmetical expression
f+g+...
- This method overloads the function
_plus.
- For details, please see
_plus.
Method _power: power operator
_power(dom f, dom
g)
-
- Returns the arithmetical expression
f^g.
- This method overloads the function
_power.
- For details, please see
_power.
Method _subtract: subtracts an arithmetical expression
_subtract(dom f, dom
g)
-
- Returns the arithmetical expression
f-g.
- For details, please see
_subtract.
Method D: differential operator for functions
D(function f)
D(list of nonnegative integers [n1,...],
function f)
-
D(f) computes the derivative of f and
returns a function or functional expression which may contain
unevaluated calls of D.
- This method overloads the function
D.
- For details, please see
D.
Method diff: differentiates an arithmetical expression
diff(dom f <,x...>)
-
- Differentiates
f with respect to the given sequence of
variables in the given order and returns an arithmetical expression. If
x is not a variable, f will be evaluated and
returned without differentiation.
- This method overloads the function
diff.
- For details, please see
diff.
Method intmult: multiplies an arithmetical expression with an
integer
intmult(dom f, integer n)
-
- Returns the arithmetical expression
f*n.
- This method overloads the function
_mult.
- For details, please see
_mult.
Method iszero: test for zero
iszero(dom f)
-
- Tests whether
f is zero and returns TRUE or FALSE.
- This method overloads the function
iszero.
- For details, please see
iszero.
Method max: maximum of numbers
max(dom x <,y...> )
-
- Calculates the maximum of numerical elements. If one of the
arguments cannot be evaluated to a number, then the function call with
all non-numerical and the minimum of the numerical arguments is
returned.
- All numerical arguments must be real.
- This method overloads the function
max.
- For details, please see
max.
Method min: minimum of numbers
min(dom x <,y...> )
-
- Calculates the minimum of numerical elements. If one of the
arguments cannot be evaluated to a number, then the function call with
all non-numerical and the minimum of the numerical arguments is
returned.
- All numerical arguments must be real.
- This method overloads the function
min.
- For details, please see
min.
Method norm: norm of an arithmetical expression
norm(dom f)
-
- Computes the norm of
f as the absolute value of
f.
- This method overloads the function
abs.
- For details, please see
abs.
Method convert: check for being an arithmetical expression
convert(any x)
-
- Tests whether
x is an arithmetical expression. If yes,
x is returned; otherwise the result is FAIL.
Example
1
For brevity, we will use AE as a shorthand
notation for Dom::ArithmeticalExpression:
>> AE := Dom::ArithmeticalExpression
Dom::ArithmeticalExpression
An element of this domain can not be created as
follows:
>> e := AE(2*sin(x) + f(x)/y)
f(x)
2 sin(x) + ----
y
Since Dom::ArithmeticalExpression is a
faēcade domain, e is not a domain element, but an
expression:
>> domtype(e)
DOM_EXPR
The fact that no error was returned yields the
information that e is an arithmetical expression. This can
also be checked as follows:
>> testtype(e,AE)
TRUE
In contrast to its super-domain Dom::Expression, this domain only
allows elements which are valid arguments for the arithmetical
functions, thus the following yields an error:
>> AE([a, b])
Error: illegal arguments [Dom::ArithmeticalExpression::new]
Super-Domain
Dom::Expression
Axioms
Ax::systemRep
Changes
Do you have
questions or comments?
Copyright © SciFace Software GmbH & Co. KG
2000