(   Title:  Tests for IEEE 754-2008 reference representation
     File:  ieeefp-ref-test.fs
   Author:  David N. Williams
  Version:  0.5.0
  License:  Public Domain
  Revised:  December 24, 2020

These tests have themselves been tested only on little-endian, 32/64-bit
systems.  They have been tested with double and extended double floats,
but not with single or quad floats.

The revision date may reflect cosmetic changes not logged below.

Version 0.5.0
11Sep20 * Started.
        * Classification tests with nan.
13Sep20 * Added fp environment report, more classification tests.
15Sep20 * Finished classification tests.
16Sep20 * Added T-F< tests.
18Sep20 * Added signed zero T-F< tests.
19Sep20 * Added USE-NATIVE-COMPARISONS switch to test existing
          FLOATING-POINT word set versions.
        * Added:  T-F>  T-F=  T-F<=  T-F>=
27Sep20 * REDEFINED-WARNING-OFF instead of REDEFINED-WARNING off.
30Sep20 * Adapted for revision of ieeefp-ref.fs as a module, removed T-
          prefixes.
 1Oct20 * Removed USE-NATIVE-COMPARISONS switch.
        * Replaced by:  USE-NATIVE  ?USE-NATIVE{  }?USE-NATIVE
        * Added:  FDATUM=  FABSDIFF<  F~  FABS
        * Added logic for selection of ref/native F~ for the testers
          themselves.
 2Oct20 * Added:  FNEGATE  FCOPYSIGN
 3Oct20 * Added:  FMAX  FMIN
 7Oct20 * Added FNEXTUP and FNEXTDOWN tests from fnextup.fs 0.9.0, which
          do not cover gaps for extended doubles.
 9Oct20 * Added nan quieting tests for FNEXTUP and FNEXTDOWN.
11Oct20 * Added:  FSNAN?  FQNAN?
        * Add relaxed versions of FNEXTUP and FNEXTDOWN nan tests using
          FQNAN?.
12Oct20 * Moved RAW-CONSTANT and RAW-DROP tests to rawfloat-test.fs.
        * Replaced negative raw constant definitions by tests of
          RAW-NEGATE.
13Oct20 * Added VERBOSE display about possible fpu conversion of sNaN
          into qNan via F@.  This happens on our legacy macOS 32-bit
          system, but not on our 64-bit Catalina system.
16Oct20 * Added report for integer data endianness.
        * Consolidated tests for <nan> F~ into one section headed by: 
          TESTING F~ nan tolerance
22Oct20 * Removed option to use ttester.  Simplified load logic.
        * Added conditional native defs:  F<=  F>=
        * Added experimental SHOULD switch.
25Oct20 * Added:  RAW-FRAC-#LZB
27Oct20 * Added:  RAW-EXP  FLOGB
28Oct20 * Added:  FILOGB
        * Added arithmetic tests from ieeefp-arith-test.fs.
        * Added FATAN2 tests from fatan2-test.fs.
29Oct20 * Moved QUIET to ieeefp-ref.fs.
        * Added:  #LZB  2#LZB  4#LZB
30Oct20 * Added conditionals for skipping tests of undefined native
          versions of reference words.
31Oct20 * Added HAS-QUIETING conditional.
23Dec20 * Added quad raw FCONSTANTs for FNEXTUP and FNEXTDOWN.
          Added 50-digit FCONSTANTs for the FATAN2 section.
24Dec20 * Made fp classification tests conditional on individual
          existence of word definitions.
)

\ *** USER CONFIG

\  true  CONSTANT TESTER-USE-REF-F~
 false CONSTANT TESTER-USE-REF-F~

  true CONSTANT USE-NATIVE
\  false CONSTANT USE-NATIVE

(
Turn on the USE-NATIVE variable above to set ?USE-NATIVE{ to hide
reference and reveal host native definitions, and set }?USE-NATIVE to
reveal reference and hide native definitions.  Tests sandwiched between

  ?USE-NATIVE{ ... }?USE-NATIVE

are switched by the value in USE-NATIVE.  Unsandwiched tests always use
reference definitions when they exist in ieeefp-ref.fs.
)

\ EXPERIMENTAL:  For switching IEEE 754 "should" spec tests on|off.
true CONSTANT SHOULD
\ false CONSTANT SHOULD

\ See the MORE USER CONFIG section below for HAS-QUIETING.

\ *** DEBUGGING

[UNDEFINED] \\ [IF]
: \\  ( -- )  -1 parse 2drop BEGIN refill 0= UNTIL ; [THEN]

\ *** INCLUDES

[DEFINED] -VERBOSEINCLUDE [IF] -VERBOSEINCLUDE [THEN]  \ vfx

INCLUDE tester-display.fs  \ Forth host info and conditional reporting
REDEFINED-WARNING-OFF
VERBOSE on
\ PFE-HOST [IF] loadm ieeefp [THEN]

INCLUDE ieeefp-ref.fs  \ Loads rawfloat.fs, which ensures host has fp.

\ Possibly missing native defs.
[UNDEFINED] F<= [IF]
  : F<=  (f: f1 f2 -- ) ( -- [f1<=f2]? )  f2dup f< f= or ; [THEN]
[UNDEFINED] F>= [IF]
  : F>=  (f: f1 f2 -- ) ( -- [f1>=f2]? )  f2dup f> f= or ; [THEN]

also IEEEFP-REF  \ reveal reference defs

\ Ref words needed For testing native defs.
: tquiet   (f: snan|qnan -- qnan )    QUIET ;
: tfqnan?  (f: f -- ) ( -- [qnan]? )  FQNAN? ;

: ?USE-NATIVE{  ( -- )  USE-NATIVE IF previous
  blue-text s" Using native definitions." ?type normal-text ?.cr THEN ;

: }?USE-NATIVE  ( -- )  USE-NATIVE IF also IEEEFP-REF
  blue-text s" Using reference definitions." ?type normal-text ?.cr THEN ;

INCLUDE ttester-xf.fs
INCLUDE xtester-errors.fs
INCLUDE ftester-errors.fs
decimal

\ *** MORE USER CONFIG

:  HAS-QUIETING  ( -- flag )
(
To add signaling nan quieting tests for native fp words for your system,
uncomment the appropriate line below.
)
  USE-NATIVE 0=
\ [ GFORTH-HOST ]  [IF] true or [THEN]
\ [ IFORTH-HOST ]  [IF] true or [THEN]
\ [ PFE-HOST ]     [IF] true or [THEN]
\ [ VFX-HOST ]     [IF] true or [THEN]
\ [ UNKNOWN-HOST ] [IF] true or [THEN]
  ;

\ *** REPORTS

?.first-cr
?." Testing uses reference definitions until switched.

TESTER-USE-REF-F~ [IF]
  :noname 0e F~ ; FT-TEST=-XT !
  ?." The tester itself uses the reference F~.
[ELSE]
  ?." The tester itself uses the Forth host F~.
[THEN] 

?." An address unit is " bits/au . ?." bits.
?." There are " bits/cell .  ?." bits/cell.
?." There are " bits/float . ?." bits/float.
LITTLE-ENDIAN?
[IF]   ?." Integer data in memory is little-endian.
[ELSE] ?." Integer data in memory is big-endian.
[THEN]
FLITTLE-ENDIAN?
[IF]   ?." Float data in memory is little-endian.
[ELSE] ?." Float data in memory is big-endian.
[THEN]

:noname  ( -- fp.separate? )  depth >r 1e depth >r fdrop 2r> = ; execute
?." The floating-point stack is "
[IF] ?.( *separate*) [ELSE] ?.( *not separate*) [THEN]
?."  from the data stack.

: ?.errors  ( -- )  ?.xt-errors s"     " ?type ?.ft-errors ?.cr ;

\ *** FCONSTANTS

+max-qnan-raw raw>f FCONSTANT +tmax-qnan
-max-qnan-raw raw>f FCONSTANT -tmax-qnan
+min-qnan-raw raw>f FCONSTANT +tmin-qnan
-min-qnan-raw raw>f FCONSTANT -tmin-qnan
+max-snan-raw raw>f FCONSTANT +tmax-snan
-max-snan-raw raw>f FCONSTANT -tmax-snan
+min-snan-raw raw>f FCONSTANT +tmin-snan
-min-snan-raw raw>f FCONSTANT -tmin-snan
+inf-raw      raw>f FCONSTANT +tinf
-inf-raw      raw>f FCONSTANT -tinf
+max-n-raw    raw>f FCONSTANT +tmax-n
-max-n-raw    raw>f FCONSTANT -tmax-n
+min-n-raw    raw>f FCONSTANT +tmin-n
-min-n-raw    raw>f FCONSTANT -tmin-n
+max-subn-raw raw>f FCONSTANT +tmax-subn
-max-subn-raw raw>f FCONSTANT -tmax-subn
+min-subn-raw raw>f FCONSTANT +tmin-subn
-min-subn-raw raw>f FCONSTANT -tmin-subn
+0-raw        raw>f FCONSTANT +t0
-0-raw        raw>f FCONSTANT -t0

\ *** TESTS

TESTING #LZB 2#LZB 4#LZB

t{ 1 bits/cell 1 - lshift #LZB -> 0 }t
t{ 3 bits/cell 2 - lshift #LZB -> 0 }t
t{ -1                     #LZB -> 0 }t
t{ 3 bits/cell 3 - lshift #LZB -> 1 }t
t{ 3                      #LZB -> bits/cell 2 - }t
t{ 1                      #LZB -> bits/cell 1 - }t
t{ 0                      #LZB -> bits/cell }t

t{ 0 1 bits/cell 1 - lshift 2#LZB -> 0 }t
t{ 0 1 bits/cell 2 - lshift 2#LZB -> 1 }t
t{ 0 1                      2#LZB -> bits/cell 1 - }t
t{ 1 bits/cell 1 - lshift 0 2#LZB -> bits/cell }t
t{ 1 bits/cell 2 - lshift 0 2#LZB -> bits/cell 1+ }t
t{ 1 0 2#LZB -> bits/cell 2* 1- }t
t{ 0 0 2#LZB -> bits/cell 2* }t

t{ 0 0 0 1 bits/cell 1-  lshift 4#LZB -> 0 }t
t{ 0 0 0 1 bits/cell 2 - lshift 4#LZB -> 1 }t
t{ 0 0 0 1                      4#LZB -> bits/cell 1- }t
t{ 0 0 1 bits/cell 1- lshift 0  4#LZB -> bits/cell }t
t{ 0 0 1 0                      4#LZB -> bits/cell 2* 1- }t
t{ 0 1 bits/cell 1- lshift 0 0  4#LZB -> bits/cell 2* }t
t{ 0 1 0 0                      4#LZB -> bits/cell 3 * 1- }t
t{ 1 bits/cell 1- lshift 0 0 0  4#LZB -> bits/cell 3 * }t
t{ 1 0 0 0                      4#LZB -> bits/cell 4 * 1- }t
t{ 0 0 0 0                      4#LZB -> bits/cell 4 * }t

TESTING RAW-NEGATE RAW= |RAW|

t{  1e f>raw raw-negate raw>f -> -1e }t
t{ -1e f>raw raw-negate raw>f ->  1e }t

t{ +inf-raw raw-negate -> -inf-raw }t
t{ 1e 0e f/ f>raw      -> +inf-raw }t

t{ +max-qnan-raw raw-negate -> -max-qnan-raw }t
t{ +min-qnan-raw raw-negate -> -min-qnan-raw }t
t{ +max-snan-raw raw-negate -> -max-snan-raw }t
t{ +min-snan-raw raw-negate -> -min-snan-raw }t
t{ +inf-raw      raw-negate -> -inf-raw }t
t{ +max-n-raw    raw-negate -> -max-n-raw }t
t{ +min-n-raw    raw-negate -> -min-n-raw }t
t{ +max-subn-raw raw-negate -> -max-subn-raw }t
t{ +min-subn-raw raw-negate -> -min-subn-raw }t
t{ +0-raw        raw-negate -> -0-raw }t
 
t{ +max-n-raw    +max-n-raw    raw= -> true }t
t{ +max-n-raw    -max-n-raw    raw= -> false }t
t{ -max-subn-raw -max-subn-raw raw= -> true }t
t{ +min-subn-raw -max-n-raw    raw= -> false }t

t{ +max-qnan-raw +max-qnan-raw raw= -> true }t
t{ -min-snan-raw +inf-raw      raw= -> false }t
t{ +inf-raw      -inf-raw      raw= -> false }t
t{ +0-raw        -0-raw        raw= -> false }t

t{ -1e f>raw |raw| raw>f ->  1e }t
t{  1e f>raw |raw| raw>f ->  1e }t

t{ +min-qnan-raw |raw| -> +min-qnan-raw }t
t{ -min-qnan-raw |raw| -> +min-qnan-raw }t
t{ +0-raw        |raw| -> +0-raw }t
t{ -0-raw        |raw| -> +0-raw }t

TESTING RAW-FRAC-#LZB RAW-EXP RAW-QUIET

t{ +max-subn-raw raw-frac-#lzb -> 0 }t
t{ +min-subn-raw raw-frac-#lzb -> prec 2 - }t
t{ -max-subn-raw raw-frac-#lzb -> 0 }t
t{ -min-subn-raw raw-frac-#lzb -> prec 2 - }t

t{ +max-qnan-raw raw-exp -> emax 1+ }t
t{ -max-qnan-raw raw-exp -> emax 1+ }t
t{ +inf-raw      raw-exp -> emax 1+ }t
t{ -inf-raw      raw-exp -> emax 1+ }t
t{ +max-n-raw    raw-exp -> emax }t
t{ -max-n-raw    raw-exp -> emax }t
t{  1e f>raw     raw-exp -> 0 }t
t{ -1e f>raw     raw-exp -> 0 }t
t{ +max-subn-raw raw-exp -> emin 1- }t
t{ -max-subn-raw raw-exp -> emin 1- }t
t{ +min-subn-raw raw-exp -> emin 1- }t
t{ -min-subn-raw raw-exp -> emin 1- }t
t{ +0-raw        raw-exp -> emin 1- }t
t{ -0-raw        raw-exp -> emin 1- }t

\ Passing these tests supports the conjecture that F+ with one nan and
\ one extended number input produces the nan simply quieted.
t{ +max-snan-raw raw>f  0.0e f+ f>raw -> +max-snan-raw raw-quiet }t
t{ +min-snan-raw raw>f  0.0e f+ f>raw -> +min-snan-raw raw-quiet }t
t{ -max-snan-raw raw>f  0.0e f+ f>raw -> -max-snan-raw raw-quiet }t
t{ -min-snan-raw raw>f  0.0e f+ f>raw -> -min-snan-raw raw-quiet }t
t{ +max-qnan-raw raw>f  0.0e f+ f>raw -> +max-qnan-raw }t
t{ +min-qnan-raw raw>f  0.0e f+ f>raw -> +min-qnan-raw }t
t{ -max-qnan-raw raw>f  0.0e f+ f>raw -> -max-qnan-raw }t
t{ -min-qnan-raw raw>f  0.0e f+ f>raw -> -min-qnan-raw }t
t{ +max-snan-raw raw>f +tinf f+ f>raw -> +max-snan-raw raw-quiet }t
t{ +max-snan-raw raw>f -tinf f+ f>raw -> +max-snan-raw raw-quiet }t

?USE-NATIVE{
TESTING FSIGNBIT
[UNDEFINED] FSIGNBIT [IF]
?." FSIGNBIT not defined, skipping these tests.
[ELSE]
t{  1e FSIGNBIT -> false }t
t{ -1e FSIGNBIT -> true }t
[THEN]

TESTING F0= FINFINITE? FFINITE? FSUBNORMAL? FNORMAL? FNAN? FQNAN? FSNAN?

\ PFE-HOST IFORTH-HOST or [IF] : FFINITE? FINITE? ; [THEN] 

t{ +tmax-qnan f0= -> false }t
t{ +tmin-qnan f0= -> false }t
t{ +tmax-snan f0= -> false }t
t{ +tmin-snan f0= -> false }t
t{ +tinf      f0= -> false }t
t{ +tmax-n    f0= -> false }t
t{ +tmin-n    f0= -> false }t
t{ +tmax-subn f0= -> false }t
t{ +tmin-subn f0= -> false }t
t{ +t0        f0= -> true }t

t{ -tmax-qnan f0= -> false }t
t{ -tmin-qnan f0= -> false }t
t{ -tmax-snan f0= -> false }t
t{ -tmin-snan f0= -> false }t
t{ -tinf      f0= -> false }t
t{ -tmax-n    f0= -> false }t
t{ -tmin-n    f0= -> false }t
t{ -tmax-subn f0= -> false }t
t{ -tmin-subn f0= -> false }t
t{ -t0        f0= -> true }t

[UNDEFINED] FINFINITE? [IF]
?." Skipping FINFINITE?, not defined.
[ELSE]
t{ +tmax-qnan finfinite? -> false }t
t{ +tmin-qnan finfinite? -> false }t
t{ +tmax-snan finfinite? -> false }t
t{ +tmin-snan finfinite? -> false }t
t{ +tinf      finfinite? -> true }t
t{ +tmax-n    finfinite? -> false }t
t{ +tmin-n    finfinite? -> false }t
t{ +tmax-subn finfinite? -> false }t
t{ +tmin-subn finfinite? -> false }t
t{ +t0        finfinite? -> false }t

t{ -tmax-qnan finfinite? -> false }t
t{ -tmin-qnan finfinite? -> false }t
t{ -tmax-snan finfinite? -> false }t
t{ -tmin-snan finfinite? -> false }t
t{ -tinf      finfinite? -> true }t
t{ -tmax-n    finfinite? -> false }t
t{ -tmin-n    finfinite? -> false }t
t{ -tmax-subn finfinite? -> false }t
t{ -tmin-subn finfinite? -> false }t
t{ -t0        finfinite? -> false }t

t{  1e        finfinite? -> false }t
t{ -1e        finfinite? -> false }t
t{  1e  0e f/ finfinite? -> true }t
t{ -1e  0e f/ finfinite? -> true }t
[THEN]  \ [UNDEFINED] FINFINITE?

[UNDEFINED] FFINITE? [IF]
?." Skipping FFINITE?, not defined.
[ELSE]
t{ +tmax-qnan ffinite? -> false }t
t{ +tmin-qnan ffinite? -> false }t
t{ +tmax-snan ffinite? -> false }t
t{ +tmin-snan ffinite? -> false }t
t{ +tinf      ffinite? -> false }t
t{ +tmax-n    ffinite? -> true }t
t{ +tmin-n    ffinite? -> true }t
t{ +tmax-subn ffinite? -> true }t
t{ +tmin-subn ffinite? -> true }t
t{ +t0        ffinite? -> true }t

t{ -tmax-qnan ffinite? -> false }t
t{ -tmin-qnan ffinite? -> false }t
t{ -tmax-snan ffinite? -> false }t
t{ -tmin-snan ffinite? -> false }t
t{ -tinf      ffinite? -> false }t
t{ -tmax-n    ffinite? -> true }t
t{ -tmin-n    ffinite? -> true }t
t{ -tmax-subn ffinite? -> true }t
t{ -tmin-subn ffinite? -> true }t
t{ -t0        ffinite? -> true }t
[THEN]  \ [UNDEFINED] FFINITE?

[UNDEFINED] FSUBNORMAL? [IF]
?." Skipping FSURNORMAL?, not defined.
[ELSE]
t{ +tmax-qnan fsubnormal? -> false }t
t{ +tmin-qnan fsubnormal? -> false }t
t{ +tmax-snan fsubnormal? -> false }t
t{ +tmin-snan fsubnormal? -> false }t
t{ +tinf      fsubnormal? -> false }t
t{ +tmax-n    fsubnormal? -> false }t
t{ +tmin-n    fsubnormal? -> false }t
t{ +tmax-subn fsubnormal? -> true }t
t{ +tmin-subn fsubnormal? -> true }t
t{ +t0        fsubnormal? -> false }t

t{ -tmax-qnan fsubnormal? -> false }t
t{ -tmin-qnan fsubnormal? -> false }t
t{ -tmax-snan fsubnormal? -> false }t
t{ -tmin-snan fsubnormal? -> false }t
t{ -tinf      fsubnormal? -> false }t
t{ -tmax-n    fsubnormal? -> false }t
t{ -tmin-n    fsubnormal? -> false }t
t{ -tmax-subn fsubnormal? -> true }t
t{ -tmin-subn fsubnormal? -> true }t
t{ -t0        fsubnormal? -> false }t
[THEN]  \ [UNDEFINED] FSUBNORMAL?

[UNDEFINED] FNORMAL? [IF]
?." Skipping FNORMAL?, not defined.
[ELSE]
t{ +tmax-qnan fnormal? -> false }t
t{ +tmin-qnan fnormal? -> false }t
t{ +tmax-snan fnormal? -> false }t
t{ +tmin-snan fnormal? -> false }t
t{ +tinf      fnormal? -> false }t
t{ +tmax-n    fnormal? -> true }t
t{ +tmin-n    fnormal? -> true }t
t{ +tmax-subn fnormal? -> false }t
t{ +tmin-subn fnormal? -> false }t
t{ +t0        fnormal? -> false }t
[THEN]  \ [UNDEFINED] FNORMAL?

[UNDEFINED] FNAN? [IF]
?." Skipping FNAN?, not defined.
[ELSE]
t{ +tmax-qnan fnan? -> true }t
t{ +tmin-qnan fnan? -> true }t
t{ +tmax-snan fnan? -> true }t
t{ +tmin-snan fnan? -> true }t
t{ +tinf      fnan? -> false }t
t{ +tmax-n    fnan? -> false }t
t{ +tmin-n    fnan? -> false }t
t{ +tmax-subn fnan? -> false }t
t{ +tmin-subn fnan? -> false }t
t{ +t0        fnan? -> false }t

t{ -tmax-qnan fnan? -> true }t
t{ -tmin-qnan fnan? -> true }t
t{ -tmax-snan fnan? -> true }t
t{ -tmin-snan fnan? -> true }t
t{ -tinf      fnan? -> false }t
t{ -tmax-n    fnan? -> false }t
t{ -tmin-n    fnan? -> false }t
t{ -tmax-subn fnan? -> false }t
t{ -tmin-subn fnan? -> false }t
t{ -t0        fnan? -> false }t
[THEN]  \ [UNDEFINED] FNAN?

[UNDEFINED] FQNAN? [IF]
?." Skipping FQNAN?, not defined.
[ELSE]
t{ +tmax-qnan fqnan? -> true }t
t{ +tmin-qnan fqnan? -> true }t
t{ +tmax-snan fqnan? -> false }t \ Fails if quieted by F@.
t{ +tmin-snan fqnan? -> false }t \ Fails if quieted by F@.
t{ +tinf      fqnan? -> false }t
t{ +tmax-n    fqnan? -> false }t
t{ +tmin-n    fqnan? -> false }t
t{ +tmax-subn fqnan? -> false }t
t{ +tmin-subn fqnan? -> false }t
t{ +t0        fqnan? -> false }t

t{ -tmax-qnan fqnan? -> true }t
t{ -tmin-qnan fqnan? -> true }t
t{ -tmax-snan fqnan? -> false }t \ Fails if quieted by F@.
t{ -tmin-snan fqnan? -> false }t \ Fails if quieted by F@.
t{ -tinf      fqnan? -> false }t
t{ -tmax-n    fqnan? -> false }t
t{ -tmin-n    fqnan? -> false }t
t{ -tmax-subn fqnan? -> false }t
t{ -tmin-subn fqnan? -> false }t
t{ -t0        fqnan? -> false }t

t{  1e                fqnan? -> false }t
t{ -1e                fqnan? -> false }t
t{  0e  0e f/         fqnan? -> true }t
t{  0e  0e f/ fnegate fqnan? -> true }t  \ fnegate is tested later
[THEN]  \ [UNDEFINED] FQNAN?

[UNDEFINED] FSNAN? [IF]
?." Skipping FSNAN?, not defined.
[ELSE]
?." If you do not see failed FSNAN? tests with sNaN inputs,
?." then F@ on an sNaN does not convert it to a qNAN.

t{ +tmax-qnan fsnan? -> false }t
t{ +tmin-qnan fsnan? -> false }t
t{ +tmax-snan fsnan? -> true }t \ Fails if quieted by F@.
t{ +tmin-snan fsnan? -> true }t \ Fails if quieted by F@.
t{ +tinf      fsnan? -> false }t
t{ +tmax-n    fsnan? -> false }t
t{ +tmin-n    fsnan? -> false }t
t{ +tmax-subn fsnan? -> false }t
t{ +tmin-subn fsnan? -> false }t
t{ +t0        fsnan? -> false }t

t{ -tmax-qnan fsnan? -> false }t
t{ -tmin-qnan fsnan? -> false }t
t{ -tmax-snan fsnan? -> true }t \ Fails if quieted by F@.
t{ -tmin-snan fsnan? -> true }t \ Fails if quieted by F@.
t{ -tinf      fsnan? -> false }t
t{ -tmax-n    fsnan? -> false }t
t{ -tmin-n    fsnan? -> false }t
t{ -tmax-subn fsnan? -> false }t
t{ -tmin-subn fsnan? -> false }t
t{ -t0        fsnan? -> false }t
[THEN]  \ [UNDEFINED] FSNAN?

TESTING FABS FNEGATE FCOPYSIGN

t{ -1e    FABS ->  1e }t
t{ -t0    FABS -> +t0 }t
t{ -tinf  FABS -> +tinf }t
t{ -tmin-qnan FABS -> +tmin-qnan }t

t{  1e    FABS ->  1e }t
t{ +t0    FABS -> +t0 }t
t{ +tinf  FABS -> +tinf }t
t{ +tmin-qnan FABS -> +tmin-qnan }t

t{ -1e    FNEGATE ->  1e }t
t{ -t0    FNEGATE -> +t0 }t
t{ -tinf  FNEGATE -> +tinf }t
t{ -tmin-qnan FNEGATE -> +tmin-qnan }t

t{  1e    FNEGATE ->  -1e }t
t{ +t0    FNEGATE -> -t0 }t
t{ +tinf  FNEGATE -> -tinf }t
t{ +tmin-qnan FNEGATE -> -tmin-qnan }t

[UNDEFINED] FCOPYSIGN [IF]
?." FCOPYSIGN not defined, skipping test.
[ELSE]
t{  1e     1e FCOPYSIGN ->  1e }t
t{ +t0     1e FCOPYSIGN -> +t0 }t
t{ +tinf   1e FCOPYSIGN -> +tinf }t
t{ +tmin-qnan  1e FCOPYSIGN -> +tmin-qnan }t

t{ -1e     1e FCOPYSIGN ->  1e }t
t{ -t0     1e FCOPYSIGN -> +t0 }t
t{ -tinf   1e FCOPYSIGN -> +tinf }t
t{ -tmin-qnan  1e FCOPYSIGN -> +tmin-qnan }t

t{  1e    -1e FCOPYSIGN -> -1e }t
t{ +t0    -1e FCOPYSIGN -> -t0 }t
t{ +tinf  -1e FCOPYSIGN -> -tinf }t
t{ +tmin-qnan -1e FCOPYSIGN -> -tmin-qnan }t

t{ -1e    -1e FCOPYSIGN -> -1e }t
t{ -t0    -1e FCOPYSIGN -> -t0 }t
t{ -tinf  -1e FCOPYSIGN -> -tinf }t
t{ -tmin-qnan -1e FCOPYSIGN -> -tmin-qnan }t

t{  1e    +t0 FCOPYSIGN ->  1e }t
t{ +t0    +t0 FCOPYSIGN -> +t0 }t
t{ +tinf  +t0 FCOPYSIGN -> +tinf }t
t{ +tmin-qnan +t0 FCOPYSIGN -> +tmin-qnan }t

t{ -1e    +t0 FCOPYSIGN ->  1e }t
t{ -t0    +t0 FCOPYSIGN -> +t0 }t
t{ -tinf  +t0 FCOPYSIGN -> +tinf }t
t{ -tmin-qnan +t0 FCOPYSIGN -> +tmin-qnan }t

t{  1e    -t0 FCOPYSIGN -> -1e }t
t{ +t0    -t0 FCOPYSIGN -> -t0 }t
t{ +tinf  -t0 FCOPYSIGN -> -tinf }t
t{ +tmin-qnan -t0 FCOPYSIGN -> -tmin-qnan }t

t{ -1e    -t0 FCOPYSIGN -> -1e }t
t{ -t0    -t0 FCOPYSIGN -> -t0 }t
t{ -tinf  -t0 FCOPYSIGN -> -tinf }t
t{ -tmin-qnan -t0 FCOPYSIGN -> -tmin-qnan }t

t{  1e    +tinf FCOPYSIGN ->  1e }t
t{ +t0    +tinf FCOPYSIGN -> +t0 }t
t{ +tinf  +tinf FCOPYSIGN -> +tinf }t
t{ +tmin-qnan +tinf FCOPYSIGN -> +tmin-qnan }t

t{ -1e    +tinf FCOPYSIGN ->  1e }t
t{ -t0    +tinf FCOPYSIGN -> +t0 }t
t{ -tinf  +tinf FCOPYSIGN -> +tinf }t
t{ -tmin-qnan +tinf FCOPYSIGN -> +tmin-qnan }t

t{  1e    -tinf FCOPYSIGN -> -1e }t
t{ +t0    -tinf FCOPYSIGN -> -t0 }t
t{ +tinf  -tinf FCOPYSIGN -> -tinf }t
t{ +tmin-qnan -tinf FCOPYSIGN -> -tmin-qnan }t

t{ -1e    -tinf FCOPYSIGN -> -1e }t
t{ -t0    -tinf FCOPYSIGN -> -t0 }t
t{ -tinf  -tinf FCOPYSIGN -> -tinf }t
t{ -tmin-qnan -tinf FCOPYSIGN -> -tmin-qnan }t

t{  1e    +tmin-qnan FCOPYSIGN ->  1e }t
t{ +t0    +tmin-qnan FCOPYSIGN -> +t0 }t
t{ +tinf  +tmin-qnan FCOPYSIGN -> +tinf }t
t{ +tmin-qnan +tmin-qnan FCOPYSIGN -> +tmin-qnan }t

t{ -1e    +tmin-qnan FCOPYSIGN ->  1e }t
t{ -t0    +tmin-qnan FCOPYSIGN -> +t0 }t
t{ -tinf  +tmin-qnan FCOPYSIGN -> +tinf }t
t{ -tmin-qnan +tmin-qnan FCOPYSIGN -> +tmin-qnan }t

t{  1e    -tmin-qnan FCOPYSIGN -> -1e }t
t{ +t0    -tmin-qnan FCOPYSIGN -> -t0 }t
t{ +tinf  -tmin-qnan FCOPYSIGN -> -tinf }t
t{ +tmin-qnan -tmin-qnan FCOPYSIGN -> -tmin-qnan }t

t{ -1e    -tmin-qnan FCOPYSIGN -> -1e }t
t{ -t0    -tmin-qnan FCOPYSIGN -> -t0 }t
t{ -tinf  -tmin-qnan FCOPYSIGN -> -tinf }t
t{ -tmin-qnan -tmin-qnan FCOPYSIGN -> -tmin-qnan }t
[THEN]  \ [UNDEFINED] FCOPYSIGN

TESTING F<
(
Add corner tests for <finite> <finite> F< ?

The following uses only one of the nans.  It assumes that nan appears in
the reference implementation of the comparisons only through FNAN?, and
that FNAN? is correct.
)

t{  17e   17e  F< -> false }t
t{ -17e  -17e  F< -> false }t

t{ +tmin-qnan +tmin-qnan F< -> false }t
t{ +tinf      +tinf      F< -> false }t
t{ -tinf      -tinf      F< -> false }t

t{ +tmin-qnan +tinf F< -> false }t
t{ +tmin-qnan -tinf F< -> false }t
t{ +tmin-qnan  17e  F< -> false }t
t{ -tinf      +tinf F< -> true  }t
t{  17e       +tinf F< -> true  }t
t{ -17e       -tinf F< -> false }t

t{ +tinf +tmin-qnan F< -> false }t
t{ -tinf +tmin-qnan F< -> false }t
t{  17e  +tmin-qnan F< -> false }t
t{ +tinf -tinf      F< -> false }t
t{ +tinf  17e       F< -> false }t
t{ -tinf -17e       F< -> true  }t

t{ -t0 -t0 F< -> false }t
t{ -t0 -t0 F< -> false }t
t{ -t0 -t0 F< -> false }t
t{ -t0 -t0 F< -> false }t

t{ -t0  +17e F< -> true }t
t{ -t0  +17e F< -> true }t
t{ -t0  -17e F< -> false }t
t{ -t0  -17e F< -> false }t
t{ +17e -t0  F< -> false }t
t{ -17e -t0  F< -> true }t

t{ -t0    +tmin-qnan F< -> false }t
t{ -t0    +tmin-qnan F< -> false }t
t{ +tmin-qnan -t0    F< -> false }t
t{ +tmin-qnan -t0    F< -> false }t

t{ -t0   +tinf F< -> true  }t
t{ -t0   +tinf F< -> true  }t
t{ +tinf -t0   F< -> false }t
t{ +tinf -t0   F< -> false }t

t{ -t0   -tinf F< -> false }t
t{ -t0   -tinf F< -> false }t
t{ -tinf -t0   F< -> true  }t
t{ -tinf -t0   F< -> true  }t

TESTING F>
(
The following is independent of the F< tests.  It uses the same inputs
but replaces the goals.  If F> is implemented by FSWAP F<, the theorem
that they are equivalent is also tested.
)

t{  17e  17e F> -> false }t
t{ -17e -17e F> -> false }t

t{ +tmin-qnan +tmin-qnan F> -> false }t
t{ +tinf      +tinf      F> -> false }t
t{ -tinf      -tinf      F> -> false }t

t{ +tmin-qnan +tinf F> -> false }t
t{ +tmin-qnan -tinf F> -> false }t
t{ +tmin-qnan  17e  F> -> false }t
t{ -tinf      +tinf F> -> false }t
t{  17e       +tinf F> -> false }t
t{ -17e       -tinf F> -> true  }t

t{ +tinf +tmin-qnan F> -> false }t
t{ -tinf +tmin-qnan F> -> false }t
t{  17e  +tmin-qnan F> -> false }t
t{ +tinf -tinf      F> -> true  }t
t{ +tinf  17e       F> -> true  }t
t{ -tinf -17e       F> -> false }t

t{ -t0 -t0 F> -> false }t
t{ -t0 -t0 F> -> false }t
t{ -t0 -t0 F> -> false }t
t{ -t0 -t0 F> -> false }t

t{ -t0  +17e  F> -> false }t
t{ -t0  +17e  F> -> false }t
t{ -t0  -17e  F> -> true  }t
t{ -t0  -17e  F> -> true  }t
t{ +17e -t0   F> -> true  }t
t{ -17e -t0   F> -> false }t

t{ -t0    +tmin-qnan F> -> false }t
t{ -t0    +tmin-qnan F> -> false }t
t{ +tmin-qnan -t0    F> -> false }t
t{ +tmin-qnan -t0    F> -> false }t

t{ -t0   +tinf F> -> false }t
t{ -t0   +tinf F> -> false }t
t{ +tinf -t0   F> -> true  }t
t{ +tinf -t0   F> -> true }t

t{ -t0   -tinf F> -> true  }t
t{ -t0   -tinf F> -> true  }t
t{ -tinf -t0   F> -> false }t
t{ -tinf -t0   F> -> false }t

TESTING F=

t{  17e  17e F= -> true  }t
t{ -17e -17e F= -> true  }t

t{ +tmin-qnan +tmin-qnan F= -> false }t
t{ +tinf      +tinf      F= -> true }t
t{ -tinf      -tinf      F= -> true }t

t{ +tmin-qnan +tinf F= -> false }t
t{ +tmin-qnan -tinf F= -> false }t
t{ +tmin-qnan  17e  F= -> false }t
t{ -tinf      +tinf F= -> false }t
t{  17e       +tinf F= -> false }t
t{ -17e       -tinf F= -> false }t

t{ +tinf +tmin-qnan F= -> false }t
t{ -tinf +tmin-qnan F= -> false }t
t{  17e  +tmin-qnan F= -> false }t
t{ +tinf -tinf      F= -> false }t
t{ +tinf  17e       F= -> false }t
t{ -tinf -17e       F= -> false }t

t{ -t0 -t0 F= -> true  }t
t{ -t0 -t0 F= -> true  }t
t{ -t0 -t0 F= -> true  }t
t{ -t0 -t0 F= -> true  }t

t{ -t0  +17e F= -> false }t
t{ -t0  +17e F= -> false }t
t{ -t0  -17e F= -> false }t
t{ -t0  -17e F= -> false }t
t{ +17e -t0  F= -> false }t
t{ -17e -t0  F= -> false }t

t{ -t0    +tmin-qnan F= -> false }t
t{ -t0    +tmin-qnan F= -> false }t
t{ +tmin-qnan -t0    F= -> false }t
t{ +tmin-qnan -t0    F= -> false }t

t{ -t0   +tinf F= -> false }t
t{ -t0   +tinf F= -> false }t
t{ +tinf -t0   F= -> false }t
t{ +tinf -t0   F= -> false }t

t{ -t0  -tinf F= -> false }t
t{ -t0  -tinf F= -> false }t
t{ -tinf -t0  F= -> false }t
t{ -tinf -t0  F= -> false }t

TESTING F<=

t{  17e  17e F<= -> true  }t
t{ -17e -17e F<= -> true  }t

t{ +tmin-qnan +tmin-qnan F<= -> false }t
t{ +tinf +tinf F<= -> true }t
t{ -tinf -tinf F<= -> true }t

t{ +tmin-qnan +tinf F<= -> false }t
t{ +tmin-qnan -tinf F<= -> false }t
t{ +tmin-qnan  17e  F<= -> false }t
t{ -tinf      +tinf F<= -> true  }t
t{  17e       +tinf F<= -> true  }t
t{ -17e       -tinf F<= -> false }t

t{ +tinf +tmin-qnan F<= -> false }t
t{ -tinf +tmin-qnan F<= -> false }t
t{  17e  +tmin-qnan F<= -> false }t
t{ +tinf -tinf      F<= -> false }t
t{ +tinf  17e       F<= -> false }t
t{ -tinf -17e       F<= -> true  }t

t{ -t0 -t0 F<= -> true  }t
t{ -t0 -t0 F<= -> true  }t
t{ -t0 -t0 F<= -> true  }t
t{ -t0 -t0 F<= -> true  }t

t{ -t0  +17e F<= -> true  }t
t{ -t0  +17e F<= -> true  }t
t{ -t0  -17e F<= -> false }t
t{ -t0  -17e F<= -> false }t
t{ +17e -t0  F<= -> false }t
t{ -17e -t0  F<= -> true  }t

t{ -t0    +tmin-qnan F<= -> false }t
t{ -t0    +tmin-qnan F<= -> false }t
t{ +tmin-qnan -t0    F<= -> false }t
t{ +tmin-qnan -t0    F<= -> false }t

t{ -t0   +tinf F<= -> true  }t
t{ -t0   +tinf F<= -> true  }t
t{ +tinf -t0   F<= -> false }t
t{ +tinf -t0   F<= -> false }t

t{ -t0   -tinf F<= -> false }t
t{ -t0   -tinf F<= -> false }t
t{ -tinf -t0   F<= -> true  }t
t{ -tinf -t0   F<= -> true  }t

TESTING F>=

t{  17e  17e F>= -> true  }t
t{ -17e -17e F>= -> true  }t

t{ +tmin-qnan +tmin-qnan F>= -> false }t
t{ +tinf      +tinf      F>= -> true  }t
t{ -tinf      -tinf      F>= -> true  }t

t{ +tmin-qnan +tinf F>= -> false }t
t{ +tmin-qnan -tinf F>= -> false }t
t{ +tmin-qnan  17e  F>= -> false }t
t{ -tinf      +tinf F>= -> false }t
t{  17e       +tinf F>= -> false }t
t{ -17e       -tinf F>= -> true  }t

t{ +tinf +tmin-qnan F>= -> false }t
t{ -tinf +tmin-qnan F>= -> false }t
t{  17e  +tmin-qnan F>= -> false }t
t{ +tinf -tinf      F>= -> true  }t
t{ +tinf  17e       F>= -> true  }t
t{ -tinf -17e       F>= -> false }t

t{ -t0 -t0 F>= -> true  }t
t{ -t0 -t0 F>= -> true  }t
t{ -t0 -t0 F>= -> true  }t
t{ -t0 -t0 F>= -> true  }t

t{ -t0  +17e F>= -> false }t
t{ -t0  +17e F>= -> false }t
t{ -t0  -17e F>= -> true  }t
t{ -t0  -17e F>= -> true  }t
t{ +17e -t0  F>= -> true  }t
t{ -17e -t0  F>= -> false }t

t{ -t0     +tmin-qnan F>= -> false }t
t{ -t0     +tmin-qnan F>= -> false }t
t{  +tmin-qnan -t0    F>= -> false }t
t{  +tmin-qnan -t0    F>= -> false }t

t{ -t0   +tinf F>= -> false }t
t{ -t0   +tinf F>= -> false }t
t{ +tinf -t0   F>= -> true  }t
t{ +tinf -t0   F>= -> true }t

t{ -t0   -tinf F>= -> true  }t
t{ -t0   -tinf F>= -> true  }t
t{ -tinf -t0   F>= -> false }t
t{ -tinf -t0   F>= -> false }t

}?USE-NATIVE

TESTING FDATUM= FABSDIFF<

t{ 1e 0e FDATUM= -> false }t
t{ 0e 1e FDATUM= -> false }t
t{ 1e 1e FDATUM= -> true }t

t{ +t0 +t0 FDATUM= -> true }t
t{ +t0 -t0 FDATUM= -> false }t
t{ -t0 +t0 FDATUM= -> false }t
t{ -t0 -t0 FDATUM= -> true }t

t{ +tinf +tinf FDATUM= -> true }t
t{ +tinf -tinf FDATUM= -> false }t
t{ -tinf +tinf FDATUM= -> false }t
t{ -tinf -tinf FDATUM= -> true }t

t{ +tmin-qnan +tmin-qnan FDATUM= -> true }t
t{ +tmin-qnan -tmin-qnan FDATUM= -> false }t
t{ -tmin-qnan +tmin-qnan FDATUM= -> false }t
t{ -tmin-qnan -tmin-qnan FDATUM= -> true }t

t{ +tmin-subn +t0 FDATUM= -> false }t

t{ 0e 1e  0.5e   FABSDIFF< -> false }t
t{ 0e 1e -0.5e   FABSDIFF< -> false }t
t{ 0e 1e  1.001e FABSDIFF< -> true }t
t{ 0e 1e -1.001e FABSDIFF< -> false }t
t{ 1e 0e  1.001e FABSDIFF< -> true }t
t{ 1e 0e -1.001e FABSDIFF< -> false }t

t{  0e         1e        -tmin-qnan FABSDIFF< -> false }t
t{  0e        -tmin-qnan  1.001e    FABSDIFF< -> false }t
t{ -tmin-qnan  1e         1.001e    FABSDIFF< -> false }t

t{ +tmin-qnan  1e        +tmin-qnan FABSDIFF< -> false }t
t{  1e        +tmin-qnan +tmin-qnan FABSDIFF< -> false }t
t{ +tmin-qnan -tmin-qnan  1.001e    FABSDIFF< -> false }t

t{ +tmin-qnan -tmin-qnan +tmin-qnan FABSDIFF< -> false }t

t{  0e    1e   +tinf   FABSDIFF< -> true }t
t{  0e    1e   -tinf   FABSDIFF< -> false }t
t{  0e   -tinf  1.001e FABSDIFF< -> false }t
t{ -tinf  1e    1.001e FABSDIFF< -> false }t

t{ +tinf  1e   +tinf   FABSDIFF< -> false }t
t{  1e   +tinf +tinf   FABSDIFF< -> false }t
t{ +tinf -tinf  1.001e FABSDIFF< -> false }t

t{ +tinf -tinf +tinf FABSDIFF< -> false }t

t{  0e        +tmin-qnan +tinf FABSDIFF< -> false }t
t{ -tmin-qnan  1e        +tinf FABSDIFF< -> false }t

?USE-NATIVE{
TESTING F~ exact tolerance

t{ +t0 +t0 +t0 F~ -> true }t
t{ +t0 -t0 +t0 F~ -> false }t
t{ -t0 +t0 +t0 F~ -> false }t
t{ -t0 -t0 +t0 F~ -> true }t

t{  7e -2e +t0 F~ -> false }t
t{ -2e  7e +t0 F~ -> false }t
t{  7e  7e +t0 F~ -> true }t
   
t{  7e   +tinf +t0 F~ -> false }t
t{ +tinf  7e   +t0 F~ -> false }t
t{  7e   -tinf +t0 F~ -> false }t
t{ -tinf  7e   +t0 F~ -> false }t

t{ +tinf +tinf +t0 F~ -> true }t
t{ +tinf -tinf +t0 F~ -> false }t
t{ -tinf +tinf +t0 F~ -> false }t
t{ -tinf -tinf +t0 F~ -> true }t

t{ +tmin-qnan  7e    +t0 F~ -> false }t
t{ -tmin-qnan  7e    +t0 F~ -> false }t
t{  7e    +tmin-qnan +t0 F~ -> false }t
t{  7e    -tmin-qnan +t0 F~ -> false }t

t{ +tmin-qnan +tmin-qnan +t0 F~ -> true }t
t{ -tmin-qnan +tmin-qnan +t0 F~ -> false }t
t{ +tmin-qnan -tmin-qnan +t0 F~ -> false }t
t{ -tmin-qnan -tmin-qnan +t0 F~ -> true }t

t{ +tinf +tmin-qnan +t0 F~ -> false }t
t{ -tinf +tmin-qnan +t0 F~ -> false }t
t{ +tinf -tmin-qnan +t0 F~ -> false }t
t{ -tinf -tmin-qnan +t0 F~ -> false }t

t{ +tmin-qnan +tinf +t0 F~ -> false }t
t{ -tmin-qnan +tinf +t0 F~ -> false }t
t{ +tmin-qnan -tinf +t0 F~ -> false }t
t{ -tmin-qnan -tinf +t0 F~ -> false }t

t{ +t0 +t0 -t0 F~ -> true }t
t{ +t0 -t0 -t0 F~ -> false }t
t{ -t0 +t0 -t0 F~ -> false }t
t{ -t0 -t0 -t0 F~ -> true }t

t{  7e -2e -t0 F~ -> false }t
t{ -2e  7e -t0 F~ -> false }t
t{  7e  7e -t0 F~ -> true }t

t{  7e   +tinf -t0 F~ -> false }t
t{ +tinf  7e   -t0 F~ -> false }t
t{  7e   -tinf -t0 F~ -> false }t
t{ -tinf  7e   -t0 F~ -> false }t

t{ +tinf -tinf -t0 F~ -> false }t
t{ -tinf +tinf -t0 F~ -> false }t
t{ -tinf -tinf -t0 F~ -> true }t
t{ +tinf +tinf -t0 F~ -> true }t

t{ +tmin-qnan  7e    -t0 F~ -> false }t
t{ -tmin-qnan  7e    -t0 F~ -> false }t
t{  7e    +tmin-qnan -t0 F~ -> false }t
t{  7e    -tmin-qnan -t0 F~ -> false }t

t{ +tmin-qnan +tmin-qnan -t0 F~ -> true }t
t{ -tmin-qnan +tmin-qnan -t0 F~ -> false }t
t{ +tmin-qnan -tmin-qnan -t0 F~ -> false }t
t{ -tmin-qnan -tmin-qnan -t0 F~ -> true }t

t{ +tinf +tmin-qnan -t0 F~ -> false }t
t{ -tinf +tmin-qnan -t0 F~ -> false }t
t{ +tinf -tmin-qnan -t0 F~ -> false }t
t{ -tinf -tmin-qnan -t0 F~ -> false }t

t{ +tmin-qnan +tinf -t0 F~ -> false }t
t{ -tmin-qnan +tinf -t0 F~ -> false }t
t{ +tmin-qnan -tinf -t0 F~ -> false }t
t{ -tmin-qnan -tinf -t0 F~ -> false }t

TESTING F~ absolute tolerance

t{ +t0 +t0  7e F~ -> true }t
t{ +t0 -t0  7e F~ -> true }t
t{ -t0 +t0  7e F~ -> true }t
t{ -t0 -t0  7e F~ -> true }t

t{  7e   +tinf  7e F~ -> false }t
t{ +tinf  7e    7e F~ -> false }t
t{  7e   -tinf  7e F~ -> false }t
t{ -tinf  7e    7e F~ -> false }t

t{ +tinf +tinf  7e F~ -> false }t
t{ +tinf -tinf  7e F~ -> false }t
t{ -tinf +tinf  7e F~ -> false }t
t{ -tinf -tinf  7e F~ -> false }t

t{ +tmin-qnan  7e    7e F~ -> false }t
t{ -tmin-qnan  7e    7e F~ -> false }t
t{  7e    +tmin-qnan 7e F~ -> false }t
t{  7e    -tmin-qnan 7e F~ -> false }t

t{ +tmin-qnan +tmin-qnan  7e F~ -> false }t
t{ -tmin-qnan +tmin-qnan  7e F~ -> false }t
t{ +tmin-qnan -tmin-qnan  7e F~ -> false }t
t{ -tmin-qnan -tmin-qnan  7e F~ -> false }t

t{ +tinf +tmin-qnan  7e F~ -> false }t
t{ -tinf +tmin-qnan  7e F~ -> false }t
t{ +tinf -tmin-qnan  7e F~ -> false }t
t{ -tinf -tmin-qnan  7e F~ -> false }t

t{ +tmin-qnan +tinf  7e F~ -> false }t
t{ -tmin-qnan +tinf  7e F~ -> false }t
t{ +tmin-qnan -tinf  7e F~ -> false }t
t{ -tmin-qnan -tinf  7e F~ -> false }t

t{ +t0 +t0 +tinf F~ -> true }t
t{ +t0 -t0 +tinf F~ -> true }t
t{ -t0 +t0 +tinf F~ -> true }t
t{ -t0 -t0 +tinf F~ -> true }t

t{  7e -2e +tinf F~ -> true }t
t{ -2e  7e +tinf F~ -> true }t
t{  7e  7e +tinf F~ -> true }t

t{  7e   +tinf +tinf F~ -> false }t
t{ +tinf  7e   +tinf F~ -> false }t
t{  7e   -tinf +tinf F~ -> false }t
t{ -tinf  7e   +tinf F~ -> false }t

t{ +tinf +tinf +tinf F~ -> false }t
t{ +tinf -tinf +tinf F~ -> false }t
t{ -tinf +tinf +tinf F~ -> false }t
t{ -tinf -tinf +tinf F~ -> false }t

t{ +tmin-qnan  7e    +tinf F~ -> false }t
t{ -tmin-qnan  7e    +tinf F~ -> false }t
t{  7e    +tmin-qnan +tinf F~ -> false }t
t{  7e    -tmin-qnan +tinf F~ -> false }t

t{ +tmin-qnan +tmin-qnan +tinf F~ -> false }t
t{ -tmin-qnan +tmin-qnan +tinf F~ -> false }t
t{ +tmin-qnan -tmin-qnan +tinf F~ -> false }t
t{ -tmin-qnan -tmin-qnan +tinf F~ -> false }t

t{ +tinf +tmin-qnan +tinf F~ -> false }t
t{ -tinf +tmin-qnan +tinf F~ -> false }t
t{ +tinf -tmin-qnan +tinf F~ -> false }t
t{ -tinf -tmin-qnan +tinf F~ -> false }t

t{ +tmin-qnan +tinf +tinf F~ -> false }t
t{ -tmin-qnan +tinf +tinf F~ -> false }t
t{ +tmin-qnan -tinf +tinf F~ -> false }t
t{ -tmin-qnan -tinf +tinf F~ -> false }t

TESTING F~ relative tolerance

t{ +t0 +t0 -7e F~ -> false }t
t{ +t0 -t0 -7e F~ -> false }t
t{ -t0 +t0 -7e F~ -> false }t
t{ -t0 -t0 -7e F~ -> false }t

t{  7e   +tinf -7e F~ -> false }t
t{ +tinf  7e   -7e F~ -> false }t
t{  7e   -tinf -7e F~ -> false }t
t{ -tinf  7e   -7e F~ -> false }t

t{ +tinf +tinf -7e F~ -> false }t
t{ +tinf -tinf -7e F~ -> false }t
t{ -tinf +tinf -7e F~ -> false }t
t{ -tinf -tinf -7e F~ -> false }t

t{ +tmin-qnan  7e    -7e F~ -> false }t
t{ -tmin-qnan  7e    -7e F~ -> false }t
t{  7e    +tmin-qnan -7e F~ -> false }t
t{  7e    -tmin-qnan -7e F~ -> false }t

t{ +tmin-qnan +tmin-qnan -7e F~ -> false }t
t{ -tmin-qnan +tmin-qnan -7e F~ -> false }t
t{ +tmin-qnan -tmin-qnan -7e F~ -> false }t
t{ -tmin-qnan -tmin-qnan -7e F~ -> false }t

t{ +tinf +tmin-qnan -7e F~ -> false }t
t{ -tinf +tmin-qnan -7e F~ -> false }t
t{ +tinf -tmin-qnan -7e F~ -> false }t
t{ -tinf -tmin-qnan -7e F~ -> false }t

t{ +tmin-qnan +tinf -7e F~ -> false }t
t{ -tmin-qnan +tinf -7e F~ -> false }t
t{ +tmin-qnan -tinf -7e F~ -> false }t
t{ -tmin-qnan -tinf -7e F~ -> false }t

t{ +t0 +t0 -tinf F~ -> false }t
t{ +t0 -t0 -tinf F~ -> false }t
t{ -t0 +t0 -tinf F~ -> false }t
t{ -t0 -t0 -tinf F~ -> false }t

t{  7e -2e -tinf F~ -> true }t
t{ -2e  7e -tinf F~ -> true }t
t{  7e  7e -tinf F~ -> true }t

t{  7e   +tinf -tinf F~ -> false }t
t{ +tinf 7e    -tinf F~ -> false }t
t{  7e  -tinf  -tinf F~ -> false }t
t{ -tinf 7e    -tinf F~ -> false }t

t{ +tinf +tinf -tinf F~ -> false }t
t{ +tinf -tinf -tinf F~ -> false }t
t{ -tinf +tinf -tinf F~ -> false }t
t{ -tinf -tinf -tinf F~ -> false }t

t{ +tmin-qnan  7e    -tinf F~ -> false }t
t{ -tmin-qnan  7e    -tinf F~ -> false }t
t{  7e    +tmin-qnan -tinf F~ -> false }t
t{  7e    -tmin-qnan -tinf F~ -> false }t

t{ +tmin-qnan +tmin-qnan -tinf F~ -> false }t
t{ -tmin-qnan +tmin-qnan -tinf F~ -> false }t
t{ +tmin-qnan -tmin-qnan -tinf F~ -> false }t
t{ -tmin-qnan -tmin-qnan -tinf F~ -> false }t

t{ +tinf +tmin-qnan -tinf F~ -> false }t
t{ -tinf +tmin-qnan -tinf F~ -> false }t
t{ +tinf -tmin-qnan -tinf F~ -> false }t
t{ -tinf -tmin-qnan -tinf F~ -> false }t

t{ +tmin-qnan +tinf -tinf F~ -> false }t
t{ -tmin-qnan +tinf -tinf F~ -> false }t
t{ +tmin-qnan -tinf -tinf F~ -> false }t
t{ -tmin-qnan -tinf -tinf F~ -> false }t

TESTING F~ nan tolerance

t{ +t0 +t0 +tmin-qnan F~ -> false }t
t{ +t0 -t0 +tmin-qnan F~ -> false }t
t{ -t0 +t0 +tmin-qnan F~ -> false }t
t{ -t0 -t0 +tmin-qnan F~ -> false }t

t{  7e -2e +tmin-qnan F~ -> false }t
t{ -2e  7e +tmin-qnan F~ -> false }t
t{  7e  7e +tmin-qnan F~ -> false }t

t{  7e   +tinf +tmin-qnan F~ -> false }t
t{ +tinf  7e   +tmin-qnan F~ -> false }t
t{  7e   -tinf +tmin-qnan F~ -> false }t
t{ -tinf   7e  +tmin-qnan F~ -> false }t

t{ +tinf +tinf +tmin-qnan F~ -> false }t
t{ +tinf -tinf +tmin-qnan F~ -> false }t
t{ -tinf +tinf +tmin-qnan F~ -> false }t
t{ -tinf -tinf +tmin-qnan F~ -> false }t

t{ +tmin-qnan  7e    +tmin-qnan F~ -> false }t
t{ -tmin-qnan  7e    +tmin-qnan F~ -> false }t
t{  7e    +tmin-qnan +tmin-qnan F~ -> false }t
t{  7e    -tmin-qnan +tmin-qnan F~ -> false }t

t{ +tmin-qnan +tmin-qnan +tmin-qnan F~ -> false }t
t{ -tmin-qnan +tmin-qnan +tmin-qnan F~ -> false }t
t{ +tmin-qnan -tmin-qnan +tmin-qnan F~ -> false }t
t{ -tmin-qnan -tmin-qnan +tmin-qnan F~ -> false }t

t{ +tinf +tmin-qnan +tmin-qnan F~ -> false }t
t{ -tinf +tmin-qnan +tmin-qnan F~ -> false }t
t{ +tinf -tmin-qnan +tmin-qnan F~ -> false }t
t{ -tinf -tmin-qnan +tmin-qnan F~ -> false }t

t{ +tmin-qnan +tinf +tmin-qnan F~ -> false }t
t{ -tmin-qnan +tinf +tmin-qnan F~ -> false }t
t{ +tmin-qnan -tinf +tmin-qnan F~ -> false }t
t{ -tmin-qnan -tinf +tmin-qnan F~ -> false }t

t{ +t0 +t0 +tmin-qnan F~ -> false }t
t{ +t0 -t0 +tmin-qnan F~ -> false }t
t{ -t0 +t0 +tmin-qnan F~ -> false }t
t{ -t0 -t0 +tmin-qnan F~ -> false }t

t{  7e -2e -tmin-qnan F~ -> false }t
t{ -2e  7e -tmin-qnan F~ -> false }t
t{  7e  7e -tmin-qnan F~ -> false }t

t{  7e   +tinf -tmin-qnan F~ -> false }t
t{ +tinf  7e   -tmin-qnan F~ -> false }t
t{  7e   -tinf -tmin-qnan F~ -> false }t
t{ -tinf  7e   -tmin-qnan F~ -> false }t

t{ +tinf +tinf -tmin-qnan F~ -> false }t
t{ +tinf -tinf -tmin-qnan F~ -> false }t
t{ -tinf +tinf -tmin-qnan F~ -> false }t
t{ -tinf -tinf -tmin-qnan F~ -> false }t

t{ +tmin-qnan  7e    -tmin-qnan F~ -> false }t
t{ -tmin-qnan  7e    -tmin-qnan F~ -> false }t
t{  7e    +tmin-qnan -tmin-qnan F~ -> false }t
t{  7e    -tmin-qnan -tmin-qnan F~ -> false }t

t{ +tmin-qnan +tmin-qnan -tmin-qnan F~ -> false }t
t{ -tmin-qnan +tmin-qnan -tmin-qnan F~ -> false }t
t{ +tmin-qnan -tmin-qnan -tmin-qnan F~ -> false }t
t{ -tmin-qnan -tmin-qnan -tmin-qnan F~ -> false }t

t{ +tinf +tmin-qnan -tmin-qnan F~ -> false }t
t{ -tinf +tmin-qnan -tmin-qnan F~ -> false }t
t{ +tinf -tmin-qnan -tmin-qnan F~ -> false }t
t{ -tinf -tmin-qnan -tmin-qnan F~ -> false }t

t{ +tmin-qnan +tinf -tmin-qnan F~ -> false }t
t{ -tmin-qnan +tinf -tmin-qnan F~ -> false }t
t{ +tmin-qnan -tinf -tmin-qnan F~ -> false }t
t{ -tmin-qnan -tinf -tmin-qnan F~ -> false }t

TESTING FMAX FMIN

t{  7e    7e   FMAX ->  7e }t
t{  7e    7.1e FMAX ->  7.1e }t
t{  7.1e  7e   FMAX ->  7.1e }t

t{  7e   +tinf FMAX -> +tinf }t
t{ +tinf  7e   FMAX -> +tinf }t
t{  7e   -tinf FMAX ->  7e }t
t{ -tinf  7e   FMAX ->  7e }t

t{ +tinf +tinf FMAX -> +tinf }t
t{ +tinf -tinf FMAX -> +tinf }t
t{ -tinf +tinf FMAX -> +tinf }t
t{ -tinf -tinf FMAX -> -tinf }t

t{  7e    -tmin-qnan FMAX ->  7e }t
t{ -tmin-qnan  7e    FMAX ->  7e }t
t{ -7e    +tmin-qnan FMAX -> -7e }t
t{ +tmin-qnan -7e    FMAX -> -7e }t

t{ +t0    -tmin-qnan FMAX -> +t0 }t
t{ -tmin-qnan +t0    FMAX -> +t0 }t
t{ -t0    +tmin-qnan FMAX -> -t0 }t
t{ +tmin-qnan -t0    FMAX -> -t0 }t

\ IEEE 754-2008 allows either nan to be returned.
t{ +tmin-qnan +tmin-qnan FMAX      -> +tmin-qnan }t
t{ +tmin-qnan -tmin-qnan FMAX FABS -> +tmin-qnan }t
t{ -tmin-qnan +tmin-qnan FMAX FABS -> +tmin-qnan }t
t{ -tmin-qnan -tmin-qnan FMAX      -> -tmin-qnan }t
HAS-QUIETING [IF]
t{ +tmin-snan +tmin-snan FMAX      -> +tmin-snan tquiet }t
t{ +tmin-snan -tmin-snan FMAX FABS -> +tmin-snan tquiet }t
t{ -tmin-snan +tmin-snan FMAX FABS -> +tmin-snan tquiet }t
t{ -tmin-snan -tmin-snan FMAX      -> -tmin-snan tquiet }t
[THEN]

\ IEEE 754-2008 allows either signed zero to be returned.
t{ -t0 -t0 FMAX      -> -t0 }t
t{ -t0 +t0 FMAX FABS -> +t0 }t
t{ +t0 -t0 FMAX FABS -> +t0 }t
t{ +t0 +t0 FMAX      -> +t0 }t

t{  7e    7e   FMIN ->  7e }t
t{  7e    7.1e FMIN ->  7e }t
t{  7.1e  7e   FMIN ->  7e }t

t{  7e   +tinf FMIN ->  7e }t
t{ +tinf  7e   FMIN ->  7e }t
t{  7e   -tinf FMIN -> -tinf }t
t{ -tinf  7e   FMIN -> -tinf }t

t{ +tinf +tinf FMIN -> +tinf }t
t{ +tinf -tinf FMIN -> -tinf }t
t{ -tinf +tinf FMIN -> -tinf }t
t{ -tinf -tinf FMIN -> -tinf }t

t{  7e    -tmin-qnan FMIN ->  7e }t
t{ -tmin-qnan  7e    FMIN ->  7e }t
t{ -7e    +tmin-qnan FMIN -> -7e }t
t{ +tmin-qnan -7e    FMIN -> -7e }t

t{ +t0    -tmin-qnan FMIN -> +t0 }t
t{ -tmin-qnan +t0    FMIN -> +t0 }t
t{ -t0    +tmin-qnan FMIN -> -t0 }t
t{ +tmin-qnan -t0    FMIN -> -t0 }t

\ IEEE 754-2008 allows either nan to be returned.
t{ +tmin-qnan +tmin-qnan FMIN      -> +tmin-qnan }t
t{ +tmin-qnan -tmin-qnan FMIN FABS -> +tmin-qnan }t
t{ -tmin-qnan +tmin-qnan FMIN FABS -> +tmin-qnan }t
t{ -tmin-qnan -tmin-qnan FMIN      -> -tmin-qnan }t
HAS-QUIETING [IF]
t{ +tmin-snan +tmin-snan FMIN      -> +tmin-snan tquiet }t
t{ +tmin-snan -tmin-snan FMIN FABS -> +tmin-snan tquiet }t
t{ -tmin-snan +tmin-snan FMIN FABS -> +tmin-snan tquiet }t
t{ -tmin-snan -tmin-snan FMIN      -> -tmin-snan tquiet }t
[THEN]

\ IEEE 754-2008 allows either signed zero to be returned.
t{ -t0 -t0 FMIN      -> -t0 }t
t{ -t0 +t0 FMIN FABS -> +t0 }t
t{ +t0 -t0 FMIN FABS -> +t0 }t
t{ +t0 +t0 FMIN      -> +t0 }t

TESTING FNEXTUP FNEXTDOWN
[UNDEFINED] FNEXTUP [IF]
?." FNEXTUP not defined, skipping these tests.
[ELSE]

bits/float #32 = [IF]
  $40000001 raw>f FCONSTANT [+2]-up
  $3fffffff raw>f FCONSTANT [+2]-down
  $bfffffff raw>f FCONSTANT [-2]-up
  $c0000001 raw>f FCONSTANT [-2]-down
  $7f7ffffe raw>f FCONSTANT [+tmax-n]-down
  $ff7ffffe raw>f FCONSTANT [-tmax-n]-up
  $00800001 raw>f FCONSTANT [+tmin-n]-up
  $80800001 raw>f FCONSTANT [-tmin-n]-down [THEN]

bits/cell #32 = [IF]
bits/float #64 =  [IF]
  $00000001 $40000000 raw>f FCONSTANT [+2]-up
  $ffffffff $3fffffff raw>f FCONSTANT [+2]-down
  $ffffffff $bfffffff raw>f FCONSTANT [-2]-up
  $00000001 $c0000000 raw>f FCONSTANT [-2]-down
  $fffffffe $7fefffff raw>f FCONSTANT [+tmax-n]-down
  $fffffffe $ffefffff raw>f FCONSTANT [-tmax-n]-up
  $00000001 $00100000 raw>f FCONSTANT [+tmin-n]-up
  $00000001 $80100000 raw>f FCONSTANT [-tmin-n]-down [THEN]
bits/float #80 =  [IF]
  $00000001 $80000000 $4000 raw>f FCONSTANT [+2]-up
  $ffffffff $ffffffff $3fff raw>f FCONSTANT [+2]-down
  $ffffffff $ffffffff $bfff raw>f FCONSTANT [-2]-up
  $00000001 $80000000 $c000 raw>f FCONSTANT [-2]-down
  $fffffffe $ffffffff $7ffe raw>f FCONSTANT [+tmax-n]-down
  $fffffffe $ffffffff $fffe raw>f FCONSTANT [-tmax-n]-up
  $00000001 $80000000 $0001 raw>f FCONSTANT [+tmin-n]-up
  $00000001 $80000000 $8001 raw>f FCONSTANT [-tmin-n]-down [THEN]
bits/float #128 = [IF]
  $00000001 $00000000 $00000000 $40000000 raw>f FCONSTANT [+2]-up
  $ffffffff $ffffffff $ffffffff $3fffffff raw>f FCONSTANT [+2]-down
  $ffffffff $ffffffff $ffffffff $bfffffff raw>f FCONSTANT [-2]-up
  $00000001 $00000000 $00000000 $c0000000 raw>f FCONSTANT [-2]-down
  $fffffffe $ffffffff $ffffffff $7ffeffff raw>f FCONSTANT [+tmax-n]-down
  $fffffffe $ffffffff $ffffffff $fffeffff raw>f FCONSTANT [-tmax-n]-up
  $00000001 $00000000 $00000000 $00010000 raw>f FCONSTANT [+tmin-n]-up
  $00000001 $00000000 $00000000 $80010000 raw>f FCONSTANT [-tmin-n]-down [THEN]
[ELSE]  \ 64 bits/cell
bits/float #64 =  [IF]
  $4000000000000001 raw>f FCONSTANT [+2]-up
  $3fffffffffffffff raw>f FCONSTANT [+2]-down
  $bfffffffffffffff raw>f FCONSTANT [-2]-up
  $c000000000000001 raw>f FCONSTANT [-2]-down
  $7feffffffffffffe raw>f FCONSTANT [+tmax-n]-down
  $ffeffffffffffffe raw>f FCONSTANT [-tmax-n]-up
  $0010000000000001 raw>f FCONSTANT [+tmin-n]-up
  $8010000000000001 raw>f FCONSTANT [-tmin-n]-down [THEN]
bits/float #80 =  [IF]
  $8000000000000001 $4000 raw>f FCONSTANT [+2]-up
  $ffffffffffffffff $3fff raw>f FCONSTANT [+2]-down
  $ffffffffffffffff $bfff raw>f FCONSTANT [-2]-up
  $8000000000000001 $c000 raw>f FCONSTANT [-2]-down
  $fffffffffffffffe $7ffe raw>f FCONSTANT [+tmax-n]-down
  $fffffffffffffffe $fffe raw>f FCONSTANT [-tmax-n]-up
  $8000000000000001 $0001 raw>f FCONSTANT [+tmin-n]-up
  $8000000000000001 $8001 raw>f FCONSTANT [-tmin-n]-down [THEN]
bits/float #128 = [IF]
  $0000000000000001 $4000000000000000 raw>f FCONSTANT [+2]-up
  $ffffffffffffffff $3fffffffffffffff raw>f FCONSTANT [+2]-down
  $ffffffffffffffff $bfffffffffffffff raw>f FCONSTANT [-2]-up
  $0000000000000001 $c000000000000000 raw>f FCONSTANT [-2]-down
  $fffffffffffffffe $7ffeffffffffffff  raw>f FCONSTANT [+tmax-n]-down
  $fffffffffffffffe $fffeffffffffffff raw>f FCONSTANT [-tmax-n]-up
  $0000000000000001 $0001000000000000 raw>f FCONSTANT [+tmin-n]-up
  $0000000000000001 $8001000000000000 raw>f FCONSTANT [-tmin-n]-down [THEN]
[THEN]

\ qnan propagation
t{ +tmin-qnan FNEXTUP tfqnan? -> true }t
t{ -tmin-qnan FNEXTUP tfqnan? -> true }t
\ If these pass, these particular qNaNs are conserved.
t{ +tmin-qnan FNEXTUP -> +tmin-qnan }t \ not an ieee "shall"
t{ -tmin-qnan FNEXTUP -> -tmin-qnan }t \ not an ieee "shall"

HAS-QUIETING [IF]
\ snan quieting
t{ +tmin-snan FNEXTUP tfqnan? -> true }t
t{ -tmin-snan FNEXTUP tfqnan? -> true }t
\ If these pass, these particular sNaNs are simply quieted.
t{ +tmin-snan FNEXTUP -> +tmin-snan tquiet }t
t{ -tmin-snan FNEXTUP -> -tmin-snan tquiet }t
[THEN]

\ +max-n boundary
t{ +tinf          FNEXTUP -> +tinf }t
t{ +tmax-n        FNEXTUP -> +tinf }t
t{ [+tmax-n]-down FNEXTUP -> +tmax-n }t

\ +normal integer boundaries
t{  2e        FNEXTUP -> [+2]-up }t
t{  [+2]-down FNEXTUP ->  2e }t

\ +subnormal boundaries
t{ +tmin-n    FNEXTUP -> [+tmin-n]-up }t
t{ +tmax-subn FNEXTUP -> +tmin-n }t
t{ +tmin-subn FNEXTUP -> +tmin-subn 2e f* }t

\ +|-0 boundaries
t{ +t0        FNEXTUP -> +tmin-subn }t
t{ -t0        FNEXTUP -> +tmin-subn }t
t{ -tmin-subn FNEXTUP -> -t0 }t

\ -subnormal boundaries
t{ -tmin-subn 2e f* FNEXTUP -> -tmin-subn }t
t{ -tmin-n          FNEXTUP -> -tmax-subn }t
t{ [-tmin-n]-down   FNEXTUP -> -tmin-n }t

\ -normal integer boundaries
t{ [-2]-down FNEXTUP -> -2e }t
t{ -2e       FNEXTUP -> [-2]-up }t 

\ -max-n boundary
t{ -tmax-n FNEXTUP -> [-tmax-n]-up }t
t{ -tinf   FNEXTUP -> -tmax-n }t

\ tnan propagation
t{ +tmin-qnan FNEXTDOWN tfqnan? -> true }t
t{ -tmin-qnan FNEXTDOWN tfqnan? -> true }t
\ If these pass, these particular qNaNs are conserved.
t{ +tmin-qnan FNEXTDOWN -> +tmin-qnan }t \ not an ieee "shall"
t{ -tmin-qnan FNEXTDOWN -> -tmin-qnan }t \ not an ieee "shall"


HAS-QUIETING [IF]
\ snan quieting
t{ +tmin-snan FNEXTDOWN tfqnan? -> true }t
t{ -tmin-snan FNEXTDOWN tfqnan? -> true }t
\ If these pass, these particular sNaNs are simply quieted.
t{ +tmin-snan FNEXTDOWN -> +tmin-snan tquiet }t
t{ -tmin-snan FNEXTDOWN -> -tmin-snan tquiet }t
[THEN]

\ max-n boundary
t{ +tinf   FNEXTDOWN -> +tmax-n }t
t{ +tmax-n FNEXTDOWN -> [+tmax-n]-down }t

\ +normal integer boundaries
t{ [+2]-up FNEXTDOWN ->  2e }t
t{  2e     FNEXTDOWN -> [+2]-down }t

\ +subnormal boundaries
t{ [+tmin-n]-up     FNEXTDOWN -> +tmin-n }t
t{ +tmin-n          FNEXTDOWN -> +tmax-subn }t 
t{ +tmin-subn 2e f* FNEXTDOWN -> +tmin-subn }t 

\ +|-0 boundaries
t{ +tmin-subn FNEXTDOWN -> +t0 }t
t{ +t0        FNEXTDOWN -> -tmin-subn }t
t{ -t0        FNEXTDOWN -> -tmin-subn }t

\ -subnormal boundaries
t{ -tmin-subn FNEXTDOWN -> -tmin-subn 2e f* }t
t{ -tmax-subn FNEXTDOWN -> -tmin-n }t
t{ -tmin-n    FNEXTDOWN -> [-tmin-n]-down }t

\ -normal integer boundaries
t{ [-2]-up FNEXTDOWN -> -2e }t 
t{ -2e     FNEXTDOWN -> [-2]-down }t 

\ -max-n boundary
t{ [-tmax-n]-up FNEXTDOWN -> -tmax-n }t
t{ -tmax-n      FNEXTDOWN -> -tinf }t
t{ -tinf        FNEXTDOWN -> -tinf }t
[THEN]  \ [UNDEFINED] NEXTUP

TESTING FLOGB
[UNDEFINED] FLOGB [IF]
?." FLOGB not defined, skipping these tests.
[ELSE]
t{  1e      FLOGB -> +t0 }t
t{ -1e      FLOGB -> +t0 }t

t{  1.2345e FLOGB -> +t0 }t
t{ -1.6789e FLOGB -> +t0 }t
t{ +tinf    FLOGB -> +tinf }t
t{ -tinf    FLOGB -> +tinf }t

\ divideByZero signal not tested here
t{ +t0 FLOGB -> -tinf }t
t{ -t0 FLOGB -> -tinf }t

t{ +tmax-n FLOGB -> emax s>f }t
t{ -tmax-n FLOGB -> emax s>f }t
t{ +tmin-n FLOGB -> emin s>f }t
t{ -tmin-n FLOGB -> emin s>f }t

t{ +tmax-subn FLOGB -> emin 1- s>f }t
t{ -tmax-subn FLOGB -> emin 1- s>f }t
t{ +tmin-subn FLOGB -> emin prec - 1+ s>f }t
t{ -tmin-subn FLOGB -> emin prec - 1+ s>f }t

t{ +tmin-qnan FLOGB tfqnan? -> true }t
t{ -tmin-qnan FLOGB tfqnan? -> true }t

SHOULD [IF]
TESTING FLOGB shoulds

t{ +tmin-qnan FLOGB -> +tmin-qnan }t
t{ -tmin-qnan FLOGB -> -tmin-qnan }t
t{ +tmax-qnan FLOGB -> +tmax-qnan }t
t{ -tmax-qnan FLOGB -> -tmax-qnan }t
t{ -tmin-qnan FLOGB -> -tmin-qnan }t
HAS-QUIETING [IF]
t{ +tmin-snan FLOGB -> +tmin-snan tquiet }t
t{ -tmin-snan FLOGB -> -tmin-snan tquiet }t
t{ +tmin-snan FLOGB tfqnan? -> true }t
t{ -tmin-snan FLOGB tfqnan? -> true }t
[THEN]

[THEN]  \ SHOULD
[THEN]  \ [UNDEFINED] FLOGB

TESTING FILOGB
[UNDEFINED] FILOGB [IF]
?." FILOGB not defined, skipping these tests.
[ELSE]

\ Signals for special returns not tested here.

t{  1e      FILOGB -> 0 }t
t{ -1e      FILOGB -> 0 }t
t{  1.2345e FILOGB -> 0 }t
t{ -1.6789e FILOGB -> 0 }t
t{ +tinf    FILOGB -> MAX-N }t
t{ -tinf    FILOGB -> MAX-N }t
t{ +t0      FILOGB -> -MAX-N }t
t{ -t0      FILOGB -> -MAX-N }t

t{ +tmax-n FILOGB -> emax }t
t{ -tmax-n FILOGB -> emax }t
t{ +tmin-n FILOGB -> emin }t
t{ -tmin-n FILOGB -> emin }t

t{ +tmax-subn FILOGB -> emin 1- }t
t{ -tmax-subn FILOGB -> emin 1- }t
t{ +tmin-subn FILOGB -> emin prec - 1+ }t
t{ -tmin-subn FILOGB -> emin prec - 1+ }t

t{ +tmin-qnan FILOGB -> MIN-N }t
t{ -tmin-qnan FILOGB -> MIN-N }t
t{ +tmin-snan FILOGB -> MIN-N }t
t{ -tmin-snan FILOGB -> MIN-N }t
[THEN]  \ [UNDEFINED] FILOGB
}?USE-NATIVE

?." NATIVE ARITHMETIC TESTS
TESTING F+

\ IEEE-2008 6.3

t{ +t0 +t0 f+ -> +t0 }t
t{ +t0 -t0 f+ -> +t0 }t
t{ -t0 +t0 f+ -> +t0 }t
t{ -t0 -t0 f+ -> -t0 }t

t{ +tmin-qnan  2e  f+ -> +tmin-qnan }t
t{ -tmin-qnan  2e  f+ -> -tmin-qnan }t
t{  3e  +tmin-qnan f+ -> +tmin-qnan }t
t{  3e  -tmin-qnan f+ -> -tmin-qnan }t

t{ +tmin-qnan +tmin-qnan f+      -> +tmin-qnan }t
t{ -tmin-qnan +tmin-qnan f+ fabs -> +tmin-qnan }t
t{ +tmin-qnan -tmin-qnan f+ fabs -> +tmin-qnan }t
t{ -tmin-qnan -tmin-qnan f+      -> -tmin-qnan }t

t{  2e  +tinf f+ -> +tinf }t
t{ +tinf  7e  f+ -> +tinf }t
t{  2e  -tinf f+ -> -tinf }t
t{ -tinf  7e  f+ -> -tinf }t

t{ +tmin-qnan +tinf f+ -> +tmin-qnan }t
t{ +tinf +tmin-qnan f+ -> +tmin-qnan }t
t{ +tmin-qnan -tinf f+ -> +tmin-qnan }t
t{ -tinf +tmin-qnan f+ -> +tmin-qnan }t
t{ -tmin-qnan +tinf f+ -> -tmin-qnan }t
t{ +tinf -tmin-qnan f+ -> -tmin-qnan }t
t{ -tmin-qnan -tinf f+ -> -tmin-qnan }t
t{ -tinf -tmin-qnan f+ -> -tmin-qnan }t

t{ +tinf +tinf f+      -> +tinf }t
t{ +tinf -tinf f+ fabs -> +tmin-qnan }t
t{ -tinf +tinf f+ fabs -> +tmin-qnan }t
t{ -tinf -tinf f+      -> -tinf }t

TESTING F-

t{ +t0 +t0 f- -> +t0 }t
t{ +t0 -t0 f- -> +t0 }t
t{ -t0 +t0 f- -> -t0 }t
t{ -t0 -t0 f- -> +t0 }t

t{ +tmin-qnan  2e   f- -> +tmin-qnan }t
t{ -tmin-qnan  2e   f- -> -tmin-qnan }t
t{  3e   +tmin-qnan f- -> +tmin-qnan }t
t{  3e   -tmin-qnan f- -> -tmin-qnan }t

t{ +tmin-qnan +tmin-qnan f-      -> +tmin-qnan }t
t{ -tmin-qnan +tmin-qnan f- fabs -> +tmin-qnan }t
t{ +tmin-qnan -tmin-qnan f- fabs -> +tmin-qnan }t
t{ -tmin-qnan -tmin-qnan f-      -> -tmin-qnan }t

t{  2e  +tinf f- -> -tinf }t
t{ +tinf  7e  f- -> +tinf }t
t{  2e  -tinf f- -> +tinf }t
t{ -tinf  7e  f- -> -tinf }t

t{ +tmin-qnan +tinf f- -> +tmin-qnan }t
t{ +tinf +tmin-qnan f- -> +tmin-qnan }t
t{ +tmin-qnan -tinf f- -> +tmin-qnan }t
t{ -tinf +tmin-qnan f- -> +tmin-qnan }t
t{ -tmin-qnan +tinf f- -> -tmin-qnan }t
t{ +tinf -tmin-qnan f- -> -tmin-qnan }t
t{ -tmin-qnan -tinf f- -> -tmin-qnan }t
t{ -tinf -tmin-qnan f- -> -tmin-qnan }t

t{ +tinf +tinf f- fabs -> +tmin-qnan }t
t{ +tinf -tinf f-      -> +tinf }t
t{ -tinf +tinf f-      -> -tinf }t
t{ -tinf -tinf f- fabs -> +tmin-qnan }t

TESTING F*

t{ +t0 +t0 f* -> +t0 }t
t{ +t0 -t0 f* -> -t0 }t
t{ -t0 +t0 f* -> -t0 }t
t{ -t0 -t0 f* -> +t0 }t

t{ +t0  2e f* -> +t0 }t
t{ -t0  2e f* -> -t0 }t
t{ +t0 -2e f* -> -t0 }t
t{ -t0 -2e f* -> +t0 }t
t{  2e +t0 f* -> +t0 }t
t{  2e -t0 f* -> -t0 }t
t{ -2e +t0 f* -> -t0 }t
t{ -2e -t0 f* -> +t0 }t

t{ +tmin-qnan  2e  f* -> +tmin-qnan }t
t{ -tmin-qnan  2e  f* -> -tmin-qnan }t
t{  3e  +tmin-qnan f* -> +tmin-qnan }t
t{  3e  -tmin-qnan f* -> -tmin-qnan }t

t{ +tmin-qnan +tmin-qnan f*      -> +tmin-qnan }t
t{ -tmin-qnan +tmin-qnan f* fabs -> +tmin-qnan }t
t{ +tmin-qnan -tmin-qnan f* fabs -> +tmin-qnan }t
t{ -tmin-qnan -tmin-qnan f*      -> -tmin-qnan }t

t{  2e  +tinf f* -> +tinf }t
t{ +tinf  7e  f* -> +tinf }t
t{  2e  -tinf f* -> -tinf }t
t{ -tinf  7e  f* -> -tinf }t

t{ +tmin-qnan +tinf f* -> +tmin-qnan }t
t{ +tinf +tmin-qnan f* -> +tmin-qnan }t
t{ +tmin-qnan -tinf f* -> +tmin-qnan }t
t{ -tinf +tmin-qnan f* -> +tmin-qnan }t
t{ -tmin-qnan +tinf f* -> -tmin-qnan }t
t{ +tinf -tmin-qnan f* -> -tmin-qnan }t
t{ -tmin-qnan -tinf f* -> -tmin-qnan }t
t{ -tinf -tmin-qnan f* -> -tmin-qnan }t

t{ +tinf +tinf f* -> +tinf }t
t{ +tinf -tinf f* -> -tinf }t
t{ -tinf +tinf f* -> -tinf }t

TESTING F/

t{ +t0 +t0 f/ fabs -> +tmin-qnan }t
t{ +t0 -t0 f/ fabs -> +tmin-qnan }t
t{ -t0 +t0 f/ fabs -> +tmin-qnan }t
t{ -t0 -t0 f/ fabs -> +tmin-qnan }t

t{ +t0  2e f/ -> +t0 }t
t{ -t0  2e f/ -> -t0 }t
t{ +t0 -2e f/ -> -t0 }t
t{ -t0 -2e f/ -> +t0 }t
t{  2e +t0 f/ -> +tinf }t
t{  2e -t0 f/ -> -tinf }t
t{ -2e +t0 f/ -> -tinf }t
t{ -2e -t0 f/ -> +tinf }t

t{ +tmin-qnan  2e  f/ -> +tmin-qnan }t
t{ -tmin-qnan  2e  f/ -> -tmin-qnan }t
t{  3e  +tmin-qnan f/ -> +tmin-qnan }t
t{  3e  -tmin-qnan f/ -> -tmin-qnan }t

t{ +tmin-qnan +tmin-qnan f/      -> +tmin-qnan }t
t{ -tmin-qnan +tmin-qnan f/ fabs -> +tmin-qnan }t
t{ +tmin-qnan -tmin-qnan f/ fabs -> +tmin-qnan }t
t{ -tmin-qnan -tmin-qnan f/      -> -tmin-qnan }t

t{  2e  +tinf f/ -> +t0 }t
t{ +tinf  7e  f/ -> +tinf }t
t{  2e  -tinf f/ -> -t0 }t
t{ -tinf  7e  f/ -> -tinf }t

t{ +tmin-qnan +tinf f/ -> +tmin-qnan }t
t{ +tinf +tmin-qnan f/ -> +tmin-qnan }t
t{ +tmin-qnan -tinf f/ -> +tmin-qnan }t
t{ -tinf +tmin-qnan f/ -> +tmin-qnan }t
t{ -tmin-qnan +tinf f/ -> -tmin-qnan }t
t{ +tinf -tmin-qnan f/ -> -tmin-qnan }t
t{ -tmin-qnan -tinf f/ -> -tmin-qnan }t
t{ -tinf -tmin-qnan f/ -> -tmin-qnan }t

t{ +tinf +tinf f/ fabs -> +tmin-qnan }t
t{ +tinf -tinf f/ fabs -> +tmin-qnan }t
t{ -tinf +tinf f/ fabs -> +tmin-qnan }t

TESTING FSQRT

t{ +t0   fsqrt -> +t0 }t
t{ -t0   fsqrt -> -t0 }t
t{ +tinf fsqrt -> +tinf }t
t{ -tinf fsqrt -> -1e fsqrt }t
t{ +tmin-qnan fsqrt -> +tmin-qnan }t
t{ -tmin-qnan fsqrt -> -tmin-qnan }t
t{ -1e  fsqrt tfqnan? -> true }t

?." NOT TESTING F*+

?." NATIVE FATAN2 TESTS
(
Tests the ISO C / Single UNIX 3 specification for the ANS Forth
Floating-Ext word:
)
\ FATAN2 ( f: y x -- radians ) or ( y x -- radians )
(
It expects the return value to be the principal angle, and includes a
number of tests with +|-0, +|-nan, and +|-inf that are not required by
the ANS Forth 94 standard.
)

[UNDEFINED] FATAN2 [IF]

?." FATAN2 not defined, skipping these tests.

[ELSE]  \ FATAN2 defined

?." Using exact values.

true [IF]

 0.31415926535897932384626433832795028841971693993751e1 FCONSTANT  pi
-0.31415926535897932384626433832795028841971693993751e1 FCONSTANT -pi

\ Defining fractions of pi in terms of pi avoids most of the decimal
\ to binary conversions.  Suggested by Bernd Paysan.  The fact that both
\ branches of this conditional work validates his suggestion.

 pi 4e f/   FCONSTANT   pi/4
-pi 4e f/   FCONSTANT  -pi/4
 pi 2e f/   FCONSTANT   pi/2
-pi 2e f/   FCONSTANT  -pi/2
 pi/2 3e f* FCONSTANT  3pi/2
 pi/4 3e f* FCONSTANT  3pi/4
-pi/4 3e f* FCONSTANT -3pi/4

[ELSE]

\ These 50-digit constants are good for binary 128, which is about 34
\ decimal digits.

 0.31415926535897932384626433832795028841971693993751e1 FCONSTANT  pi
-0.31415926535897932384626433832795028841971693993751e1 FCONSTANT -pi
 0.78539816339744830961566084581987572104929234984378e0 FCONSTANT  pi/4
-0.78539816339744830961566084581987572104929234984378e0 FCONSTANT -pi/4
 0.15707963267948966192313216916397514420985846996876e1 FCONSTANT  pi/2
-0.15707963267948966192313216916397514420985846996876e1 FCONSTANT -pi/2
 0.47123889803846898576939650749192543262957540990627e1 FCONSTANT  3pi/2
-0.47123889803846898576939650749192543262957540990627e1 FCONSTANT -3pi/2
 0.23561944901923449288469825374596271631478770495313e1 FCONSTANT  3pi/4
-0.23561944901923449288469825374596271631478770495313e1 FCONSTANT -3pi/4

[THEN]

TESTING normal values

\ Input x-y values taken from Ed, comp.lang.forth,
\ "Re: Ambiguity in FATAN2", 14Mar09, 17Mar09:
\   y   x              rad          deg
t{  0e  1e fatan2 ->   0e   }t    \   0
t{  1e  1e fatan2 ->   pi/4 }t    \  45
t{  1e  0e fatan2 ->   pi/2 }t    \  90
t{ -1e -1e fatan2 -> -3pi/4 }t    \ 135
t{  0e -1e fatan2 ->   pi   }t    \ 180
t{ -1e  1e fatan2 ->  -pi/4 }t    \ 225
t{ -1e  0e fatan2 ->  -pi/2 }t    \ 270
t{ -1e  1e fatan2 ->  -pi/4 }t    \ 315

TESTING Single UNIX 3 special values spec

\ ISO C / Single UNIX Specification Version 3:
\   http://www.unix.org/single_unix_specification/
\ Select "Topic", then "Math Interfaces", then "atan2()":
\   http://www.opengroup.org/onlinepubs/009695399/functions/atan2f.html

\ If y is +|-0 and x is < 0, +|-pi shall be returned.
t{  0e -1e fatan2 ->  pi }t
t{ -0e -1e fatan2 -> -pi }t

\ If y is +|-0 and x is > 0, +|-0 shall be returned.
t{  0e  1e fatan2 ->  0e }t
t{ -0e  1e fatan2 -> -0e }t

\ If y is < 0 and x is +|-0, -pi/2 shall be returned.
t{ -1e  0e fatan2 -> -pi/2 }t
t{ -1e -0e fatan2 -> -pi/2 }t

\ If y is > 0 and x is +|-0, pi/2 shall be returned.
t{  1e  0e fatan2 -> pi/2 }t
t{  1e -0e fatan2 -> pi/2 }t

TESTING Single UNIX 3 special values optional spec

\ Optional ISO C / single UNIX specs:

\ If either x or y is nan, a nan shall be returned.
t{ +tmin-qnan  1e fatan2 -> +tmin-qnan }t
t{  1e +tmin-qnan fatan2 -> +tmin-qnan }t
t{ +tmin-qnan +tmin-qnan fatan2 -> +tmin-qnan }t

\ If y is +|-0 and x is -0, +|-pi shall be returned.
t{  0e -0e fatan2 ->  pi }t
t{ -0e -0e fatan2 -> -pi }t

\ If y is +|-0 and x is +0, +|-0 shall be returned.
t{  0e  0e fatan2 -> +0e }t
t{ -0e  0e fatan2 -> -0e }t

\ For finite values of +|-y > 0, if x is -inf, +|-pi shall be returned.
t{  1e -tinf fatan2 ->  pi }t
t{ -1e -tinf fatan2 -> -pi }t

\ For finite values of +|-y > 0, if x is +inf, +|-0 shall be returned.
t{  1e +tinf fatan2 -> +0e }t
t{ -1e +tinf fatan2 -> -0e }t

\ For finite values of x, if y is +|-inf, +|-pi/2 shall be returned.
t{ +tinf  1e fatan2 ->  pi/2 }t
t{ +tinf -1e fatan2 ->  pi/2 }t
t{ +tinf  0e fatan2 ->  pi/2 }t
t{ +tinf -0e fatan2 ->  pi/2 }t
t{ -tinf  1e fatan2 -> -pi/2 }t
t{ -tinf -1e fatan2 -> -pi/2 }t
t{ -tinf  0e fatan2 -> -pi/2 }t
t{ -tinf -0e fatan2 -> -pi/2 }t

\ If y is +|-inf and x is -inf, +|-3pi/4 shall be returned.
t{ +tinf -tinf fatan2 ->  3pi/4 }t
t{ -tinf -tinf fatan2 -> -3pi/4 }t

\ If y is +|-inf and x is +inf, +|-pi/4 shall be returned.
t{ +tinf +tinf fatan2 ->  pi/4 }t
t{ -tinf +tinf fatan2 -> -pi/4 }t

[THEN]  \ [UNDEFINED] FATAN2

?.errors GFORTH-HOST [IF] ?.cr [THEN]