🚀 go-pugleaf

An article by W. Kahan titled "How Java's Floating-Point Hurts Everyone
Everywhere" (and which describes much more than Java)  includes a discussion
about the results of floating point multiply.


According to his description, until 1963 IBM Fortran compilers would
generate double precision results for floating point multiply of two single
precision numbers, at least when it was being summed into a double precision
variable.  He then explains that IBM changed this in IBSYS 13, anticipating
S/360.

As far as I can tell, the Fortran-66 standard requires a single precision
product when multiplying single precision numbers, though I don't know how
much impact IBM had on Fortran-66.

The reason why this comment is surprising to me is that S/360 (along with
S/370 and ESA/390) do not have a single precision multipy instruction with a
single precision product.  The product is always double precision.  I have
checked the code generated by both the G and H compilers, and both, after
generating the multiply instruction generate at least two more instructions
to truncate the product to single precision.

It, then, seems unlikely to me that the change was made to accomodate S/360,
when the S/360 hardware had exactly the opposite effect.   I don't know what
the status of Fortran-66 was in 1963, though, and what influence that may
have had.

As far as I know, Fortran still requires floating point multiply to generate
a result with no more precision than the arguments that went into it.
W.Kahan describes well the advantage of summing a double precision product
of single precision arguments, yet the Fortran standard doesn't seem to
follow it.  (Someone with a more recent standard can comment on this.)

The floating point rules in C (not crossposted to comp.lang.c) are more
relaxed, and I believe that C compilers commonly do generate whatever
results the hardware supplies.  This, of course, can be confusing to
programmers.

PL/I has the MULTIPLY function where one can specify the desired result
precision.  At least one compiler I know of expands both operands before
doing a double precision multiply when double precision is desired.

If someone wanted to comment about other hardware or compilers in use in the
1960's and 1970's, that might also be useful.

I would, in the end, like to thank W.Kahan for his unceasing drive to
improve the results of floating point hardware and software, and hope for
only constructive discussion of this problem.

-- glen