## `Dom::Float` -- the real floating point numbers

#### Introduction

`Dom::Float` is the set of real floating point numbers represented by elements of the domain `DOM_FLOAT`.

#### Creating Elements

`Dom::Float(x)`

#### Parameters

`x` | - | an expression which can be converted to a `DOM_FLOAT` by the function `float`.

#### Categories

`Cat::DifferentialRing`

, `Cat::Field`, `Cat::OrderedSet`

#### Related Domains

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

#### Details

- `Dom::Float` is the domain of real floating point numbers represented by expressions of type `DOM_FLOAT`.
- `Dom::Float` has category `Cat::Field` out of pragmatism. This domain actually is not a field because `bool(1.0 = float(3) / float(3))` returns `FALSE` for example.
- Elements of `Dom::Float` are usually not created explicitly. However, if one creates elements using the usual syntax, it is checked whether the input expression may be converted to a floating point number. This means `Dom::Float` is a facade domain which creates elements of domain type `DOM_FLOAT`.
- Viewed as a differential ring `Dom::Float` is trivial, it contains constants only.
- `Dom::Float` has the domain `Dom::Numerical` as its super domain, i.e., it inherits each method which is defined by `Dom::Numerical` and not implemented by `Dom::Float`. Methods described below are re-implemented by `Dom::Float`.

#### Entries

one

  the unit element; it equals `1.0`.

zero

  The zero element; it equals `0.0`.

#### Method random: random number generation

- `random()`
- - This methods returns a randomly generated number.

#### Method convert: conversion of objects

- `convert(any x)`
- - This method tries to convert `x` to a number of type `Dom::Float`. If the conversion fails, `FAIL` is returned.
  - In general, if `float(x)` evaluates to a real floating point number of type `DOM_FLOAT`, this number is the result of the conversion.

#### Method convert_to: conversion to other domains

- `convert_to(dom x, any T)`
- - This method tries to convert the number `x` to an element of type `T`, or, if `T` is not a domain, to the domain type of `T`. If the conversion fails, then `FAIL` is returned.
  - The following domains are allowed for `T`: `DOM_FLOAT`, `Dom::Float` and `Dom::Numerical`.

#### Method testtype: type checking

- `testtype(any x, dom T)`
- - This method checks whether it can convert `x` to the domain `Dom::Float`. It returns `TRUE` if it can perform the conversion. Otherwise `FAIL` is returned.
  - In general this method is called from the function `testtype` and not directly by the user. Example 2 demonstrates this behavior.

#### Example 1

Creating some floating point numbers using `Dom::Float`. This example also shows that `Dom::Float` is a facade domain.

    >> Dom::Float(2.3); domtype(%)

                                        2.3

                                     DOM_FLOAT

    >> Dom::Float(sin(2/3*PI) + 3)

                                    3.866025404

    >> Dom::Float(sin(x))

          Error: illegal arguments [Dom::Float::new]

#### Example 2

By tracing the method `Dom::Float::testtype` we can see the interaction between `testtype` and `Dom::Float::testtype`.

    >> prog::trace(Dom::Float::testtype):
       delete x:
       testtype(x, Dom::Float);
       testtype(3.4, Dom::Float);
       prog::untrace(Dom::Float::testtype):

          enter 'Dom::Float::testtype'           with args   : x, Dom::Float
          leave 'Dom::Float::testtype'           with result : FAIL

                                       FALSE
          enter 'Dom::Float::testtype'           with args   : 3.4, Dom::Float
          leave 'Dom::Float::testtype'           with result : TRUE

                                       TRUE

#### Super-Domain

`Dom::Numerical`

#### Axioms

`Ax::canonicalRep`

, `Ax::systemRep`, `Ax::canonicalOrder`, `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