## `Dom::Numerical` -- the field of numbers

#### Introduction

`Dom::Numerical` is the field of numbers.

#### Details

- `Dom::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.
- Elements of `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.
- Viewed as a differential ring, `Dom::Numerical` is trivial. It only contains constants.

#### Creating Elements

`Dom::Numerical(x)`

#### Parameters

`x` | - | an arithmetical expression

#### Categories

`Cat::DifferentialRing`

, `Cat::Field`

#### Related Domains

`Dom::Complex`, `Dom::Float`, `Dom::Integer`, `Dom::Rational`, `Dom::Real`

#### Details

- If `x` 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`.

#### Entries

characteristic

  is zero.

#### Method D: the differential operator for numbers

- `D(dom a)`
- - This method returns the derivative of `a`, which is zero.
  - See the function `D` for details and further calling sequences.

#### Method diff: differentiation of numbers

- `diff(dom a,` variable x)
- - This method differentiates `a` with respect to `x`, which results in zero.
  - See the function `diff` for details and further calling sequences.

#### Method norm: the absolute value of numbers

- `norm(dom a)`
- - This method returns |a|.

#### Method random: random number generation

- `random()`
- - This methods returns a randomly generated number. The real and imaginary part of this number are generated as tan (r), where r is uniformly distributed in the interval ]-π/2,π/2[.

#### Method convert: conversion of objects into numbers

- `convert(any x)`
- - This method tries to convert `x` into a number of type `Dom::Numerical` and returns `FAIL` if this is not possible.
  - If `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.

#### Method convert_to: conversion into other domains

- `convert_to(dom a, any T)`
- - This method tries to convert the number `a` into an element of the domain `T`.
  - If the conversion fails, `FAIL` is returned.
  - It currently handles the following domains for `T`: `DOM_INT`, `Dom::Integer`, `DOM_RAT`, `Dom::Rational`, `DOM_FLOAT`, `Dom::Float` and `DOM_COMPLEX`.

#### Method testtype: type checking

- `testtype(any a, dom T)`
- - This method checks whether it can convert `a` into the domain `Dom::Numerical`. The method returns `TRUE` if it can perform the conversion, and `FAIL` otherwise.
  - This method is called from the function `testtype`.

#### Example 1

`Dom::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 2

`Dom::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-Domain

`Dom::ArithmeticalExpression`

#### Axioms

`Ax::canonicalRep`

, `Ax::systemRep`, `Ax::efficientOperation("_divide")`, `Ax::efficientOperation("_mult")`, `Ax::efficientOperation("_invert")`

#### Changes

- no changes

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