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

`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`

.