Previous: Implementation Defined Options, 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: Implementation Defined Options, Up: The optional Floating-Point word set [Contents][Index]