Dom::Numerical -- the field of
numbers
IntroductionDom::Numerical is the field of numbers.
DetailsDom::Numerical is the domain of numbers represented by
one of the kernel domains DOM_INT, DOM_RAT, DOM_FLOAT, or DOM_COMPLEX.Dom::Numerical is of category Cat::Field due to pragmatism. This domain
actually is not a field because bool(1.0 = float(3) /
float(3)) returns FALSE, for example.Dom::Numerical are usually not created
explicitly. However, if one creates elements using the usual syntax, it
is checked whether the input expression can be converted into a number
(see below).
This means that Dom::Numerical is a faēcade domain
which creates elements of domain type DOM_INT,
DOM_RAT, DOM_FLOAT or
DOM_COMPLEX. Every system function dealing with numbers
can be applied, and computations in this domain are performed
efficiently.
Dom::Numerical has no normal representation, because
0 and 0.0 both represent zero.Dom::Numerical is
trivial. It only contains constants.
Creating
ElementsDom::Numerical(x)
Parametersx |
- | an arithmetical expression |
Cat::DifferentialRing
Related
DomainsDom::Complex, Dom::Float, Dom::Integer, Dom::Rational, Dom::Real
Detailsx is a constant
arithmetical expression such as sin(2) or PI +
2, the system function float is applied to convert
x into a floating point approximation.
An error message is issued if the result of this conversion is not
of domain type DOM_FLOAT or DOM_COMPLEX.
is zero.
D(dom a)a, which is
zero.D for
details and further calling sequences.diff(dom a, variable x)a with respect to
x, which results in zero.diff
for details and further calling sequences.norm(dom a)random()convert(any x)x into a number of type
Dom::Numerical and returns FAIL if this is
not possible.x is of the domain type DOM_INT, DOM_RAT, DOM_FLOAT or DOM_COMPLEX, x is
returned.
Otherwise float(x) is computed and the result is
returned, if it is of the domain type DOM_FLOAT or
DOM_COMPLEX. If it
is not, FAIL is returned.
convert_to(dom a, any
T)a into an
element of the domain T.FAIL is returned.T:
DOM_INT, Dom::Integer, DOM_RAT, Dom::Rational, DOM_FLOAT, Dom::Float and DOM_COMPLEX.testtype(any a, dom
T)a into the
domain Dom::Numerical. The method returns
TRUE if it can perform the conversion, and
FAIL otherwise.testtype.
Example
1Dom::Numerical contains numbers of the
domains DOM_INT,
DOM_RAT, DOM_FLOAT and DOM_COMPLEX:
>> Dom::Numerical(2), Dom::Numerical(2/3), Dom::Numerical(3.141), Dom::Numerical(2 + 3*I)
2, 2/3, 3.141, 2 + 3 I
Constant arithmetical expressions are converted into a
real and complex floating point number, respectively, i.e., into an
element of the domain DOM_FLOAT or DOM_COMPLEX (see the function
float for details):
>> Dom::Numerical(exp(5)), Dom::Numerical(sin(2/3*I) + 3)
148.4131591, 3.0 + 0.717158461 I
Note that the elements of this domain are elements of
kernel domains, there are no elements of the domain type
Dom::Numerical!
An error message is issued for non-constant arithmetical expressions:
>> Dom::Numerical(sin(x))
Error: illegal arguments [Dom::Numerical::new]
Example
2Dom::Numerical is regarded as a field, and
it therefore can be used as a coefficient ring of polynomials or as a
component ring of matrices, for example.
We create the domain of matrices of arbitrary size (see Dom::Matrix) with numerical
components:
>> MatN := Dom::Matrix(Dom::Numerical)
Dom::Matrix(Dom::Numerical)
Next we create a banded matrix, such as:
>> A := MatN(4, 4, [-PI, 0, PI], Banded)
+- -+
| 0, 3.141592654, 0, 0 |
| |
| -3.141592654, 0, 3.141592654, 0 |
| |
| 0, -3.141592654, 0, 3.141592654 |
| |
| 0, 0, -3.141592654, 0 |
+- -+
and a row vector with four components as a 1 x 4 matrix:
>> v := MatN([[2, 3, -1, 0]])
+- -+
| 2, 3, -1, 0 |
+- -+
Vector-matrix multiplication can be performed with the
standard operator * for
multiplication:
>> v * A
+- -+
| -9.424777961, 9.424777961, 9.424777961, -3.141592654 |
+- -+
Finally we compute the determinant of the matrix
A, using the function linalg::det of the linalg package:
>> linalg::det(A)
97.40909104
Super-DomainAx::canonicalRep
, Ax::systemRep,
Ax::efficientOperation("_divide"),
Ax::efficientOperation("_mult"),
Ax::efficientOperation("_invert")