Previous: floating-idef, Up: The optional Floating-Point word set

#### 8.7.2 Ambiguous conditions

`df@` or `df!` used with an address that is not double-float aligned:
System-dependent. Typically results in a `-23 THROW` like other alignment violations.
`f@` or `f!` used with an address that is not float aligned:
System-dependent. Typically results in a `-23 THROW` like other alignment violations.
floating-point result out of range:
System-dependent. Can result in a `-43 throw` (floating point overflow), `-54 throw` (floating point underflow), `-41 throw` (floating point inexact result), `-55 THROW` (Floating-point unidentified fault), or can produce a special value representing, e.g., Infinity.
`sf@` or `sf!` used with an address that is not single-float aligned:
System-dependent. Typically results in an alignment fault like other alignment violations.
`base` is not decimal (`REPRESENT`, `F.`, `FE.`, `FS.`):
The floating-point number is converted into decimal nonetheless.
Both arguments are equal to zero (`FATAN2`):
System-dependent. `FATAN2` is implemented using the C library function `atan2()`.
Using `FTAN` on an argument r1 where cos(r1) is zero:
System-dependent. Anyway, typically the cos of r1 will not be zero because of small errors and the tan will be a very large (or very small) but finite number.
d cannot be presented precisely as a float in `D>F`:
The result is rounded to the nearest float.
dividing by zero:
Platform-dependent; can produce an Infinity, NaN, `-42 throw` (floating point divide by zero) or `-55 throw` (Floating-point unidentified fault).
exponent too big for conversion (`DF!`, `DF@`, `SF!`, `SF@`):
System dependent. On IEEE-FP based systems the number is converted into an infinity.
float<1 (`FACOSH`):
Platform-dependent; on IEEE-FP systems typically produces a NaN.
float=<-1 (`FLNP1`):
Platform-dependent; on IEEE-FP systems typically produces a NaN (or a negative infinity for float=-1).
float=<0 (`FLN`, `FLOG`):
Platform-dependent; on IEEE-FP systems typically produces a NaN (or a negative infinity for float=0).
float<0 (`FASINH`, `FSQRT`):
Platform-dependent; for `fsqrt` this typically gives a NaN, for `fasinh` some platforms produce a NaN, others a number (bug in the C library?).
|float|>1 (`FACOS`, `FASIN`, `FATANH`):
Platform-dependent; IEEE-FP systems typically produce a NaN.
integer part of float cannot be represented by d in `F>D`:
Platform-dependent; typically, some double number is produced and no error is reported.
string larger than pictured numeric output area (`f.`, `fe.`, `fs.`):
`Precision` characters of the numeric output area are used. If `precision` is too high, these words will smash the data or code close to `here`.