Test exceptions in sqrt too.

Test flo:negate.

Add some more sqrt edge cases.

Fix mistranscription of opcode for UNPCKLF.

Add some more copysign tests.

Floating-point total ordering.

- (flo:total< x y) is true if x < y in the total ordering on
  floating-point values defined in IEEE 754-2008 Sec. 5.10, i.e. this
  is the totalOrder function of IEEE 754-2008 Sec. 5.7.2.
- (flo:total-order x y) is -1 if x < y, 0 if x = y, +1 if x > y in the
  total ordering -- the three-way comparison version of total<.
- (flo:total-mag< x y) = (flo:total< (flo:abs x) (flo:abs y))
- (flo:total-order-mag x y)
  = (flo:total-order (flo:abs x) (flo:abs y))

While here, tweak release notes on flonum stuff.

sqrt is busted on infinities.

Move a bunch of flonum tests to test-flonum.scm.

Let's keep test-arith.scm for higher-level numerical computations.

Make the signature of define-enumerated-test match everyone else.

Not sure why I used vectors here in the first place.

Note string and symbol escape printing bug.

Note local optional parameter bug.

Note magnitude overflow bug.

Note flo:min/max IEEE 754-2008 conformance.

Test more edge cases of rounding operations.

Include the rounding->exact operations too.

Update some release notes on floating-point stuff.

Use fabs(3) for C implementation of FLONUM-ABS.

A conditional based on < doesn't handle NaN correctly.

Our C implementation of flo:abs is busted.

Pass multiple arguments here.  No functional change.

New NaN-related and min/max flonum procedures and fixes.

- (flo:qnan) returns a quiet NaN: arithmetic on it quietly returns
  another qNaN (usually the same one, unless there are multiple to
  choose from) without raising any exception.

- (flo:snan) returns a signalling NaN: arithmetic on it returns
  another sNaN (usually the same) and raises an exception, which will
  trap if you ask.

- (flo:qnan? f) = (and (flo:nan? f) (flo:nan-quiet? f))

- (flo:snan? f) = (and (flo:nan? f) (not (flo:nan-quiet? f)))

- (flo:min x y) and (flo:max x y) now raise an exception only if at
  least one input is a signalling NaN, and traps only if you ask.
  These now implement minNum and maxNum of IEEE 754-2008.

- (flo:min-mag x y) and (flo:max-mag x y) return whichever of the
  inputs has the smaller magnitude, as in minNumMag and maxNumMag in
  IEEE 754-2008.

New primitives for creating and examining NaNs.

- (flo:make-nan negative? quiet? payload)
- (flo:nan-quiet? nan)
- (flo:nan-payload nan)

New CTASSERT macro for compile-time assertions.

Implement flo:safe-zero? and flo:safe=.

Merge these cases again now that the xfails are fixed.

Implement binary-hash-by-X; some hair to guarantee fixnum result.

Not nearly as fast as the underlying unary hash, but for now that's OK.  If need
be we can make it faster.

Simplify spar-push-body.

Eliminate unnecessary copy of map-in-order.

Teach LIAR/x86-64 to open-code flo:safe-negative?.

Correctly commute flo:safe>= to flo:safe<=, not to safe:>=.

Until LIAR's RTL code compression was taught to search through
object->float, this code path appears to have been impossible to
exercise.

Teach RTL compression to search through object->float too.

This way it can fold (object->float (constant #x1p+0)) in both

(assign (register #x22) (object->float (constant #x1p+0))
(assign (register #x23) (offset (register 4) (machine-constant 0)))
(assign (register #x24) (object->float (register #x23)))
(jumpc (flonum-pred-2-args flonum-is-greater? (register #x22) (register #x24)) label-3)

and

(assign (register #x21) (offset (register 4) (machine-constant 0)))
(assign (register #x22) (object->float (register #x21)))
(assign (register #x24) (object->float (constant #x1p+0)))
(jumpc (flonum-pred-2-args flonum-is-greater? (register #x22) (register #x24)) label-3)

where previously it could handle only the second one because the
reference appeared in the immediately subsequent instruction.

This exposes a latent bug in the x86-64 code generator, to be fixed
in a subsequent commit.

fixup! aa477cf3a28ded82f8cbcda5e8ee317cf9490d2f

Delete a rewriting rule that could not possibly have ever matched.

It would have required (object->float (object->float ...)) to appear
in the input, which makes no sense.

Test literal operands to flonum comparators.

This is a failed attempt to trigger a compiler bug that I noticed by
code inspection.

Make thie test actually check something by calling both.

Re-enable invalid-operation traps here and fix the one broken test.

Should maybe add a flo:safe-zero?, or decide that flo:zero? is the
quiet version and (flo:= x 0.) is the signalling one.

Factor out unary->binary predicate conversion.

Add flo:<>, as (or flo:< flo:>) for now.

Test flo:unordered? both ways too.

Test compilation of flonum comparisons both ways.

Run the flonum tests both compiled and interpreted.

These tests now pass on x86-64.

Need to teach i386, svm, and C about this now.

Test compiling in-line calls to the flonum comparators too.

Teach LIAR/x86-64 about ordered vs unordered comparisons.

- Fix miscompilation of ordered comparisons: now the standard
  comparison operators raise exceptions, which trap if you ask.

- Open-code the unordered comparisons flo:safe< &c.

Factor out unary->binary predicate conversion.

Explain what commute-flonum-predicate is doing.

Teach rtlgen to open-code flo:safe-negative? too.

Disabled on all machines for now.

Teach rtlgen to open-code safe flonum comparison routines.

Disable on all machines for now.

Teach sf about some flonum primitives worth open-coding.

Fix miscompilation of default optional parameters.

Holdover from days when optional parameters were filled with
unassigned reference traps -- LIAR never got the memo.

Test for miscompilation of optional arguments.

Add some tests for primitive floating-point operations.

Test for exceptions from ordered comparisons.

These are currently broken at least on x86 because the compiler
generates the wrong instructions.

When we switch the compiler to generating the right ones we may need to
adjust the runtime to use flo:safeX in certain places.

Define expect-error as an alias for assert-error.

The difference is in intent: expect-error means something is broken,
and the test signals an error because of a bug; assert-error means
the correct behaviour is to signal an error.

Pass expect-error or expect-failure as procedures, not as symbols
representing them, throughout the test suite.

Now we can find documented bugs by grepping for expect-error and
expect-failure.

Implement random-bytevector!.

Note flo:classify and flo:subnormal?.

Define flo:classify and flo:subnormal?.

Test escapes in symbol notation too.

Escape only the character that needs it.

Read/write invariance is broken for strings with `|'.

Add another screw case.

From my attempt to work around the other one using
er-macro-transformer...

Fix typos.  Missed this when committing.

Add test for bug#55090.

Add some test cases for (broken) macro expansion.

Initial draft of program to grovel over files looking for libraries.

This eliminates the need for the library names to be tied to the filesystem
structure.

The loader still needs to be enhanced to automatically load the registered
libraries.  For now this is essentially a no-op.

Default os/interprogram-paste needs to return #f or string.

Revise unix installation notes to be more specific.

Explicitly prevent native releases from assuming a scheme exists.

Arrange for runtime packages to be importable as libraries.

Pass IS_NATIVE_RELEASE to microcode during configuration.

Fix create-makefiles.sh to use arch consistently.

Change configure.ac to gobble up arch from ".native-release-marker".

Use flo:hypot to compute inexact magnitudes with edge caess.

Maybe not the best way but it'll do for now.

Test angles of partly infinite complex numbers.

Teach relerr to return 0 if eqv or 1 if not for zero or inf.

This way we confirm infinite results and the sign of zero.

Fix up some test cases that this broke.

magnitude is busted when both components are infinite.

Fix harmless typo.

Accidentally using base 2 set this bound far lower than it needed to
be, but this branch isn't necessary anyway; it just skips a call to
exp that would have given the same result.

Redo some of the floating-point parameters.  Test them.

My initial attempt at these went wrong in various ways, oops.

Fix nonsense error analysis in logit1/2+.

The Sterbenz lemma does not apply here after all, not sure why I
thought it did.

Fix overflow in logistic-1/2.

Test some screw cases for logistic-1/2.

Check all four quadrants of complex asin, acos, atan.

Avoid overflow in sqrt(1 - z^2) with sqrt(1 - z)*sqrt(1 + z) in asin.

Strike off a couple xfails.  Others remain because the branch cuts
are busted.

Tweak acos tests to clarify and reduce rounding errors.

Define some more complex trig tests, several currently broken.

Implement handling of traps under macOS.

Change .native-release-marker to contain arch.

Move string-for-primitive to (runtime).

Fix definition of relerr.

The expected magnitude should be, well, the magnitude of the expected
value, not the one we actually computed!

Fortunately it doesn't change the outcome of any of the tests here.

Use complex:1+ and complex:-1+.

No functional change but this makes it less likely that someone might
tweak the argument order, which tend sto matter for preserving things
like signed zeros.

Note corrected atan branch cut.

Some more atan tests for real values.

Invent complex:log1m to get correct branch cut in atan on exact inputs.

Not going to export it for now without further thought, though.

Add some atan tests.

Currently (atan -2i) is broken because of an unfortunate consequence
of exact Scheme arithmetic failing to propagate sign changes through
zero like floating-point does.

Add note about signed zero in complex notation.

Fix printing signed zero imaginary part.

More signed zero screw cases in complex numbers.

Some more cases.

Respect signed zero in complex real part.

Test some complex cases.  We lose on signed zero (again).

Add note about <= and >= fix.

Teach (log1p x) to return complex results for real x < -1.