Previous: floating-idef, Up: The optional Floating-Point word set [Contents][Index]

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

.

Previous: floating-idef, Up: The optional Floating-Point word set [Contents][Index]