A Ada Interface

A Ada interface

AUGUSTA ADA (1815–1852), COUNTESS OF LOVELACE AND DAUGHTER OF LORD BYRON, ASSISTANT AND BIOGRAPHER TO CHARLES BABBAGE, AND THE WORLD’S FIRST COMPUTER PROGRAMMER.

The Ada programming language [Ada95] defines a standard interface to routines written in other languages, and the GNU Ada translator, gnat, supports that interface. The standard Ada floating-point data types Float, Long_Float, and Long_Long_Float correspond directly to the C data types float, double, and long double. The Ada integer data types Integer, Long_Integer, and Long_Long_Integer are defined to be 32-bit, 32-bit, and 64-bit signed values, respectively, by the gnat compiler. At the time of writing this, this author has access only to one Ada compiler family, gnat, running on IA-32, IA-64, and AMD64 systems, so interplatform portability of the Ada interface to the mathcw library cannot yet be extensively checked. Nevertheless, any changes needed for other platforms are expected to be relatively small, and related to the mapping of integer types. Ada is a complex and strongly typed language, with a large collection of packages, several of which must be imported into Ada programs in order to use library functions. It is traditional in Ada to separate the specification of a package from its implementation, and with the gnat compiler, the two parts are stored in separate files with extensions .ads (Ada specification) and .adb (Ada body). For example, commercial software vendors can supply the specification source files and implementation object library files to customers, without revealing the implementation source code. Ada specification files therefore are similar in purpose to C header files. The interface to the mathcw library is defined as an Ada package specification in the file mathcw.ads. Because the implementation is in the C language, there is no need for a separate body file.

A.1 Building the Ada interface

Before looking at the source code of the Ada interface, it is useful to see how it is built and used in a small test program. Initially, we have just three hand-coded ﬁles in the ada subdirectory:

%cdada %ls Makefile mathcw.ads test.adb

The Makefile contains the rules for the build process, the second file contains the Ada specification, and the last file contains the test program. Ada is unusual in that it is a requirement of the language that the compiler manage source-file dependencies, so that it is impossible to compile and link a program with interface inconsistencies. The GNU gnatmake tool satisfies that mandate, managing compilation of files in the correct order, and then linking them into an executable program. That tool requires a lengthy list of options that are recorded in the Makefile. They include options that supply the installed location of the mathcw library, which can be either a static library, or a shared library. The make utility manages the build, which looks like this on a GNU/LINUX system:

% make test

gnatmake -gnaty test.adb -L/usr/local/lib -aO/usr/local/lib -largs -lm -Xlinker -R/usr/local/lib -lmcw

gcc -c -gnaty test.adb

gcc -c -gnaty mathcw.ads

gnatbind -aO./ -aO/usr/local/lib -I- -x test.ali

gnatlink -L/usr/local/lib -lm -Xlinker -R/usr/local/lib -lmcw test.ali

Only the gnatmake command is specified in the Makefile. That program examines the source-code file, test.adb, and determines that both that file and the mathcw.ads file must be compiled by gcc, which it then automatically invokes. Next, it runs gnatbind to perform various required consistency checks. Finally, it runs gnatlink to link the object files and libraries recorded in the test.ali file (output by gcc) into the target executable program, test. After the make steps, the ls utility displays a list of all of the files in the directory:

%ls Makefile mathcw.ali test test.ali mathcw.ads mathcw.o test.adb test.o

Sites that use Ada extensively are likely to have a standard set of directories in which to store interface files, such as mathcw.ads, and in such a case, that file would be installed in one of those directories. However, there are no widely used conventions for the names of directories for locally installed Ada packages, so the Makefile cannot provide a system-independent install target. For simplicity, here we just store the interface and the test program in the same directory. The final step is to run the test program:

% ./test

Test of Ada interface to MathCW library

x MathCW.erff () MathCW.erfcf () -4.00E+00 -1.00000E+00 2.00000E+00 -3.75E+00 -1.00000E+00 2.00000E+00 ... 3.75E+00 1.00000E+00 1.13727E-07 4.00E+00 1.00000E+00 1.54173E-08

x MathCW.erf () MathCW.erfc () -4.00E+00 -9.99999984582742E-01 1.99999998458274E+00 -3.75E+00 -9.99999886272743E-01 1.99999988627274E+00 ... 3.75E+00 9.99999886272743E-01 1.13727256569797E-07 4.00E+00 9.99999984582742E-01 1.54172579002800E-08

x MathCW.erfl () MathCW.erfcl () -4.00E+00 -9.99999984582742100E-01 1.99999998458274210E+00 -3.75E+00 -9.99999886272743430E-01 1.99999988627274343E+00 ... 3.75E+00 9.99999886272743430E-01 1.13727256569796653E-07 4.00E+00 9.99999984582742100E-01 1.54172579002800189E-08

Here, we trimmed trailing zeros from the reported x values to make the output ﬁt the page.

A.2 Programming the Ada interface

The public part of the interface speciﬁcation in mathcw.ads begins like this, introducing four mathematical constants that are also present in the standard Ada numerics package:

with Interfaces.C;

package MathCW is A.2. Programming the Ada interface 913

PI : constant := 3.14159_26535_89793_23846_26433_83279_50288_41971;

PI_2 : constant := PI / 2.0;

Sqrt_Two : constant := 1.41421_35623_73095_04880_16887_24209_69807_85696;

Log_Two : constant := 0.69314_71805_59945_30941_72321_21458_17656_80755;

The constants are specified with sufficient precision for 128-bit floating-point arithmetic, and illustrate the useful Ada practice of separating digit groups with underscores to improve readability. That feature is sadly lacking from almost all other programming languages, and is trivial to implement in a compiler. The constants have no declared type; instead, they are converted as needed with a type wrapper, such as Float (PI). The constants are followed by a large block of function declarations that define the names, argument types, and return values of all of the functions in the mathcw library that can be accessed from Ada programs:

-- ======Standard MathCW names ======

function Acosf (X : Float) return Float; function Acoshf (X : Float) return Float; function Adxf (X : Float; N : Integer) return Float; ... function Urcw3f return Float; function Urcw4f return Float; function Urcwf return Float; ... function Acos (X : Long_Float) return Long_Float; function Acosh (X : Long_Float) return Long_Float; function Adx (X : Long_Float; N : Integer) return Long_Float; ... function Urcw3 return Long_Float; function Urcw4 return Long_Float; function Urcw return Long_Float;

function Acosl (X : Long_Long_Float) return Long_Long_Float; function Acoshl (X : Long_Long_Float) return Long_Long_Float; function Adxl (X : Long_Long_Float; N : Integer) return Long_Long_Float; ... function Urcw3l return Long_Long_Float; function Urcw4l return Long_Long_Float; function Urcwl return Long_Long_Float;

Notice that Ada functions without arguments lack the empty parentheses that are required in C. Next, the interface deﬁnes synonyms with the traditional names used in the Ada numerics library:

-- ======Standard Ada names with C-like suffixes ======

function Arccosf (X : Float) return Float; function Arcsinf (X : Float) return Float; function Arctanf (X : Float) return Float; ...

Unfortunately, the match between Ada and C is imperfect in several areas:

I The source code of Ada programs is case insensitive. The Ada convention for spelling is that keywords are lowercase, function names are capitalized, and variables are uppercase. The gnatmake option -gnaty that we use requests fastidious style checking so that deviations from those conventions can be identiﬁed and corrected. One possibly surprising rule is that a function name must be separated from its parenthesized argument list by at least one space, contrary to centuries-old mathematical practice. 914 Appendix A. Ada interface

I Ada has a power operator, **, but C does not.

I Ada treats the ceiling, ﬂoor, and round operations as type properties, rather than as functions, although their use is quite similar. For example, the Ada code Float’Ceiling (X) corresponds to the C code ceilf(x). Similarly, Float’Rounding (X) corresponds to roundf(x): both round halfway cases away from zero, independent of the current rounding direction. Ada’s Float’Unbiased_Rounding (X) rounds halfway cases to the nearest even integer, like C’s rintf(x) when the rounding direction is set to the IEEE 754 default.

I The Ada absolute-value operation uses a function-like operator, Abs (x).

I Ada provides generic names for the elementary functions. For example, as long as the appropriate library packages are included, the call Sqrt (x) selects a version of the square-root function that is appropriate for the type of the argument expression.

I Functions that return additional values by storing values into locations given by pointer arguments, such as C’s frexpf(x,&n), have no direct analogue in Ada. However, they are easily handled with arguments declared with the in out keyword pair, indicating that the arguments are assigned values in the function, and those new values are visible to the caller on return from the function.

I Ada provides no access to the IEEE 754 exception ﬂags, precision control, or rounding modes. Indeed, there is no mention of IEEE 754, and only three brief references to the IEC 60559:1989 Floating-Point Standard, in the Ada 95 Reference Manual, along with one remark about a possible future Ada binding to that standard.

It is unclear whether it is possible to offer a generic interface to the mathcw library, so the current interface in mathcw.ads does not attempt to do so. The private part of the interface speciﬁcation in mathcw.ads comes next:

private pragma Import (C, Acosf, "acosf"); pragma Import (C, Acoshf, "acoshf"); ... pragma Import (C, Urcw4f, "urcw4f"); pragma Import (C, Urcwf, "urcwf");

pragma Import (C, Acos, "acos"); pragma Import (C, Acosh, "acosh"); ... pragma Import (C, Urcw4, "urcw4"); pragma Import (C, Urcw, "urcw");

pragma Import (C, Acoshl, "acoshl"); pragma Import (C, Acosl, "acosl"); ... pragma Import (C, Urcw4l, "urcw4l"); pragma Import (C, Urcwl, "urcwl");

pragma Import (C, Arccosf, "acosf"); pragma Import (C, Arcsinf, "asinf"); ...

The pragma statements tell the Ada compiler what language the external routines are written in, and give their names in Ada and in the other language. The remainder of the interface speciﬁcation in mathcw.ads provides hints to the compiler about inlining, and tells which functions are known to be pure, that is, produce the same result on successive calls with the same argument:

pragma Inline (Acosf); pragma Inline (Acoshf); A.3. Using the Ada interface 915

... pragma Pure_Function (Acosf); pragma Pure_Function (Acoshf); ... end MathCW;

Because they produce different results on each call, the random-number generator routines are excluded from the declarations of pure functions.

A.3 Using the Ada interface

The test program, test.adb, used on page 912 demonstrates the use of the library interface, mathcw, for Ada. As usual in Ada programs, it begins with a list of required packages:

with Ada.Text_IO; use Ada.Text_IO;

with Ada.Float_Text_IO; use Ada.Float_Text_IO;

with Ada.Long_Float_Text_IO; use Ada.Long_Float_Text_IO;

with Ada.Long_Long_Float_Text_IO; use Ada.Long_Long_Float_Text_IO;

with MathCW; use MathCW;

The with statement imports the package, and the use statement tells the compiler that the long qualifying package names can be omitted from invocations of the package routines. Four standard Ada packages are needed for output statements in the test program, and the gnat system knows how to find them all. By gnat convention, the mathcw package is known to be found in a file with a lowercase name matching the package name, followed by an extension for an Ada specification file: mathcw.ads. Next comes the body of the test program, although here we omit code from the two sections that handle the double- and extended-precision tests, because they are similar to the single-precision code:

procedure Test is X : Float; Y : Long_Float; Z : Long_Long_Float;

begin New_Line; Put ("Test of Ada interface to MathCW library"); New_Line; New_Line;

Put ("x"); Put (ASCII.HT); Put (ASCII.HT); Put ("MathCW.erff ()"); Put (ASCII.HT); Put ("MathCW.erfcf ()"); New_Line;

X := -4.0; 916 Appendix A. Ada interface

while X <= 4.0 loop

Put (X); Put (ASCII.HT); Put (Erff (X)); Put (ASCII.HT); Put (erfcf (X)); New_Line;

X := X + 0.25; end loop;

-- ... code omitted ... end Test;

The verbose output code is typical of Ada, which overloads a single function, Put(), for text output. Consequently, a separate implementation of that function is needed for each data type. That in turn accounts for the sequence of with statements at the beginning of the ﬁle. A second test program, perf.adb, in the mathcw package carries out performance comparisons between the Ada and C versions of some the library functions. It too can be built and run under control of the UNIX make utility:

% make check-perf ... Performance test of Ada interface to MathCW library

Average wall-clock time for 2000000 calls to Ada.Abs() = 9 nsec Average wall-clock time for 2000000 calls to MathCW.Fabs() = 21 nsec Performance: (MathCW.Fabs() time) / (Ada.Abs() time) = 2.49372E+00 ... Average wall-clock time for 2000000 calls to Ada.Tanh() = 151 nsec Average wall-clock time for 2000000 calls to MathCW.Tanh() = 186 nsec Performance: (MathCW.Tanh() time) / (Ada.Tanh() time) = 1.22695E+00

Cumulative performance summary

Average wall-clock time for 2000000 calls to Ada.ANY() = 148 nsec Average wall-clock time for 2000000 calls to MathCW.ANY() = 112 nsec Performance: (MathCW.ANY() time) / (Ada.ANY() time) = 7.59194E-01

The relative performance is, of course, expected to vary signiﬁcantly across platforms, particularly because the functions have quite different implementations in the two languages, but it is evident that there is no signiﬁcant overhead from the interlanguage communication. The full benchmark report shows that the mathcw functions are usually faster than the Ada library ones, and the summary shows a 25% average improvement over the Ada library on that system. B C# interface

THE C# NAME WAS MUSICALLY INSPIRED.ITISAC-STYLE LANGUAGE THAT IS A STEP ABOVE C/C++, WHERE SHARP (#) MEANS A SEMI-TONE ABOVE THE NOTE.

—JAMES KOVACS (2007).

The C# programming language1 [C#03b, HWG04, ECM06a, HWG06, C#06a, JPS07, HTWG08, HTWG11] is designed to run on top of a standardized virtual machine called the Common Language Infrastructure (CLI) [CLI03, CLI05, CLI06, ECM06b, MR04]. Microsoft’s implementation of that virtual machine is part of their .NET Framework, and several other languages also share the Common Language Runtime (CLR) library environment built on top of the CLI virtual machine [AHG+04]. That design has several important beneﬁts:

I Interlanguage communication is greatly facilitated. Programmers can use the language that works best for a given task, without losing access to software written in every other language that runs in the CLR.

I The CLR provides a uniform run-time library and operating system interface for all languages, eliminating the duplication that has historically plagued all programming languages.

I The virtual machine layer between most software and the underlying hardware makes migration to other, and future, hardware platforms trivial once the CLI has been ported. Long experience in the computing industry shows that software usually outlives the hardware on which it was developed, so hardware independence is often an important software design goal.

I Because a substantial part of any modern operating system is largely independent of the details of the underlying hardware, the virtual machine layer can be moved from its current position between user software and the operating system, to between the operating system and the hardware. That can make almost the entire operating system independent of hardware. Only device drivers need to have knowledge of hardware details, and once devices are themselves standardized and virtualized, that last shred of hardware dependence can also be eliminated.

Just as the Java Virtual Machine helped to make a uniform Java programming environment widely available on most popular operating systems and hardware platforms, it seems likely that many programming languages will be available on the CLI. An interface to the mathcw library from the CLR then makes the library immediately available in every language that can be compiled for the CLI virtual machine. The DotGNU Project2 and the Mono Project3 are free-software reimplementations of the CLR and the CLI virtual machine. The C# interface described in this appendix was developed on installations of the Mono system on multiple operating systems and CPU architectures, including Microsoft WINDOWS on IA-32 systems. The C# interface was also tested in installations of the DotGNU system on several platforms.

B.1 C# on the CLI virtual machine

The Common Language Infrastructure (CLI) virtual machine offers support for 32-bit and 64-bit two’s-complement integers, and 32-bit and 64-bit ﬂoating-point values. CLI implementations can offer either 32-bit or 64-bit byte addressing, and all binary values are stored in little-endian format.

1There is an extensive bibliography of publications about C# at http://www.math.utah.edu/pub/tex/bib/index-table-c.html#csharp. 2See http://www.gnu.org/projects/dotgnu/. 3See http://www.mono-project.com/.

The CLI provides integer arithmetic instructions that silently wrap around on overflow, and a companion set that trap on overflow. Integer arithmetic in the C# language follows most other languages in defaulting to undetected overflow, but provision is made for checking for, and recovering from, integer overflow. Here is a code fragment that illustrates how an overflow can be caught and handled:

try { checked{i=j+k;}; } catch (System.OverflowException) { Console.WriteLine("OverflowException: lasti="+i); i = 0x7fffffff; }

Unfortunately, the floating-point architecture defined in the CLI specification [ECM06b, pages I-67ff] is a subset of the requirements of IEEE 754. Here are the principal features of the CLI floating-point design:

I NaN and Infinity are fully supported, and computation is always nonstop, unless use is made of the CLI instruction ckfinite, which generates an exception if the result is NaN or Infinity. However, C# provides no way to execute that instruction after every floating-point operation. The try/checked/catch approach works for integer arithmetic, but not for floating-point arithmetic.

I Whether subnormals are supported or not is unspecified. Current implementations do provide them. In the language of the CLI specification: This standard does not specify the behavior of arithmetic operations on denormalized [subnormal] floating-point numbers, nor does it specify when or whether such representations should be created.

I There are no provisions for trapping ﬂoating-point exceptions, just as most current hardware architectures cannot trap exceptions either.

I There is only one rounding mode, the IEEE 754 default of round to nearest, with ties rounded to the closest even value.

I Conversion from ﬂoating-point to integer values truncates toward zero, but the Common Language Runtime (CLR) library environment provides additional rounding directions.

I There are no sticky ﬂags that record ﬂoating-point exceptions.

I The CLI is permitted to carry out intermediate ﬂoating-point computations in a precision and range that is greater than that of the operands.

I The bit patterns in NaNs, and the result of converting between float and double NaNs, are deﬁned to be platform dependent.

I There is only one type of NaN, not the separate quiet and signaling NaNs required by the IEEE 754 Standard.

Those choices were undoubtedly made to allow the CLI to be implemented efficiently on a wide range of current CPU architectures. Regrettably, they also force the many into perpetual suffering for the sins of the few, because the CLI will long outlive all current hardware. For floating-point software, it would have been much better to rectify the design flaws of past systems with an arithmetic system in the CLI that is strictly conformant with IEEE 754, and equipped with full support for the 128-bit floating-point format as well.

B.2 Building the C# interface

Before we look at the details of the C# interface code, it is helpful to see how the interface to the mathcw library is built. Initially, we have just a few ﬁles in the csharp directory: B.2. Building the C# interface 919

% cd csharp

%ls Makefile mathcw.cs test01.cs test03.cs test05.cs test07.cs README okay test02.cs test04.cs test06.cs test08.cs

The Makefile contains the rules for the build process, and the mathcw.cs file contains the interface definitions. The test*.cs source files are simple tests of some of the library routines. The Mono C# compilers are unusual in that they do not generate object files, but instead, compile and link directly to executable programs, called assemblies in C# documentation. By contrast, the DotGNU compiler, cscc, generates normal object files. The make utility directs the build, here using one of two compilers from the Mono Project (the other, older, compiler is called mcs):

% make gmcs test01.cs gmcs test02.cs gmcs test03.cs gmcs test04.cs gmcs test05.cs gmcs test06.cs mathcw.cs gmcs test07.cs mathcw.cs gmcs test08.cs mathcw.cs

The first five tests have internal definitions of a small interface to the mathcw library, so their compilation does not require the mathcw.cs file. Notice that none of the compilation steps specifies the name or location of the mathcw library. The interface code specifies its name, but the compiler and linker do not access the library at all. Library search rules allow the library to be located at run time, and the needed routines are then dynamically loaded from the library on the first reference to each of them. After the build, we have these files:

%ls Makefile test01.cs test03.cs test05.cs test07.cs README test01.exe test03.exe test05.exe test07.exe mathcw.cs test02.cs test04.cs test06.cs test08.cs okay test02.exe test04.exe test06.exe test08.exe

The executable programs have the ﬁle extension .exe, even on Unix systems. They cannot be run in isolation, but instead, as with Java programs, must be run on the virtual machine. A simple validation test runs each program, comparing its output with correct output stored in the okay subdirectory:

% make check

There should be no differences reported, just the test names:

======test01.exe ... ======test08.exe

The command that runs each test looks something like this:

env LD_LIBRARY_PATH=.. mono test01.exe

The CLI virtual machine is the mono program on that system. The library path that is temporarily set for the duration of the command informs the run-time loader that the shared object library is found in the parent directory, instead of in the normal system library directories. 920 Appendix B. C# interface

B.3 Programming the C# interface

The C# interface to the mathcw library is stored in the file mathcw.cs, and that file must be compiled with any code that needs it, as illustrated by the test program compilations on page 919. There no conventions yet of where such shared code could be stored so as to be available to every C# programmer on the system, so we assume that programmers will simply keep private copies. The interface defines function prototypes with instructions of where to find them, and how to call them. To do so, it needs language features that are defined in two standard namespaces, so the file begins with using statements for them:

using System; using System.Runtime.InteropServices;

As in the C++ and Java interfaces, the function prototypes are defined in a class whose name qualifies the function names when they are used. The functions themselves are loaded dynamically from a shared library when they are first referenced at run time, so that class begins with a definition of the name of the library:

public sealed class MathCW { private const String LIBNAME = "libmcw";

The sealed modifier prevents other classes from being derived from that class; a similar restriction is used in the Java interface. Only the base name of the library is given here for the value of LIBNAME. At run time, a suitable system- dependent suffix is added to it: .dll on Microsoft WINDOWS, .so on most UNIX systems, or .dylib on MAC OS X systems. At the time of writing this, the Mono Project on MAC OS X incorrectly uses .so as the suffix, so the shared library is installed under two names on that platform, libmcw.dylib and libmcw.so. On UNIX and MAC OS X systems, it is conventional for shared libraries to carry version numbers, with a symbolic link from the latest version to a library filename without a number. That is important, because changes to a shared library could invalidate executables that were already linked to a previous version of the library. The inability to deal with that on current Microsoft WINDOWS systems is widely referred to as the DLL hell, where installation of a new software package breaks already-installed and completely unrelated packages by replacing a shared library with a new one with the same name, but incompatible contents. With other programming languages on those systems, the linker can record in the executable program the specific library versions required. In the Mono Project, the linker does not read the shared libraries, because they are not needed until run time. However, it is possible to bind a particular library version number to a program with a small manually created configuration file. For example, to indicate that myprog.exe requires version 1.2.3 of the mathcw library, the companion file myprog.exe.config would contain these three lines:

In practice, that should rarely be necessary, because the mathcw library is based on an ISO standard, and is expected to be stable. Existing function prototypes are guaranteed to be constant, but new functions might be added in future versions of the library. Such additions do not invalidate any existing programs linked against the shared library. The mathcw.cs file continues with the definitions of two mathematical constants that are also defined in the standard C# Math class:

public const double E = 2.718281828459045235360287; public const double PI = 3.141592653589793238462643;

Next comes a long list of function prototypes for the single-precision functions:

[ DllImport(LIBNAME) ] public static extern float acosf (float x); [ DllImport(LIBNAME) ] public static extern float acoshf(float x); ... [ DllImport(LIBNAME) ] public static extern float frexpf (float x, ref int n); ... B.3. Programming the C# interface 921

[ DllImport(LIBNAME, CharSet=CharSet.Ansi) ] public static extern float nanf (string s); ... [ DllImport(LIBNAME) ] public static extern float urcw3f(); [ DllImport(LIBNAME) ] public static extern float urcw4f();

In each prototype, the square brackets contain a C# attribute list, a feature rarely seen in other programming languages. The DllImport() function is defined in the System.Runtime.InteropServices namespace. In the common case, it has only a single argument that provides the library name. However, the mathcw library contains a few functions with arguments that are pointers to numeric values or strings, and for them, the attribute list is more complicated. Unlike Java, the C# language has pointers, but with restrictions. The C-style int *n declarations and &n arguments are supported, but only when the construct is qualified with the unsafe modifier. When that feature is used, the Mono Project compilers require an additional option, -unsafe. The intent is to make clear to the programmer and the user that danger lurks. However, there is another way to deal with pointer arguments that does not require the unsafe modifier, and that is to identify a call-by-reference argument with either the ref modifier or the out modifier, which must be used in the prototype, as well as in every call to the function. The two modifiers are quite similar, except that ref requires initialization before use. The standard C# Math class uses out modifiers, so we do as well to guarantee identical calling sequences for the functions common to both classes. In reality, a called routine written in another language could still wreak havoc on its caller by overwriting memory before and after the passed location, but a native C# program cannot. C# and Java both use the Unicode character set in UTF-16 format, but C on modern systems expects 8-bit characters in normal strings. The C prototype nanf(const char *s) thus needs some additional processing to translate the C# Unicode string, and that is what the CharSet modifier does. The double-precision function prototypes make up the next big block in mathcw.cs:

[ DllImport(LIBNAME) ] public static extern double acos(double x); [ DllImport(LIBNAME) ] public static extern double acosh(double x); ... [ DllImport(LIBNAME) ] public static extern double urcw3(); [ DllImport(LIBNAME) ] public static extern double urcw4();

Because the CLI virtual machine contains only 32-bit float and 64-bit double ﬂoating-point types, C# offers only those types, so there is no way to access the long double section of the mathcw library, or the float nexttowardf() and double nexttoward() functions, which have a long double argument. As in the Java interface, we want the C# MathCW class to be a superset of the standard Math class. All of the function names in the C# Math class are capitalized, so we provide native wrapper functions that just call their lowercase companions:

public static float Acosf (float x) { return acosf (x); } public static float Acoshf (float x) { return acoshf (x); } ... public static float Urcw3f () { return urcw3f (); } public static float Urcw4f () { return urcw4f (); }

public static double Acos (double x) { return acos (x); } public static double Acosh (double x) { return acosh (x); } ... public static double Urcw3 () { return urcw3 (); } public static double Urcw4 () { return urcw4 (); }

The standard Math class in C# is an eclectic mixture of numerical functions for different data types. For floating- point arguments, in most cases, only the double version is provided, because the language allows overloaded function names; the compiler picks the right version based on the argument types. The final block of code in the mathcw.cs file therefore provides replacements for each of the remaining functions in the Math class, so that simply by changing the class name Math to MathCW everywhere it is used in a C# program, the mathcw library can be used in place of the standard library: 922 Appendix B. C# interface

public static decimal Abs (decimal value) { return Math.Abs (value); } public static double Abs (double a) { return fabs (a); } public static float Abs (float a) { return fabsf (a); } public static int Abs (int value) { return Math.Abs (value); } ... public static double Sign (int value) { return Math.Sign (value);} public static double Sign (long value) { return Math.Sign (value);} public static double Sign (sbyte value) { return Math.Sign (value);} public static double Sign (short value) { return Math.Sign (value);} }

B.4 Using the C# interface

The C# interface to the mathcw library is easy to use because nothing special needs to be done, other than to compile the mathcw.cs ﬁle with the user program, and preﬁx the function names with the class name. Here is a shorter version of one of the test programs that illustrates how the frexpf() function can be used:

using System;

class short_test08 { static void Main() { for(intk=0;k<=24;++k) { float x, fx; int n;

x = (float)(1 << k); fx = MathCW.frexpf(x, out n);

if ((fx != 0.5F) || (n != (k + 1))) Console.Write("ERROR: ");

Console.WriteLine("MathCW frexpf("+x+",->"+n+")="+fx); } } }

Notice that the call to frexpf() requires the out modiﬁer on the second argument, because the exponent of the ﬁrst argument is stored there on return. C C++ interface

AFTER TWO YEARS OF C++ PROGRAMMING, IT STILL SURPRISES ME.

—YUKIHIRO MATSUMOTO DESIGNER OF THE RUBY LANGUAGE (2003).

With the exception of a small number of disagreements that most programmers need not encounter, the C++ language is effectively a strongly typed superset of the C language. Thus, as long as a C program has prototypes for all functions, and does not use as variables any of the new reserved words in C++, it should be compilable with both C and C++ compilers. All of the C code in the mathcw library has that property. Similarly, a C++ program should have access to all of the facilities of the C language, including the many software libraries available for C. In particular, as long as the mathcw.h header ﬁle is included in a C++ program, the entire mathcw library is available, exactly like it is for C programs. Nevertheless, the extra features of the C++ language offer the possibility of doing more. The ability of C++ to overload functions, so that the same function name can be used for the same operation without regard to the data type, can be exploited by a suitable interface that we present in Section C.2 on the next page. As with other strongly typed languages, such as Ada, C#, and Java, function overloading depends on there being a distinguishing signature (the number and types of the function arguments). Most of the functions in the mathcw library can be provided under the same names as used for the double versions, because the functions have arguments that differ by numeric data type.

C.1 Building the C++ interface

Before we examine the source code for the C++ interface to the mathcw library, we ﬁrst show how to build and install the interface. Initially, we have just a few ﬁles in the cpp interface subdirectory:

%cdcpp %ls Makefile exp mathcw.hh okay test01.cc test02.cc test03.cc

The Makefile contains the rules for the build process, which is simple, because nothing actually needs to be built. Instead, all that is required is for the C++ interface header ﬁle, mathcw.hh, to be visible to the compiler when other code that uses the interface is processed. We can do a simple validation test with the usual recipe:

% make check

CC -g -DHAVE_LONG_DOUBLE -DHAVE_LONG_LONG -I. -I.. -c test01.cc

CC -g -DHAVE_LONG_DOUBLE -DHAVE_LONG_LONG -I. -I.. -o test01 test01.o -L.. -lmcw

...

There should be no output but the test names:

======test01 ======test02 ======test03

That test compiles and links the three programs, then runs them, comparing their output with output ﬁles in the okay subdirectory that are known to be correct. Installation is equally simple:

% make install

/bin/rm -f /usr/local/include/mathcw.hh

cp -p mathcw.hh /usr/local/include/

chmod 664 /usr/local/include/mathcw.hh

Installed files...

-rw-rw-r-- 1 mcw 20891 Mar 31 13:47 /usr/local/include/mathcw.hh

C.2 Programming the C++ interface

The C++ interface to the mathcw library is stored in a single file, mathcw.hh. The first part of the interface simply re- trieves the function prototypes and other definitions from the C file, mathcw.h, but it does so inside a C++ namespace, so that the function names can later be qualified with the namespace name to disambiguate them from identically named C++ wrapper functions:

namespace C { #include

// Remove macro definitions that conflict with our functions:

#undef isfinite #undef isgreater ... #undef isunordered #undef signbit }

The namespace wrapper provides one other useful service: it makes the names in the C header file inaccessible unless qualified with the namespace name, or under the scope of a using statement for the namespace. The #undef directives are needed on some systems to prevent unwanted macro substitutions later in the interface. The main part of the interface file comes next. It is just a long list of public wrappers inside a class definition, so we need only show a few of them:

class MathCW { public: inline float (acos)(float x) { return (C::acosf(x)); } // ... code omitted ... inline double (acos)(double x) { return (C::acos(x)); } // ... code omitted ... inline long double (acos)(long double x) { C.3. Using the C++ interface 925

return (C::acosl(x)); } // ... code omitted ... };

The wrappers define the overloaded C++ functions. The C:: prefix in their return statement expressions is the namespace qualifier; it ensures that the C versions of the functions are called. A few functions cannot be provided under generic names because they lack distinguishing signatures. They include the NaN-generator function families nanf(), qnanf(), and snanf(). They also include most of the routines in the random-number generator family: urcwf(), urcw1f(), urcw2f(), urcw3f(), urcw4f(), and so on. All of those functions are available under their own names. Even though there are references to all of the functions in the mathcw library in the MathCW class, only those that are actually called are present in the executable program. In addition, most modern C++ compilers optimize the wrappers away entirely, eliminating all of the class overhead.

C.3 Using the C++ interface

The MathCW class provides a new data type to C++ programs that serves mainly as a preﬁx on the library function names. Here is a short C-like program, available in the test01.cc ﬁle, that shows how the class is used:

#include #include #include

int main(void) { float x; double y; MathCW mcw;

x = 1.0F; (void)printf("mcw.erf(%g) = %.6g\n", (double)x, (double)mcw.erf(x)); y = 2.0; (void)printf("mcw.erf(%g) = %.14g\n", y, mcw.erf(y));

#if defined(HAVE_LONG_DOUBLE) long double z;

z = 3.0L; (void)printf("mcw.erf(%Lg) = %.16Lg\n", z, mcw.erf(z)); #endif

return (EXIT_SUCCESS); }

We use the simpler C-style output statements here to keep the test program small. Compilation and running of the test program is handled by the Makefile, but we can also do it manually:

% CC -DHAVE_LONG_DOUBLE -I.. -I. test01.cc && ./a.out mcw.erf(1) = 0.842701 mcw.erf(2) = 0.99532226501895 mcw.erf(3) = 0.9999779095030014

The companion test ﬁles, test02.cc and test03.cc, use the much more verbose native C++ output statements. The second of these two ﬁles exploits template expansion to provide another level of abstraction. However, their code is not of particular interest here, so we omit it. D Decimal arithmetic

THE EARLIEST DEFINITE DATE ASSIGNED FOR THE USE IN ARABIA OF THE DECIMAL SYSTEM OF NUMERATION IS 773 [CE]. IN THAT YEAR SOME INDIAN ASTRONOMICAL TABLES WERE BROUGHT TO BAGDAD, AND IT IS ALMOST CERTAIN THAT, IN THESE, INDIAN NUMERALS (INCLUDING A ZERO) WERE EMPLOYED.

—WALTER WILLIAM ROUSE BALL A Short Account of the History of Mathematics (1888).

The nature of electronic computers gives the binary number system special significance, because two states, corresponding to the binary digits 0 and 1, can be represented by card holes, CD and DVD spots, electrical circuits, magnetization, and so on. Although a few computers built in the 1950s and 1960s used native decimal arithmetic (see Table H.1 on page 948, and Cowlishaw’s historical survey [Cow03]), it still has to be represented at a lower level in hardware in terms of bits. That in turn means additional overhead in converting stored decimal numbers into binary numbers for computation, and the reverse conversion as numbers are moved from CPU to storage. The execution-time penalty and competitive market forces therefore combine to discourage decimal arithmetic, except in devices, such as hand-held calculators, where speed does not matter. Speed is less important for computations where relatively few numerical operations are carried out on input data, as in business data processing. Programming languages, such as Ada, COBOL, PL/1, and C# (see Section 4.27 on page 101), that are designed to support business applications offer fixed-decimal arithmetic. Although that is adequate for most monetary computations, it is untenable for scientific computation because of the need for frequent rescaling of fixed-point numbers to avoid digit loss. Indeed, the programmatic difficulty of handling the scaling problem led to the introduction of floating-point arithmetic in computers in the mid-1950s, and for almost all computers today, that means binary arithmetic based on the IEEE 754 Standard.

D.1 Why we need decimal ﬂoating-point arithmetic

Binary arithmetic is unfamiliar to most humans, and for some tasks, can always get the wrong answer. A popular example of that problem is sales-tax computation, such as 5% of an amount 0.70 in some arbitrary currency unit. The exact answer for the total is 1.05 × 0.70 = 0.7350, and that value rounded to the nearest even is 0.74. In binary arithmetic, however, the simple factor 1.05 cannot be represented exactly: its value has an infinite fraction represented in hexadecimal form as 0x1.0ccccc...p0. The required product, +0x1.7851eb851eb85...p-1, produces the decimal number 0.7349999 . . . , no matter how large the numeric precision. Under both round-to-nearest and round-to- zero (chopping) rules, the final result is 0.73, which is off by one in the last digit. Although that seems like a trivial amount, it produces substantial errors in the accounts of a business with large numbers of small transactions, such as a grocery store or telephone company. Also, it violates rounding rules for business and tax computations in some countries, which may require one additional rule beyond the four provided in IEEE 754 binary arithmetic: round- half-up (0.735 → 0.74). Our sales-tax example is still computed incorrectly in binary arithmetic with the round-half-up rule. For symmetry, decimal arithmetic may also provide the rule round-half-down (0.735 → 0.73). By about 2000, the dramatic computer performance and storage improvements over several decades made it desirable to reexamine decimal floating-point arithmetic. IBM led the way by implementing decimal floating-point arithmetic in firmware in 2006 in the z9 mainframe CPU [IBM06, DDZ+07]. It followed that with hardware implementations in the PowerPC version 6 CPU in 2007 [TSSK07], and in the z10 CPU in 2008 [Web08, SKC09]. However, unlike historical machines, that arithmetic is in addition to conventional IEEE 754 binary floating-point arithmetic, and for the z9 and z10, also hexadecimal floating-point arithmetic. For a good survey of hardware-design considerations for decimal arithmetic, see [WET+10]. The latest work as this book went to press reports dramatic advances on

© Springer International Publishing AG 2017 927 N.H.F. Beebe, The Mathematical-Function Computation Handbook, DOI 10.1007/978-3-319-64110-2 928 Appendix D. Decimal arithmetic the IBM z13 mainframe in the speed of decimal ﬂoating-point arithmetic, and the sharing of much low-level circuitry for both binary and decimal operations [LCM16]. In 2005, ISO committees for the standardization of the C and C++ languages received proposals for the addition of decimal ﬂoating-point arithmetic [Kla05, C06b, C06c, C06d, C09]. In 2006, GNU developers of compilers for those languages added preliminary support on one CPU platform for the new data types. Those compilers allowed extended development and testing of the mathcw library code for decimal arithmetic, a task that previously had been possible only by using decimal types remapped to binary types.

D.2 Decimal ﬂoating-point arithmetic design issues

IBM based its decimal hardware designs partly on its long experience with the Rexx and NetRexx scripting languages [Cow85, Cow90, Cow97], which provide arbitrary-precision decimal arithmetic (up to 109 digits) with an exponent range of [−999 999 999, +999 999 999]. That range is so large that overflow and underflow are unlikely in most practical computations, and indeed, those languages treat those two conditions as errors. IBM’s other design guides were the IEEE 854 Standard [ANS87] for radix-independent floating-point arithmetic, and the existence in several programming languages of a large software base written for IEEE 754 binary floating- point arithmetic. In particular, IBM felt it desirable for decimal formats to have approximately the same range and precision as binary formats with the same storage requirements. Also, there was considerable existing practice on some architectures and in commercially important programming languages:

I IBM mainframes have had hardware support for packed-format decimal ﬁxed-point arithmetic with up to 31 digits since 1964 [FIS64, POP64] (see [IBM70, Chapter 5] for programming examples).

I Existing software libraries on some other platforms support 31-digit decimal arithmetic.

I Some models of the DEC PDP-10 from about 1976 had hardware support for 21-digit decimal ﬁxed-point arithmetic, and the VAX, and models of the older PDP-11 when equipped with the commercial instruction set, had similar support for 31-digit data.

I The Intel IA-32 architecture has had hardware support for 18-digit decimal ﬁxed-point arithmetic since the 8087 ﬂoating-point coprocessor was introduced in 1980. The AMD64, EM64T, and IA-64 architectures include the IA-32 decimal instructions.

I The Ada language provides decimal ﬁxed-point arithmetic with at least 18 digits [Ada95], and also includes a Packed_Decimal type that corresponds to COBOL’s packed-decimal type.

I Older ISO COBOL Standards require 18-digit decimal ﬁxed-point arithmetic.

I The 2002 ISO COBOL Standard [COB02] mandates 32-digit decimal ﬂoating-point arithmetic and a power-often exponent with at least three digits.

I The PL/1 language supports decimal arithmetic with at least 15 ﬁxed-point digits, and 33 ﬂoating-point digits.

I Most databases support storage of decimal ﬁxed-point data with at least 18 digits, and some allow up to 35 digits.

Those considerations led to improvements in the old BCD (binary-coded decimal) format, which stores one decimal digit in a four-bit nybble, and the later Chen–Ho encoding [CH75], which is more compact. IBM calls their new encoding Densely Packed Decimal (DPD) [Cow02], and its features are summarized in Table D.1 on the facing page and Figure D.1 on page 930. The significand size and exponent range in that encoding is large enough to handle almost everything in our list of existing practice. The IBM decNumber package [Cow07] provides an open-source reference implementation of Rexx-style decimal arithmetic with an additional software layer for converting to and from DPD arithmetic, and between native binary and DPD formats. Other encodings of decimal arithmetic are certainly possible. Researchers at Intel developed the Binary Integer Decimal (BID) format [CAH+07], summarized in Table D.2 on the facing page and Figure D.2 on page 930. The BID encoding represents the decimal coefficient as a binary integer, and computations are done in binary, allowing re-use D.2. Decimal floating-point arithmetic design issues 929

Table D.1: Extended IEEE-754-like decimal ﬂoating-point characteristics and limits in the IBM Densely Packed Dec- imal (DPD) encoding.

single double quadruple octuple Format length 32 64 128 256 Stored coefﬁcient digits 7 16 34 70 Precision (p) 7 16 34 70 Biased-exponent bits 8 10 14 22 EC bits 6 8 12 20 Minimum exponent −95 −383 −6143 −1 572 863 Maximum exponent 96 384 6144 1 572 864 Exponent bias 101 398 6176 1 572 932 Machine epsilon (10−p+1)10−6 10−15 10−33 10−69 Largest normal (1 − 10−7)1097 (1 − 10−16)10385 (1 − 10−34)106145 (1 − 10−70)101 572 865 Smallest normal 10−95 10−383 10−6143 10−1 572 863 Smallest subnormal 10−101 10−398 10−6176 10−1 572 932

Table D.2: Extended IEEE-754-like decimal ﬂoating-point characteristics and limits in the Intel Binary Integer Dec- imal (BID) encoding. Values are largely identical to those for DPD encoding, but shading indicates where there are differences.

single double quadruple octuple Format length 32 64 128 256 Stored coefﬁcient bits 23 or 21 53 or 51 113 or 111 233 or 231 Coefﬁcient digits 7 16 34 70 Precision (p) 7 16 34 70 Biased-exponent bits 8 10 14 22 Minimum exponent −95 −383 −6143 −1 572 863 Maximum exponent 96 384 6144 1 572 864 Exponent bias 101 398 6176 1 572 932 Machine epsilon (10−p+1)10−6 10−15 10−33 10−69 Largest normal (1 − 10−7)1097 (1 − 10−16)10385 (1 − 10−34)106145 (1 − 10−70)101 572 865 Smallest normal 10−95 10−383 10−6143 10−1 572 863 Smallest subnormal 10−101 10−398 10−6176 10−1 572 932

of circuitry in existing arithmetic units. Binary arithmetic makes correct decimal rounding difficult, but hardware engineers later found satisfactory solutions that avoid the need to convert from binary to decimal, round, and convert back [Inte06, TSGN07, TGNSC11]. BID encoding supports a larger range of coefficient values than a pure decimal representation. For example, in the first layout in Figure D.2 on the following page, with the 32-bit format there are 23 bits for the coefficient, representing integers up to 223 − 1 = 8 388 607. Larger numbers require the second layout, as long as the exponent field does not start with two 1 bits. The largest integer is then 0x9fffff = 10 485 759, beyond the pure decimal limit of 9 999 999. Thus, BID can exactly represent about 4.86% more numbers than DPD can. Software that exploits that feature of BID is not portable to systems with DPD, and despite the identical exponent range, rounding rules, and machine epsilon in the two encodings, the wider coefficient range of BID effectively means a small improvement in precision that can visibly affect final results. It remains to be seen whether BID implementations constrain representations to the exact range of DPD, thereby preventing those differences. The computing industry will likely require a few years of experience with both encodings, and their implementations in hardware, before architects can decide whether one of them has significant advantages over the other. Some view a single standard encoding of decimal data as highly desirable, because the existence of multiple encodings 930 Appendix D. Decimal arithmetic

s cf ec cc

bit 0 1 6 9 31 single 0 1 6 12 63 double 0 1 6 16 127 quadruple 0 1 6 22 255 octuple

Figure D.1: Extended IEEE-754-like decimal floating-point data layout in the IBM Densely Packed Decimal (DPD) format. s is the sign bit (0 for +, 1 for −). cf is the combination field containing two high-order bits of the unsigned biased exponent and the leading decimal digit of the coefficient. Infinity has a cf of 11110, and NaN has a cf of 11111. ec is the exponent continuation field with the remaining unsigned biased exponent bits. Quiet NaN has a high-order ec bit of 0, and signaling NaN has a high-order ec bit of 1. IBM zSeries documentation labels that field bxcf for biased exponent continuation field. cc is the coefficient continuation field with the remaining exponent digits in DPD encoding with three decimal digits in ten bits. The coefficient is an integer, with the decimal point at the right, which means there are redundant representations of numbers, and also that trailing zeros can be preserved, and may be significant to the user.

s exp coefﬁcient (10N + 3 bits)

bit 0 1 9 31 single 01 11 63 double 01 15 127 quadruple 01 23 255 octuple

s 11 exp low-order coefﬁcient (10N + 1 bits)

bit 0 1 3 11 31 single 0 1 3 13 63 double 0 1 3 17 127 quadruple 0 1 3 25 255 octuple

Figure D.2: Extended IEEE-754-like decimal floating-point data layout in the Intel Binary Integer Decimal (BID) format. s is the sign bit (0 for +, 1 for −). exp is the unsigned biased power-of-ten exponent field, with the smallest value reserved for zero and subnormal numbers. Its valid range is [0, 3 × 2w−2 − 1] when the exponent field is w bits wide. Infinity normally has a zero coefficient (but nonzero is permitted too), with exp of 11 110 . . . . Quiet NaN has exp of 11 111 0 . . . . Signaling NaN has exp of 11 111 1 . . . . Default NaNs have zero coefficients, but nonzero values are allowed. The remaining bits hold the coefficient when it fits in 10N + 3 bits (first layout). If it requires 10N + 4 bits (second layout), three high-order bits are supplied implicitly as 100 and followed by the remaining stored low-order coefficient bits, and the exponent field must then not start 11 . . . . The coefficient is an integer, with the decimal point at the right, which means there are redundant representations of numbers, and also that trailing zeros can be preserved, and may be significant to the user.

complicates exchange of native decimal ﬂoating-point data, but so do endian addressing differences. However, a textual representation of decimal data with the correct number of digits provides an exact exchange mechanism, and compactness can be regained by a general text-compression utility. The GNU compilers initially provided support for decimal ﬂoating-point arithmetic in only the DPD format, but later added a build-time option to choose BID encoding. However, at the time of writing this, the compilers convert data in the BID format to DPD for use with the decNumber library. D.3. How decimal and binary arithmetic differ 931

Although current compiler support provides access only to 32-bit, 64-bit and 128-bit decimal formats, it is a design goal of the mathcw library to support future 256-bit binary and decimal formats. The cited tables therefore include a ﬁnal column for such arithmetic, just as we show for binary arithmetic in Figure 4.1 on page 63 and Table 4.2 on page 65. The proposed exponent ranges are determined by packing constraints of the DPD format, where ten bits encode three decimal digits, and an additional high-order decimal digit is encoded in the combination ﬁeld. That implies that each format encodes 3n + 1 decimal digits. Together with the desirable feature that storage doubling from an m-decimal-digit format should provide at least 2m + 2 decimal digits, those constraints produce a 256-bit format holding 70 decimal digits. The remaining bits determine the exponent range, and then comparison of the binary and decimal ranges for the three smaller sizes produces a clear choice for the exponent range in the 256-bit binary format.

D.3 How decimal and binary arithmetic differ

IEEE 754 binary floating-point arithmetic provides a hidden significand bit for normalized numbers in all but the 80-bit format, plus representations of Infinity, quiet and signaling NaN, and subnormal numbers. Nonzero normal numbers are represented as the product of a significand in [1, 2) and an integer power of two. Thus, the binary point lies to the left of the first stored fraction bit. With decimal arithmetic, no hidden digit is possible for normal numbers, because there are nine possibilities instead of just one. Decimal floating-point arithmetic supports Infinity and two kinds of NaNs, but their encoding uses explicit bit patterns in the DPD cc and ec fields, or the BID exp field, that permit them to be recognized solely by examination of those fields. By contrast, the IEEE 754 binary encoding requires examination of all significand bits to distinguish between Infinity and NaN. Fast identification of Infinity and NaN is important because they almost always require special handling, and as significand length increases, the binary format suffers a performance hit from that task. In the binary format, all vendors use the high-order fractional bit to identify quiet and signaling NaNs, although they do not agree on whether a 1 bit means quiet or signaling. Most choose the quiet interpretation, so that storage contents of all-bits-one is a negative quiet NaN, making it simple to initialize unset memory cells to be able to trap use before definition. Some vendor C compilers provide an option, usually called -trapuv, to request use of NaNs for initial values. We discuss bulk initialization in more detail in Section D.4 on page 935. Those differences are largely transparent to numerical programs and programmers. However, the next one is not. Decimal arithmetic places the decimal point at the right of the significand, so that decimal numbers are represented as the product of an integer coefficient and a power of ten. That choice was made for an important reason: it allows floating-point arithmetic to emulate fixed-point arithmetic for financial computations. Addition and subtraction of floating- point numbers with the same exponent are exact as long as overflow does not occur. Handling fixed-point arithmetic that way requires that computed results must not be renormalized, except by explicit request. The exponent must remain constant and it must be possible to check that the property holds at the end of a computation. The decNumberSameQuantum() function in the decNumber library tests whether two values have the same exponent, and the companion function decNumberQuantize() forces one value to have the same decimal exponent as another. Similar capabilities are present in the proposed decimal extensions to C, and the mathcw library supplies them with these prototypes:

#include

decimal_float quantizedf (decimal_float x, decimal_float y); decimal_double quantized (decimal_double x, decimal_double y); decimal_long_double quantizedl (decimal_long_double x, decimal_long_double y); decimal_long_long_double quantizedll (decimal_long_long_double x, decimal_long_long_double y);

int samequantumdf (decimal_float x, decimal_float y); int samequantumd (decimal_double x, decimal_double y); int samequantumdl (decimal_long_double x, decimal_long_double y); int samequantumdll (decimal_long_long_double x, decimal_long_long_double y);

For completeness, those functions have companions for binary arithmetic with the usual sufﬁxes f, none, l, and ll, although they are unlikely to be of much utility. 932 Appendix D. Decimal arithmetic

Table D.3: Behavior of the quantize() function. The third through ﬁfth examples show that quantization can cause rounding, here with the default round-to-nearest rule. The last decimal and binary examples show what happens when precision is lost.

Function call Result decimal quantized(+1.DD, +1.00DD) +1.00DD quantized(+100.DD, +1.00DD) +100.00DD quantized(+0.125DD, +1.00DD) +0.12DD quantized(+0.135DD, +1.00DD) +0.14DD quantized(+0.145DD, +1.00DD) +0.14DD quantized(+NaN(0x1234), +1.00DD) +NaN(0x1234) quantized(+100.DD, +NaN(0x1234)) +NaN(0x1234) quantized(+NaN(0x1234), +NaN(0x5678)) +NaN(0x1234) quantized(+∞, −∞) +∞ quantized(−∞, +∞) −∞ quantized(+100.00DD, −∞) +NaN quantized(−∞, +100.00DD) +NaN quantized(+1234567890123456.DD, +1.DD) +1234567890123456.DD quantized(+1234567890123456.DD, +1.0DD) +NaN binary quantize(+1., +0.02) +1. quantize(+100., +0.02) +100. quantize(+0.125, +0.02) +0.12 quantize(+0.135, +0.02) +0.14000000000000001 quantize(+0.145, +0.02) +0.14000000000000001 quantize(NaN(0x1234), +0.02) NaN(0x1234) quantize(+100., NaN(0x1234)) NaN(0x1234) quantize(NaN(0x1234), NaN(0x5678)) NaN(0x1234) quantize(+∞, −∞) +∞ quantize(−∞, +∞) −∞ quantize(+100.00, −∞) NaN quantize(−∞, +0.02) NaN quantize(+1234567890123456., +1.) +1234567890123456. quantize(+1234567890123456., +0.2) NaN

For example, quantized(x,y) sets x to have the same decimal exponent as y, and if both arguments are Infinity, the result is the first argument. Otherwise, if either argument is a NaN, the result is that argument, and if just one argument is Infinity, the result is a quiet NaN. If the operation would require more digits than are available, the result is a quiet NaN. If rounding is required, it obeys the current rounding mode. The purpose of the second argument is just to communicate a power of ten, so its particular coefficient digits are not significant. For decimal use, trailing zero digits are commonly used, so that 1.00 means quantize to two decimal digits. In financial computations, such operations are needed frequently, such as for rounding an amount to the nearest cent in several currency systems. For the binary companions of quantized(), the normalized floating-point format requires that the second argument be a fractional value chosen away from an exact power of ten, to avoid off-by-one errors in the inexact determination of the power of ten. Table D.3 shows examples of how that function works. Quantization also provides conversion to integers: quantized(x, 1.DD) is the whole number (in floating-point format) nearest to x, assuming the default rounding mode. The function samequantumd(x,y) returns 1 if the arguments have the same decimal exponent, and 0 otherwise. If the arguments are both Infinity, or both NaN, the return value is also 1. Table D.4 on the next page illustrates the workings of that function. One additional function is required for emulating fixed-point arithmetic: normalization of decimal values by removal of trailing zero digits. The decNumber library function decNumberNormalize() therefore has these counterparts in the mathcw library, even though they are absent from the proposals for standardization of decimal arithmetic in C and C++:

#include D.3. How decimal and binary arithmetic differ 933

Table D.4: Behavior of the samequantum() function. Notice the difference in the second of the binary and decimal examples: numbers of quite different magnitude can have the same scale in decimal, but in binary, because of normalization, they need to be within a factor of ten to have the same exponent. The third examples reﬂect the different normalization of binary and decimal values.

Function call Result decimal samequantumd(+1.00DD, +9.99DD) 1 samequantumd(+1.00DD, +9999.99DD) 1 samequantumd(+1.DD, +1.00DD) 0 samequantumd(+100.DD, +1.00DD) 0 samequantumd(+NaN(0x1234), +1.00DD) 0 samequantumd(+100.DD, +NaN(0x1234)) 0 samequantumd(+NaN(0x1234), +NaN(0x5678)) 1 samequantumd(+∞, −∞)1 samequantumd(−∞, +∞)1 samequantumd(+100.00DD, −∞)0 samequantumd(−∞, +100.00DD) 0 binary samequantum(+1.00, +1.9375) 1 samequantum(+1.00, +9999.75) 0 samequantum(+1., +1.00) 1 samequantum(+100., +1.00) 0 samequantum(NaN, +1.00) 0 samequantum(+100., NaN) 0 samequantum(NaN, NaN) 1 samequantum(+∞, −∞)1 samequantum(−∞, +∞)1 samequantum(+100.00, −∞)0 samequantum(−∞, +100.00) 0

decimal_float normalizedf (decimal_float x); decimal_double normalized (decimal_double x); decimal_long_double normalizedl (decimal_long_double x); decimal_long_long_double normalizedll (decimal_long_long_double x);

Like the earlier functions, companions for binary arithmetic have the usual suffixes f, none, l, and ll, but they simply return their arguments, because binary floating-point numbers are always normalized in modern floating- point architectures. Table D.5 on the following page shows some samples of the use of the decimal functions. Another consequence of storing decimal floating-point values with the decimal point at the right is that there are multiple representations of any number that does not use all significand digits. Thus, 1.DF, 1.0DF, 1.00DF, ..., 1.000000DF are numerically equal for comparison, yet have different storage representations equivalent to 1 × 100, 10 × 10−1, 100 × 10−2,...,1000000 × 10−6. Addition and subtraction of decimal values changes scale when exponents differ, and multiplication changes scale if trailing fractional zeros are present. Thus, the result of 1.DF * 1.234DF is 1.234DF, preserving the original value. However, 1.000DF * 1.234DF = 1.234000DF, an equal value of different scale with the representation 1234000 × 10−6. Programmers who expect to use decimal floating-point arithmetic to emulate fixed-point arithmetic therefore need to be careful to avoid altering scale. When the mathcw library was first tested with decimal arithmetic, several constants with trailing zeros had to be rewritten or trimmed, like these examples: 100.DF → 1.e2DF and 10.0 → 1.e1DF. Because many learn in school to write at least one digit on either side of a decimal point, and some programming languages require that practice (although the C-language family members do not), it is easy to make subtle scale-altering mistakes with decimal floating-point constants. Multiplication and division in general change the scale, and consequently, fixed-point computations require scale readjustment after such operations. In the sales-tax computation cited earlier, we could write code like this:

decimal_long_double amount, rate, total; 934 Appendix D. Decimal arithmetic

Table D.5: Behavior of the decimal normalize() function.

Function call Result normalized(+0.00100DD) +0.001DD normalized(+1.00DD) +1.DD normalized(+100.DD) +1E+2DD normalized(+100.00DD) +1E+2DD normalized(+NaN(0x1234)) +NaN(0x1234) normalized(-NaN(0x1234)) -NaN(0x1234) normalized(+∞) +∞ normalized(−∞) −∞

amount = 0.70DL; rate = 1.05DL; total = quantizedl(amount * rate, 1.00DL);

Without the call to quantizedl(), the total would have been 0.7350 instead of 0.74. A zero value encoded in decimal with either DPD or BID does not have all bits zero in storage, as is the case with binary floating-point formats. For example, in DPD encoding, 0.DF is represented as 0x22500000, whereas the all- bits-zero representation 0x00000000 corresponds to the value 0.e-101DF. The two values are equal when compared with decimal floating-point instructions, but not when compared as bit patterns. Programmers who examine bits via union types or with debugger commands, and compiler writers, need to be particularly aware of that point. The change of base from 2 to 10 has other effects on programmers who are accustomed to working with binary floating-point arithmetic:

I The larger base means larger spacing of consecutive decimal numbers (look at the machine-epsilon rows in Table 4.2 on page 65, and Table D.1 and Table D.2 on page 929), so computational precision is slightly reduced.

I The larger base lowers the frequency of alignment shifts for addition and subtraction, and when there are no shifts or digit overﬂow, rounding is not required and computations are exact. That feature improves performance of software implementations of decimal arithmetic, particularly when data have a common scale, as in ﬁnancial computations.

I Multiplication by constants is only exact if they are powers of ten, or if the product is small enough to be representable without rounding. In particular, doubling by adding or by multiplying by two may no longer be an exact operation. For example, 2.DF * 9.999999DF is 19.999 998, a value that has more digits than can be represented in the 32-bit format, so the result has to be rounded, in that case, to 20.00000DF.

I Input of decimal values is an exact operation as long as the number of digits is not so large that rounding is required. Output of decimal values is also exact as long as the format allows sufﬁcient output digits for the internal precision.

I Output with numeric format speciﬁcations in the printf() function family loses information about quantization. Preserve it by using the ntos() family (see Section 26.11 on page 867) to produce a string. For example, the program fragment

decimal_float x;

x = 123.000DF; (void)printf("%%He: x = %He\n", x); (void)printf("%%Hf: x = %Hf\n", x); (void)printf("%%Hg: x = %Hg\n", x); (void)printf("ntosdf(x) = %s\n", ntosdf(x));

produces this output: D.4. Initialization of decimal ﬂoating-point storage 935

%He: x = 1.230000e+02 %Hf: x = 123.000000 %Hg: x = 123 ntosdf(x) = +123.000

D.4 Initialization of decimal ﬂoating-point storage

Important special values in the DPD encoding of decimal floating-point arithmetic can be recognized by examining just the high-order byte, and Infinity is not required to have a zero significand, as it is in IEEE 754 binary arithmetic. Those two features facilitate compile-time and fast run-time storage initialization, as demonstrated by this short test program:

#include #include #include #include

void show(int byte) { decimal_float f; decimal_double d; decimal_long_double q; decimal_long_long_double o;

(void)memset((void*)&f, byte, sizeof(f)); (void)memset((void*)&d, byte, sizeof(d)); (void)memset((void*)&q, byte, sizeof(q)); (void)memset((void*)&o, byte, sizeof(o)); (void)printf("0x%02x: %+Hg %+DDg %+DLg %+DLLg\n", byte, f, d, q, o); }

int main(void) { int k;

for (k = 0; k < 256; ++k) show(k);

return (EXIT_SUCCESS); }

When compiled and run, its output looks like this, where we have elided repeated bytes in NaN payloads to ﬁt the page, and dropped uninteresting lines:

0x00: +0 +0 +0 +0 ... 0x78: +inf +inf +inf +inf 0x7c: +qnan(0x3c7c7c) +qnan(0xc7c...) +qnan(0x7c7c...) +qnan(0x7c7c...) 0x7d: +qnan(0x3d7d7d) +qnan(0xd7d...) +qnan(0x7d7d...) +qnan(0x7d7d...) 0x7e: +snan(0x3e7e7e) +snan(0xe7e...) +snan(0x7e7e...) +snan(0x7e7e...) 0x7f: +snan(0x3f7f7f) +snan(0xf7f...) +snan(0x7f7f...) +snan(0x7f7f...) ... 0xf8: -inf -inf -inf -inf 0xfc: -qnan(0x3cfcfc) -qnan(0xcfc...) -qnan(0x7cfc...) -qnan(0x7cf...) 936 Appendix D. Decimal arithmetic

0xfd: -qnan(0x3dfdfd) -qnan(0xdfd...) -qnan(0x7dfd...) -qnan(0x7df...) 0xfe: -snan(0x3efefe) -snan(0xefe...) -snan(0x7efe...) -snan(0x7ef...) 0xff: -snan(0x3fffff) -snan(0xfff...) -snan(0x7fff...) -snan(0x7ff...)

A straightforward modiﬁcation of the test program for IEEE 754 binary arithmetic shows that only initializer bytes 0x00 and 0xff are uniformly useful for all precisions: they produce +0 and −QNaN (or −SNaN) values, respectively.

D.5 The header ﬁle

The proposed extensions to ISO Standard C and C++ for decimal arithmetic introduce a new header file, , as a companion to the traditional . Those header files provide symbolic names for characteristics of the arithmetic. Each macro name proposed for contains the storage size in bits, an un- desirable practice that is inflexible and short-sighted. Nevertheless, the implementation of that header file in the mathcw library includes definitions of the proposed names, with recommended alternatives that follow the naming conventions in and hide storage size, as summarized in Table D.6 on the facing page. The DEC_EVAL_METHOD macro in the table requires some explanation. Its purpose is to allow implementors to provide fewer than three decimal types, with the unsupported ones masquerading as other decimal types. Its value is a compile-time constant chosen by the implementor, and suitable for use in preprocessing directives. DEC_EVAL_METHOD takes one of these values:

−1 Indeterminable.

0 Evaluate all operations and constants just to the range and precision of the type.

1 Evaluate operations and constants of type decimal_float and decimal_double to the range and precision of the decimal_double type, and decimal_long_double operations and constants to the range and precision of the decimal_long_double type.

2 Evaluate all operations and constants to the range and precision of the decimal_long_double type.

All other negative values correspond to implementation-deﬁned behavior. In the mathcw library, DEC_EVAL_METHOD is normally −1.

D.6 Rounding in decimal arithmetic

In Section 4.6 on page 66 we show how rounding works, and in Section 5.6 on page 110 and Section 5.8 on page 115, we describe how a programmer can use library calls to control rounding. IEEE 754 binary arithmetic provides four rounding directions: to −∞, to zero (chopping or truncation), to +∞, and the default, to nearest (or to nearest even number in the event of a tie). Because of historical practice, and legal requirements on commerce and taxation, ﬁnancial computations in decimal arithmetic require the additional rounding mode round-half-up, and possibly also its companion round-half-down. They set the rounding direction for halfway cases: if the computed result is exactly halfway between two adjacent representable values, round the magnitude up (away from zero) or down (toward zero). The decNumber library provides yet another choice, round-up (away from zero), giving a total of seven rounding modes. The IBM z9 and z10 offer an eighth choice, called round-to-prepare-for-shorter-precision, but it has no relevance for the current level of decimal arithmetic in C. Version 6 of the IBM PowerPC, introduced on 21 May 2007, supplies the same decimal rounding modes as the z9. Unfortunately, at the time of writing this, the GNU compilers always invoke decNumber functions with the default rounding mode, so it has not yet been possible to test the mathcw library rounding-control features for decimal arithmetic. D.7. Exact scaling in decimal arithmetic 937

Table D.6: The header ﬁle. The values match those of both DFP and BID encodings. If the 256-bit format is not supported, its macros have the same values as in the 128-bit format.

Proposed Recommended Value evaluation method DEC_EVAL_METHOD DEC_EVAL_METHOD -1, 0, 1, 2 number of digits in significand DEC32_MANT_DIG DEC_FLT_MANT_DIG 7 DEC64_MANT_DIG DEC_DBL_MANT_DIG 16 DEC128_MANT_DIG DEC_LDBL_MANT_DIG 34 DEC256_MANT_DIG DEC_LLDBL_MANT_DIG 70 minimum exponent of 10 DEC32_MIN_EXP DEC_FLT_MIN_EXP -95 DEC64_MIN_EXP DEC_DBL_MIN_EXP -383 DEC128_MIN_EXP DEC_LDBL_MIN_EXP -6143 DEC256_MIN_EXP DEC_LLDBL_MIN_EXP -1572863 maximum exponent of 10 DEC32_MAX_EXP DEC_FLT_MAX_EXP 96 DEC64_MAX_EXP DEC_DBL_MAX_EXP 384 DEC128_MAX_EXP DEC_LDBL_MAX_EXP 6144 DEC256_MAX_EXP DEC_LLDBL_MAX_EXP 1572864 maximum representable finite decimal floating-point number [there are 6, 15, 33, and 69 9’s after the decimal point] DEC32_MAX DEC_FLT_MAX 9.999999E+96DF DEC64_MAX DEC_DBL_MAX 9.999999...E+384DD DEC128_MAX DEC_LDBL_MAX 9.999999...E+6144DL DEC256_MAX DEC_LLDBL_MAX 9.999999...E+1572864DLL machine epsilon DEC32_EPSILON DEC_FLT_EPSILON 1E-6DF DEC64_EPSILON DEC_DBL_EPSILON 1E-15DD DEC128_EPSILON DEC_LDBL_EPSILON 1E-33DL DEC256_EPSILON DEC_LLDBL_EPSILON 1E-69DLL minimum normalized positive decimal floating-point number DEC32_MIN DEC_FLT_MIN 1E-95DF DEC64_MIN DEC_DBL_MIN 1E-383DD DEC128_MIN DEC_LDBL_MIN 1E-6143DL DEC256_MIN DEC_LLDBL_MIN 1E-1572863DLL minimum subnormal positive decimal floating-point number [there are 5, 14, 32, and 68 0’s after the decimal point] DEC32_DEN DEC_FLT_DEN 0.000001E-95DF DEC64_DEN DEC_DBL_DEN 0.000000...1E-383DD DEC128_DEN DEC_LDBL_DEN 0.000000...1E-6143DL DEC256_DEN DEC_LLDBL_DEN 0.000000...1E-1572863DLL

D.7 Exact scaling in decimal arithmetic

The mathcw library provides exact scaling of decimal values with obvious extensions of the venerable ldexp() family: if x has type decimal_double, then ldexpd(x, 3) returns a value with the same coefficient, and the exponent-often increased by three. The decimal members of the companion frexp() family decompose a number into a fraction in [0, 1), and a power of ten. The decimal members of the C99 logb() and scalbn() families extract a power-of-ten exponent that can be used to find a significand in [1, 10). A short test program illustrates those functions:

% cat dscale.c #include #include #include

int 938 Appendix D. Decimal arithmetic

main(void) { decimal_double x, y; int n;

x = 1234.56789e+1D; y = frexpd(x, &n); (void)printf("x = %s\n", ntosd(x)); (void)printf("ldexpd(x, 3) = %s\n", ntosd(ldexpd(x, 3))); (void)printf("frexpd(x, &n) = %s\n", ntosd(y)); (void)printf("n = %d\n", n); (void)printf("logbd(x) = %s\n", ntosd(logbd(x))); (void)printf("scalbnd(x, -logbd(x)) = %s\n", ntosd(scalbnd(x, -logbd(x))));

return (EXIT_SUCCESS); }

% dgcc dscale.c -lmcw && ./a.out x = +12345.67890000000 ldexpd(x, 3) = +12345678.90000000 frexpd(x, &n) = +0.1234567890000000 n=5 logbd(x) = +4 scalbnd(x, -logbd(x)) = +1.234567890000000 E Errata in the Cody/Waite book

THE WORLD’SABOOK ... ’TIS FALSLY PRINTED, THOUGH DIVINELY PENN’D, AND ALL TH’ERRATA WILL APPEAR AT TH’ END.

—FRANCIS QUARLES (1632).

The Cody/Waite book [CW80] is an early example of computer-based typesetting, and because it contains hundreds of polynomial coefficients, and hand-drawn flowcharts to specify computer algorithms, one might expect that ty- pographical errors have crept in. The exercise of implementing the mathcw library demonstrates that, compared to many more-recent books in the computing field, their book has remarkably few errors, and more than thirty years later, remains an outstanding landmark in the history and literature of numerical computation. The choice of flowcharts and prose for algorithm descriptions is understandable, but is, in this author’s view, regrettable. Programming is hard, and numerical programming is harder still, because it must deal with many small details, and variations in base, precision, rounding, and particulars of hardware instruction sets and numeric data formats, that are rarely evident until code is actually written, ported to many systems, and thoroughly tested. Flowcharts and pseudocode are not executable computer code, and can easily contain syntax errors, and algorithmic errors and omissions, that few humans can spot. Also, it is too easy with pseudocode to hide a complicated and subtle computer algorithm behind a vague statement of what is to be done; this book’s Chapter 9 on argument reduction was written in response to just that sort of problem, and its code and writing took more than a month to get right, despite repeated careful reading of the original research articles. It is true that showing working computer-program code, as we do throughout this book, necessarily obscures algorithms with programming-language syntax and irregularities, and hardware details, but that is an unavoidable fact of life if computers are to work, and do so reliably, for humans. Six years after the work on this book, and its code, began, this author remains convinced that the choice of implementation language and software principles and practices that are laid out in the introductory chapter are the correct ones for this particular task. All of the polynomial coefficients for both binary and decimal floating-point arithmetic were retyped from the book into mathcw header files. No errors attributed to those coefficients were found in numerical testing, although in a small number of cases, testing showed that polynomial degrees needed to be increased by one or two to reach the accuracy demanded of the mathcw library. The lack of machine-readable text for their book’s data and algorithms, and a clear statement of what auxiliary functions the polynomials approximate, made the job much harder than it should have been, and convinced this author of the need for publication of this book, and all of its source code, so that others can build on it in the future. Extension of the Cody/Waite algorithms to new platforms and extended floating-point types demands local control over polynomial fits, and those authors are silent on the origins of their polynomials. We remedied that serious deficiency by showing in this book how to make such fits with two popular, albeit commercial, symbolic-algebra systems, in both rational minimax form, and as Chebyshev approximations. We also showed how to convert the latter to rational form, allowing reuse of algorithm code. For every function treated in this book where a polynomial fit is required for part of the computation, our header files contain data that apply to all historical and current systems, as well as future ones with up to 70 decimal digits of precision. All of our symbolic-algebra code is part of the mathcw distribution, making it easy to adapt it for other functions not covered by the library, and to other machine precisions and number bases. In the test program for sqrt() on page 32 of the Cody/Waite book, in the second line from the bottom of the page, the assignment X1=Xshould be X1=Y: it saves the test argument, and in that program, that is Y, not X as it is in the other test programs. In the description of the computation of one of the polynomial approximations needed for pow(x,y) on page 100, the book incorrectly says evaluate R=z*v*P(v). It should say instead evaluate R=z*P(v). In the flowcharts, there is an error on page 127 in the description of the computation of cos(x) and sin(x).In the first rectangular box for cos(x), the chart specifies an assignment y = |x| + π/2. That assignment must be

© Springer International Publishing AG 2017 939 N.H.F. Beebe, The Mathematical-Function Computation Handbook, DOI 10.1007/978-3-319-64110-2 940 Appendix E. Errata in the Cody/Waite book omitted, because that adjustment is handled later in the second-last rectangular box, which has the assignment XN = XN − 0.5. For cos(x) only, the computation of N in the middle box should be INTRND(Y/π + 1/2), instead of the stated INTRND(Y/π). That confusion arises because in the relation cos(x)=sin(|x| + π/2), direct addition of the constant π/2 introduces unnecessary additional error because that constant is not exactly representable. Instead, it is preferable to incorporate it as the exact addend 1/2 in the computation of N. In the flowchart on page 62, and the description on page 63, the cutoff value SMALLX below which exp(x) is zero is defined to be the smallest machine number greater than ln(XMIN). Although that was a good choice prior to IEEE 754 arithmetic, it has the effect of producing premature underflow to zero in the exponential function, as well as in several others that use it, instead of gradual underflow into the subnormal region. That is not strictly an error in the book, because subnormals were not yet invented when it was written, but it is an issue that modern code needs to deal with. The most complex Cody/Waite algorithm, that for the power function that we treat in Chapter 14 of this book, exhibits the largest number of problems: I The inline binary search needs one more step; otherwise, it chooses the wrong endpoint, and that results in errors of a few ulps in the critical powers (±1)n and βn, which should always be exact. I Separate treatment of integer powers is desirable, for speed, and for accuracy. I Computation of nw is not accurate enough.

I If g = A1[k] at the start of the search through that table, the computed index lies outside the table, and may cause a run-time addressing error, or a completely incorrect returned function value.

I The value u2 is not accurate enough; it needs at least twice working precision. I The value w is not accurate enough; it needs at least three times working precision. I The REDUCE() operation needs more work; we improved it for our code. I Cody and Waite always choose q = 1, but we show that larger q values improve accuracy. I The power function for decimal arithmetic seems not to have been implemented on a real computer; had it been, several of the noted errors would have been caught. For future work on the power function, it is likely to be better to work instead on production of higher-precision values of the exponential and logarithm, as the fdlibm library, and Markstein’s book [Mar00], do to remove the nasty effects of error magnification. In all of the ELEFUNT test programs, the relative error computation contains rarely seen bugs, as described in detail in Section 4.25.4 on page 99. The ELEFUNT test programs are not consistent in the naming of the variables that record approximate and accurate function values: they are sometimes Z and ZZ, and other times, reversed. The legacy of keypunches and short variable names in Fortran is evident here. It would have been better to name them more mnemonically as FAPPRX and FACCUR. All of the test programs compute the absolute value of the current relative error in a variable W, and track the maximum relative error in a variable R6 initialized to zero, and the argument value for that error in a variable X1. Those two variables are updated when a guard condition IF (W .GT. R6) is satisfied. Although that usually works, it fails if the tested function is always correct. The guard is then never satisfied, and X1 is never initialized. The cure is simple: initialize R6 to a negative value. The guard condition is then guaranteed to be satisfied at least once, and X1 is always properly initialized. Finally, there is a matter of coding style that deserves mention, because it makes the test code harder to read. The test programs set the initial test region [a, b] outside the region loop, and then reset the test region just before the end of the loop, which might lie 150 lines away. That requires referencing the loop index with a value one larger than the current one, using a series of if statements. All of the new test programs developed for the mathcw library take a different approach: they set the test regions in a C switch statement at the beginning of the interval loop. That makes it easy to identify the current test region, because the regions are then clearly marked with case labels. Were ELEFUNT rewritten from scratch today, the test programs would be much more modular, with more shared code, many small private functions and procedures, and sensibly named variables. However, to keep the new tests similar to the old ones, the temptation to do that rewrite has so far been resisted. However, translations from the original Fortran 77 to C and Java have been prepared, and the ELEFUNT suite has been compatibly extended to test more functions. F Fortran interface

FORTRAN IS NOT A FLOWER, BUT A WEED. IT IS HARDY, OCCASIONALLY BLOOMS, AND GROWS IN EVERY COMPUTER.

—ALAN J. PERLIS (1987) FIRST ACM TURING AWARD WINNER (1966).

Fortran is the oldest high-level programming language still in use, and was the first programming language to be standardized by ANSI and ISO. Despite its age, it has no standard mechanism for communicating with routines written in other languages. The Fortran 2003 Standard [FTN04b] and Fortran 2008 Standard [FTN10] introduce such a facility, but it is unlikely to be widely implemented until ten to fifteen years after their publication. Donev [Don06] discusses some of the issues in using Fortran with C. The first compiler that supported Fortran 77 was the f77 compiler developed on UNIX systems at AT&T Bell Laboratories. Its calling conventions were carefully defined to be easily interfaced to C, because that was the most common language at the development site. Most subsequent UNIX Fortran compilers have followed the conventions of the original f77 compiler, so the interface that we describe here works on most UNIX systems. Nevertheless, we are careful to provide mechanisms to facilitate adapting the interface to other conventions, and other operating systems. Here is a summary of the default calling conventions in the original f77 compiler:

I The Fortran language requires that it be possible for the called routine to modify any of the arguments in the caller. In practice, that means that all arguments are passed by address. Thus, arguments passed from Fortran to C are always pointers. By contrast, in C, scalar arguments are normally passed by value, and more complicated arguments, such as arrays, are passed by address. Although some Fortran compilers support special function-like wrappers, %REF() and %VAL(), to allow the programmer to choose whether an argument is passed by address or by value, they are inconvenient, error prone, and nonportable. It is much better to design the Fortran interface so that language extensions are not required to use it.

I External names in Fortran code are converted to lowercase, because the language is case insensitive, and are sufﬁxed with an underscore to avoid colliding with names compiled from C programs, which are preserved as written.

I The Fortran ﬂoating-point data types REAL (synonym: REAL*4), DOUBLE PRECISION (synonym: REAL*8), and REAL*16 correspond exactly to the C data types float, double, and long double, respectively.

I The Fortran data type INTEGER corresponds to C’s int type. Length-qualiﬁed integer types are rare in Fortran programs, but when used, INTEGER*1 (synonym: BYTE) maps to signed char, INTEGER*2 maps to short int, INTEGER*4 to int, and INTEGER*8 to long long int.

I The Fortran LOGICAL data type corresponds to the C integer type int. The corresponding Fortran constant .FALSE. is zero in C, and the constant .TRUE. is nonzero (usually ±1) in C.

I Old-style Fortran 66 Hollerith strings (e.g., 12Hhello, world) are passed by the address of the ﬁrst character, but are not NUL-terminated. The string length is not passed, unless the user supplies an explicit argument to do so, as is common practice with Hollerith strings.

I Fortran 77 CHARACTER strings are passed by the address of the ﬁrst character, but are not NUL-terminated, because all characters are allowed in a Fortran string. The length is passed by value as an additional argument at the end of the declared argument list. Such arguments are called hidden arguments.

If there are multiple CHARACTER arguments, their lengths are passed at the end of the normal argument list in their order of occurrence. Thus, the Fortran call f(’ab’,’cda’) can be received in C with a function declared as f_(char *s, char *t, int len_s, int len_t). That convention means that Hollerith and quoted strings can be received the same way, easing the transition from Fortran 66 to Fortran 77. I Arrays are passed by address of the first element in both Fortran and C, but Fortran array indices start at one, as long as the array dimension is not a colon-separated range, whereas C indices always start at zero. I The Fortran language requires contiguous storage of multidimensional arrays, with the first subscript increasing most rapidly. Multidimensional arrays in C are also stored contiguously, but the last subscript increases most rapidly. If data copying is to be avoided, subscript lists must be reversed. Thus, the Fortran array reference x(i,j,m,n) becomes the expression x[n-1][m-1][j-1][i-1] in C. The subscript reordering and adjustment-by-one are highly error prone, but subscripting errors can be largely avoided if the array references in C are hidden in a suitable macro. That way, the C code can use X(i,j,m,n), just like the Fortran code. I Fortran supports passing array dimensions at run time, but C does not until the 1999 ISO Standard. Fortran dimensions may appear anywhere in the argument list, whereas C99 requires them to appear before the array argument declaration in which they are used, following its principle of declaration-before-use. That restriction may make it impossible to maintain identical argument order for routines supplied in both languages, because the common practice in many long-lived Fortran libraries is for array arguments to be immediately followed by their dimension arguments. I Programmers must be aware of the different array storage orders in the two languages. In Fortran, the first subscript increases most rapidly. By contrast, in the C family, the last one does. Storage-access order can have a huge effect on cache use and job times, so great care is called for in mixed-language array processing. Although Fortran 66 and Fortran 77 limit names of variables and routines to six characters, few Fortran compilers produced since the 1970s enforce that length limit. That limit was chosen because it allowed a variable name to be packed into a single machine word in the cramped memories of the early IBM mainframes on which Fortran was developed in the mid-1950s; they had six-bit characters and 36-bit words. Fortran 66 and Fortran 77 retained the six-character limit, but Fortran 90 finally raised it to 31 characters. In the mathcw library, only a few functions have array arguments: just the fmul() and qert() families, several of the pair-precision routines, the complex primitives prefixed cx, the vector functions prefixed v, and some of the special mathematical functions. Only a small number of routines take string arguments. Thus, some of the complexity of the interlanguage communication can be avoided in our interface. There are, however, two troublesome areas — CHARACTER arguments and external names: I A few Fortran compilers pass CHARACTER data by address of a descriptor, which is a compiler-dependent data structure that might include at least the length, and the address of the first character. Other compilers may pass such data by the address of the first character, and then supply a length argument immediately following the CHARACTER argument. Compilers for some other languages store the string length in the first one or two bytes of the string, but this author has never encountered that practice in a Fortran compiler. I Some Fortran compilers convert external names to uppercase, and others omit the trailing underscore, although they may offer a compile-time option to restore the underscore. If Fortran external names cannot be distinguished from C names, then the only alternative is to rename all of the library functions. That is most easily done by adding a unique prefix to the Fortran-visible names. We can easily cater to the naming problems by wrapping function names in the C interface in a macro with lowercase and uppercase arguments. However, alternate CHARACTER argument conventions require a revision of our code for those few functions that have string arguments. Our default implementation follows the original f77 conventions, providing support for a wide range of compilers on UNIX systems. F.1. Building the Fortran interface 943

F.1 Building the Fortran interface

Before we look at the source code for the Fortran interface to the mathcw library, we first show how to build the interface. Each library function has an interface wrapper function, and because few UNIX linkers discard unreferenced code from object files inside libraries, each wrapper function has its own file. Otherwise, if all of the wrappers were in a single file, then each use of the library would require loading all of the functions into the executable program, wasting time and filesystem space. A directory listing of the Fortran interface subdirectory is lengthy, so we show only part of it:

% cd fort %ls Makefile erfl.c ierfc.c l101pf.c nanf.c sign.c acos.c exp.c ierfcf.c l101pl.c nanl.c signf.c ... erfcl.c hypotl.c isunl.c modfl.c setxpf.c urcwl.c erff.c ierf.c l101p.c nan.c setxpl.c

The Makefile manages the build process, which requires compilation of all of the C ﬁles, and then creation of a static load library from the object ﬁles:

% make

cc -g -DHAVE_LONG_DOUBLE -DHAVE_LONG_LONG -I.. -c acosf.c

cc -g -DHAVE_LONG_DOUBLE -DHAVE_LONG_LONG -I.. -c acoshf.c

...

cc -g -DHAVE_LONG_DOUBLE -DHAVE_LONG_LONG -I.. urcw4l.c

cc -g -DHAVE_LONG_DOUBLE -DHAVE_LONG_LONG -I.. ftocs.c

ar r libfmcw.a acosf.o acoshf.o ...

ranlib libfmcw.a || true

The peculiar construction with the shell OR operator, ||, in the last command is needed because some UNIX systems do not have the ranlib utility for generating a library index. The ﬁrst part then fails, but the subsequent true command ensures overall success. A companion shared load library is easily built as well (here, on SOLARIS):

% make shrlib

cc -G -o libfmcw.so acosf.o ... -L.. -L. -lmcw

A simple validation test compiles and links some Fortran ﬁles with the new library, then runs them and compares their output with saved output ﬁles that are known to be correct:

% make check

f77 -g -c -o test01.o test01.f

f77 -g -o test01 test01.o -L.. -L. -lfmcw -lmcw

...

There should be no output except the test names. test03 requires support for REAL*16 in Fortran. 944 Appendix F. Fortran interface

======test01 ======test02 ======test03

When shared libraries are used, most UNIX systems require additional options to get the linker to record in the executable program the location of the shared library. Otherwise, even though linking succeeds, the program cannot be run because of missing libraries. GNU compilers generally need an option like -Wl,-rpath,/usr/local/lib, whereas others may require -R/usr/local/lib. Finally, we install the new libraries in a standard location for use by others:

% make install ... Installed files... -rw-rw-r-- 1 mcw 893794 Mar 31 06:40 /usr/local/lib/libfmcw.a lrwxrwxrwx 1 mcw 16 Mar 31 06:41 /usr/local/lib/libfmcw.so -> libfmcw.so.0.0.0 -rwxrwxr-x 1 mcw 396328 Mar 31 06:40 /usr/local/lib/libfmcw.so.0.0.0

F.2 Programming the Fortran interface

The Fortran argument-passing conventions described on page 941 suggest a simple interface design that we record in a small header ﬁle, fmcw.h, for use in all of the interface code:

#if !defined(FMCW_H) #define FMCW_H

#include

#define CONS(a,b) a##b #define FTN(lcname,ucname) CONS(lcname,_)

extern const char * F_to_C_string(const char *, int);

#endif /* !defined(FMCW_H) */

The FTN() macro handles the mapping of function names in the C code to the form produced by the Fortran compiler. Here, we choose the lowercase form with an underscore sufﬁx. The interface functions that take only numeric arguments are then similar, and a single example, frexpf.c, serves for all of them:

#include "fmcw.h"

float FTN(frexpf,FREXPF)(float *x, int *n) { return (frexpf(*x, n)); }

Because the C library functions in the frexp() family expect the second argument to be a pointer to a location for storing the power-of-two exponent, the variable n is not dereferenced with an asterisk in the return statement expression. The few functions that require string arguments are only slightly more complex, and just one example, nanf.c, sufﬁces:

#include "fmcw.h"

float FTN(nanf,NANF)(const char *tag, int len) F.3. Using the Fortran interface 945

{ return (nanf(F_to_C_string(tag, len))); }

The len argument corresponds to the hidden argument that the Fortran compiler passed by value. Because there is no terminating NUL in a Fortran string, we must copy the passed CHARACTER string into a temporary location. That job is handled by the F_to_C_string() function. In a general Fortran-to-C interface, we would have to allocate and free memory for the string copies, just as happens with the Java interface described in Section J.3 on page 982. However, for the mathcw library, we never need more than one string at a time, and the strings are always short, so as long as a single thread has control, we can safely use a small static buffer, avoiding the considerable overhead of dynamic memory management. Here is the code in ftocs.c that does the job:

#include #include "fmcw.h"

#define MAXBUF 64 #define MAX(a,b) (((a) > (b)) ? (a) : (b)) #define MIN(a,b) (((a) < (b)) ? (a) : (b))

const char * F_to_C_string(const char *s, int len) { /* Convert Fortran string to C string, and return it in a static buffer that is overwritten on the next call. */

static char buf[MAXBUF];

buf[0] = ’\0’; (void)strncpy(buf, s, MAX(0,MIN(MAXBUF - 1, len))); buf[MAXBUF-1] = ’\0’;

return ((const char*)&buf[0]); }

The Standard C library function, strncpy(), is safe: it never copies more characters than the limit set by its third argument. However, it does not supply a trailing NUL if the destination string is smaller than the source string. We therefore create an empty string in the static buffer, then copy the argument string, and ﬁnally, ensure that the last character in the buffer is a NUL. Fortran 77 does not allow zero-length character strings, so len should never be zero in that environment. How- ever, language extensions are common in some compilers, and Fortran 90 permits zero-length strings, so it is best to program defensively. If len is zero, strncpy() does not copy anything at all, so the prior assignment to buf[0] is essential. The third argument to strncpy() is an unsigned integer, so the MAX() macro wrapper ensures that a negative argument is treated as zero, instead of a large unsigned value that would result in overwritten memory, and a nasty program failure.

F.3 Using the Fortran interface

Because Fortran has no standard mechanism for ﬁle inclusion, and no notion of function and subroutine prototypes, we have to explicitly declare the mathcw library functions before using them. Here is one of the simple test programs:

program test01 real ierff, ierfcf real x integer k

write (6,’(A5, 2A15)’) ’x’, ’ierff(x)’, ’ierfcf(x)’ 946 Appendix F. Fortran interface

do 10 k = 1,9 x = float(k) / 10.0 write (6,’(F5.2, 2F15.6)’) x, ierff(x), ierfcf(x) 10 continue

end

Although the Makefile contains instructions for building the test program, all that we need to do is invoke a suitable Fortran compiler, with additional options to identify the location and names of the mathcw libraries. In this SOLARIS example, the -ftrap option is needed with the Fortran 90 and Fortran 95 compilers to get IEEE 754 nonstop operation:

% f95 -ftrap=%none test01.f -L/usr/local/lib -lfmcw -lmcw

% ./a.out x ierff(x) ierfcf(x) 0.10 0.088856 1.163087 0.20 0.179143 0.906194 0.30 0.272463 0.732869 ...

Systems managers can often specify local library locations in compiler configuration files, so that most users then need not know where the libraries are installed. Alternatively, the user can provide a colon-separated list of library directories in the LD_LIBRARY_PATH environment variable. However, here we simply supply an explicit library path with the -L option. The Fortran interface library, -lfmcw, must be specified before the mathcw library, -lmcw, because on most UNIX systems, libraries named on the command line are searched only once. H Historical floating-point architectures

THERE ARE LESSONS TO BE LEARNED BY LISTENING TO OTHERS.

—CHINESE FORTUNE-COOKIE ADVICE (2007).

THE PROLIFERATION OF MACHINES WITH LOUSY FLOATING-POINT HARDWARE ... HAS DONE MUCH HARM TO THE PROFESSION.

—EDSGER W. DIJKSTRA Structured Programming (1972).

COMPUTATION WITH ANY NUMBERS BUT SMALL INTEGERS IS A TRACKLESS SWAMP IN WHICH ONLY THE FOOLISH TRAVEL WITHOUT FEAR.

— MAINSAIL AND FLOATING POINT FAQ Is Floating Point Really This Complicated? (1999).

Virtually all modern computer systems adhere to the IEEE 754 binary floating-point design, at least in format, if not always in details. New software can generally safely assume that system, but one of the goals of the mathcw library is that it should also be usable on important historical systems, some of which still run in simulators. Both the 36-bit DEC PDP-10 and the 32-bit DEC VAX are available that way, as are dozens of microprocessors, and even the venerable IBM System/360 mainframe. Simulated PDP-10 and VAX systems have been used as test platforms for the mathcw library, and even though they are implemented in software, thanks to advances in processor speeds, they run faster today than the original hardware ever did. Table H.1 on the following page summarizes the floating-point characteristics of IEEE 754 and several historical computer systems. The variation in word size and floating-point formats is perhaps surprising, considering the uniformity of formats in machines built after 1980. On most early systems, single- and double-precision formats have the same exponent range, and on some, the wider format has a phantom exponent field in the second word. By the 1960s, most vendors adopted a floating-point format that encoded a one-bit sign, then a biased exponent, followed by the significand magnitude. However, some systems use other formats. For example, the Harris and Pr1me systems store the exponent after the fraction, the General Electric 600 series stores the sign between the exponent and the fraction, and the Illiac IV stores two 32-bit values in a 64-bit word with their signs, exponents, and fractions interleaved in the order s1, e1, s2, e2, f1, f2. When single and double formats share the same layout in the first word, a nasty and hard-to-find software bug arises when a call passes a double that is received as a single, or vice versa. If the first case, execution is correct. In the second case, whatever follows the single in memory is treated as the second word of the double. Those bits are likely to be arbitrary and unpredictable, but because they amount to a small perturbation on the fraction, their effect is simply to lower the precision of the double argument. In a large program, the error might be unnoticed, apart from the final results being puzzlingly less precise than expected. When the two formats have different layouts in the first word, the results are likely to be so nonsensical that the bug is recognized, tracked down, and repaired. Function-declaration prototypes force automatic type conversion, preventing detection of that kind of programming error. In any event, prototypes are absent from most early programming languages. In the following sections, we describe the floating-point architectures of a few systems that have strongly influenced modern computers, operating systems, and programming languages. Each is introduced with a brief note about its significance in the history of computing. Because the machines overlap in time, they are presented in alphabetical order. A useful online historical archive of manuals on computer architectures and programming languages1 provides more information about them. The Digital Computer User’s Handbook [KK67] provides a view of the early computer market up to 1967. There is also an outstanding book, Computer Architecture: Concepts and Evolution [BB97], by two leading computer architects who describe machine designs up to about 1980.

1See http://www.bitsavers.org/.

Table H.1: Arithmetic of current and historical computer systems. The digit counts exclude the sign.

Vendor and model or family Integer Floating-point base digits base digits digits digits single double quadruple Apollo Domain 23122352— Berkeley BCC-500 22323684— Burroughs B1700 23322460— Burroughs B5700 23981326— Burroughs B6700, B7700 23981326— CDC 1604 247236— — CDC 1700 21522339— CDC 3400, 3600 24723684— CDC 6000, 7000 2 48, 59 24896— Cray 1, 1S, 2, X-MP, Y-MP 26324896— DEC PDP-6 235227— — DEC PDP-10 KA 23522754— DEC PDP-10 KI, KL, KS, KLH10 23522762— DEC PDP-10 G-floating 23522759— DEC PDP-11 2 15, 31 22456— DEC PDP-12 2 11, 23 22460— DEC VAX with D-floating 2312 24 56 113 DEC VAX with G-floating 2312 24 53 113 Data General Eclipse S/200 21516 6 14 — English Electric KDF 9 23923978— General Electric 600 2 35, 71 22763— Gould 9080 23116 6 14 — Harris /6 and /7 22322338— Hewlett–Packard 1000, 3000 21622355— Honeywell 600, 6000 2 35, 71 22763— IBM 360 family 23116 6 14 28 IBM 650 10 10 10 8 — — IBM 704, 709 235227— — IBM 1130 215223— — IBM 1130 (extended REAL) 215231— — IBM 7040, 7044, 7090, 7094 23522754— IBM 7030 Stretch 263248— — IEEE 754 with 80-bit format 2312245364 IEEE 754 with doubled double 2312 24 53 106 IEEE 754 with 128-bit format 2312 24 53 113 Illinois Illiac I 239—— — — Illinois Illiac II 251445— — Illinois Illiac III 23116 6 14 — Illinois Illiac IV 24722448— Interdata 8/32 23116 6 14 — Lawrence Livermore S-1 Mark IIA 2352132757 Manchester University Atlas 247813— — Pr1me 200 21522447— Rice Institute R1 247256 6 — — SEL Systems 85, 86 23116 6 14 — Superset PGM 247239— — Univac 1100 23522760— Xerox Sigma 5, 7, 9 23116 6 14 — Zuse Z4 231223— —

For a thorough treatment of the design, analysis, and programming of historical floating-point arithmetic systems, consult the often-cited book Floating Point Computation [Ste74]. Until IEEE 754 arithmetic became widespread, and well-documented in textbooks, that book was the standard treatise on computer arithmetic, with coverage of number systems, overflow and underflow, error analysis, double-precision calculation, rounding, base conversion, choice of number base, floating-point hardware, and complex arithmetic. H.1. CDC family 949

H.1 CDC family

THE DOUBLE-PRECISION FLOATING-POINT PACKAGE USED BY 1700 FORTRAN IS DESCRIBED IN THIS APPENDIX.FOR EFFICIENCY THE PACKAGE IS NOT RUN-ANYWHERE. — CDC 1700 Fortran Version 3A/B Reference Manual (1974).

THE ONE MAJOR FLAW OF THE CDC 6000 COMPUTER IS THE ABSENCE OF AUTOMATIC TRAPS UPON OVERFLOW CONDITIONS IN INTEGER ARITHMETIC.SUCH CONDITIONS ARE SIMPLY IGNORED, AND THERE IS NO WAY TO DETECT THEM. ... THIS VERY SERIOUS DEFICIENCY MAKES COMPUTATIONS USING INTEGERS RATHER HAZARDOUS.

—NIKLAUS WIRTH The Design of a Pascal Compiler (1971).

When IBM dominated the North American computer industry, a group of competitors during the 1960s became known as the BUNCH — Burroughs, Univac, NCR, CDC, and Honeywell. Control Data Corporation, or CDC, as it is usually known, produced a line of 60-bit computers that successfully gained a share of the scientific-computing market, outperforming IBM’s 7030 Stretch. Before the 60-bit systems, CDC sold the 48-bit 1604 (1961) and 3000 (1963) family and the 16-bit 1700 (1965). The 3000 series is notable for having support in Fortran for declaring numeric variables of a user-specified type, and then having the compiler generate calls to user-provided functions for the four basic numerical operations. That simplifies programming with extended-precision data types. Cody’s first published paper [Cod64] describes a fast implementation of the square-root function for the CDC 3600. In the 60-bit product line, the CDC 6200, 6400, 6500, 6600, and 6700 mainframes were followed by a much larger system, the CDC 7600, that gained fame in national laboratories as the world’s fastest computer. One of the chief architects of those systems, Seymour Cray, left CDC in 1972 and founded a company, Cray Research Inc., that in 1976 shipped the first commercially successful vector supercomputer, the Cray 1. We discuss the words vector and supercomputer later in Appendix H.2 on page 952. Niklaus Wirth developed the Pascal programming language on a CDC 6400 system [Wir71a, Wir71b, Amm77]. The pioneering PLATO system for computer-assisted instruction was also developed on CDC machines [Kro10]. The 60-bit machines continued to evolve in the 1980s as the Cyber series, and another vector supercomputer company, ETA, was a spinoff from the CDC work. The lead architect of the 6600 writes this about the choice of the 60-bit word size [Tho80, page 347]: The selection of 60-bit word length came after a lengthy investigation into the possibility of 64 bits. Without going into it in depth, our octal background got the upper hand. The CDC 60-bit systems [Con67, Con71] have a floating-point format with a 1-bit sign, an 11-bit biased unsigned exponent-of-2, and a 48-bit integer coefficient. No hidden bit is possible with that representation. The coefficient corresponds to about 14 decimal digits, and that higher precision, compared to that available on 32-bit, 36-bit, and 48- bit systems, made the CDC systems attractive for numerical computing. Although CDC Fortran compilers provide a DOUBLE PRECISION data type, it is implemented entirely in software, and rarely used. It represents numbers as two 60-bit REAL values, with the exponent of the second reduced by 48, so the second coefficient is a bitwise extension of the first coefficient. The exponent size is not increased, so the number range is effectively that of the 60-bit form, but the precision is increased to 96 bits, or about 28 decimal digits. Integer arithmetic, and exponent arithmetic, are done in one’s-complement representation (see Appendix I.2.2 on page 972). Although integer addition and subtraction work with 60-bit values, integer multiplication and division are provided by floating-point hardware, and thus require format conversion. Results of those two operations are limited to the 48-bit coefficient size. Similar economizations are found in several models of the 64-bit Cray vector supercomputers [Cray75, Cray82]. A 1971 CDC Fortran compiler manual reports: Because the binary-to-decimal conversion routines use multiplication and division, the range of integer values output is limited to those which can be expressed with 48 bits. On neither of those CDC or Cray families is integer overflow on multiplication detected. A 1972 CDC Fortran compiler manual has this ominous remark: 950 Appendix H. Historical floating-point architectures

The maximum value of the operands and the result of integer multiplication or division must be less than 247 − 1. High-order bits will be lost if the value is larger, but no diagnostic is provided. There are multiple representations of any number with a coefficient needing fewer than 48 bits, and the results of the four basic operations are not necessarily normalized. For multiplication and division, results are normalized only if both operands are as well. A separate normalize instruction shifts a nonzero coefficient left to produce a high-order bit of 1, and reduces the exponent by the shift count. That instruction is essential, because to obtain correct results, operands for division must first be normalized. Perhaps because of the multiple representations, there is no floating-point comparison instruction. Instead, the numbers must be subtracted, the result normalized, and finally unpacked by a single hardware instruction into an exponent and fraction, and the sign and exponent tested to determine whether the difference is negative and nonzero, zero, or positive and nonzero. Octal notation is conventional on the CDC systems. The exponent bias is 20008 = 102410, so the value 1.0 can be represented in unnormalized form with an exponent of 20008 and a coefficient of 1, or in normalized form by shifting the coefficient left until its most significant bit is in the high-order position, and reducing the exponent accordingly. A short hoc program illustrates these 48 equivalent encodings:

hoc80>k=0 hoc80> printf("%2d %04o_%016...4o\n", k, 1024 - k, (1 %<< k)) hoc80> for (k = 1; k < 48; ++k) \ hoc80> printf("%2d %04o_%016...4o\n", k, 1023 - k, (1 << k))

0 2000_0000_0000_0000_0001 1 1776_0000_0000_0000_0002 2 1775_0000_0000_0000_0004 3 1774_0000_0000_0000_0010 4 1773_0000_0000_0000_0020 5 1772_0000_0000_0000_0040 ... 42 1725_0100_0000_0000_0000 43 1724_0200_0000_0000_0000 44 1723_0400_0000_0000_0000 45 1722_1000_0000_0000_0000 46 1721_2000_0000_0000_0000 47 1720_4000_0000_0000_0000

The biased exponent of 17778 is skipped for a reason to be explained shortly. The exponent encoding allows a fast way to subtract the bias: simply invert the high-order bit of the biased exponent, an operation that is easy to implement in hardware. Selective bit inversion is done by an exclusive-OR operation with a mask containing 1-bits wherever inversion is needed. To see that, consider two biased exponents, 20408 and 17208, corresponding to unbiased values of 408 and −578. Performing an exclusive-OR with the mask 20008 on the biased values produces 00408 and 37208. The first is clearly correct, and the second is as well, because 37208 = 37778 − 00578 is just the one’s-complement of the negative of 00578. The CDC floating-point arithmetic system supports Infinity and Indefinite bit patterns, which are the inspiration for IEEE 754 Infinity and NaN. Those features also provide the nonstop model of computation that IEEE 754 adopted. Although Zuse’s pioneering machines developed in Germany in the late 1930s had both special values, the Zuse computers were not well-known elsewhere, and it is unknown to this author whether the CDC architects reinvented the special values independently, or simply borrowed Zuse’s idea. The largest stored exponent, 37778, represents positive Infinity, and a stored sign and exponent of 40008 corresponds to negative Infinity. Because a one’s-complement system has both positive and negative zeros, an exponent field of 17778 corresponds to −0, and would be redundant with 20008, the encoding of +0. The CDC architects therefore chose the exponent value 17778 to indicate Indefinite. In both cases, the coefficient bits are arbitrary, but the hardware always generates a zero coefficient for those exceptional values. There are special branch instructions that recognize the two special exponents, and arithmetic units check for them early, and return a predefined result when they are encountered. The CDC operating systems provide commands to initialize unused memory to Infinity or Indefinite, with each coefficient set to the word’s own address. Machine status flags can be set to cause job termination for an Indefinite H.1. CDC family 951 and/or Infinite operand, and the ensuing report of the special operand value holds a record of where it came from, and gives a call traceback, identifying the routine and line number last executed, thereby detecting erroneous use of an uninitialized variable. Few machines before or since have made it as easy to detect that all-too-common software bug. Some modern compilers provide a -trapuv option to request such initialization, but that may still not catch uninitialized-access errors in dynamically allocated memory. The real solution to the problem is in hardware: memory systems should refuse to return a value from an unset location. − The representable number range is [2 1023, (247 − 1) × 21022], or approximately [1.11e-308, 1.26e+322], for unnormalized values. However, compilers enforce normalization, reducing the range to [2−976, (247 − 1) × 21022],or approximately [1.56e-294, 1.26e+322]. The choice of normalization, an integer coefficient, and the mid-way bias of 94 28 20008, makes the upper limit much larger than the reciprocal of the lower limit (by a factor of 2 ≈ 1.98 × 10 ), which is uncommon in floating-point designs. On most other systems, the two values are close. For example, in the IEEE 754 binary and decimal formats, the reciprocal of the smallest number is smaller than the maximum representable number by a factor of β2. On the DEC VAX, the reciprocal is about two times larger than the overflow limit, on the Cray 1 and DEC PDP-10, almost four times larger, and on IBM System/360, nearly 256 times larger. Although the floating-point system can represent a negative zero, the hardware never generates such a value. It does recognize them, so that −∞/ − 0 → +∞ and ∞/ − 0 →−∞, but for finite operands, the sign is lost: +1 ×−0 → +0. That inconsistency makes negative zeros unreliable records of their origin as underflows of negative values. Underflows on the CDC machines normally flush to zero silently. However, Fortran compilers set a trap so that underflows are caught and reported, then set to zero. Although it is possible to trap use of an Infinity or Indefinite operand, the normal practice is to continue execution. Infinity and Indefinite propagate through most subsequent computations, so if they arise, they are likely to be noticed in the program output. However, the much wider exponent range of the CDC number format compared to that of competing machines with smaller word sizes makes underflow and overflow less frequent in most programs. The default floating-point instructions on the CDC systems truncate their results, but there is a companion set that produces rounded results. CDC compilers allow users to choose either set, although the default is truncated results, perhaps because rounding arithmetic is slower. Arithmetic operations do not use a guard digit, which leads to anomalies that we discuss in Section 4.6 on page 66. For example, consider the subtraction of two adjacent numbers, simplified to a three-digit decimal system. We find correctly that 1.01 − 1.00 = 0.01, but if we instead subtract the next lower pair, 1.00 − 0.999, we first have to align the decimal points and work with at most three digits, giving 1.00 − 0.99 = 0.01. That differs from the exactly representable correct answer 0.001 by a factor of 10, which is just β, the base. For a similar computation in binary arithmetic, the computed answer is twice the correct value. For more on the history of the CDC 60-bit computer family, see the book [Tho70] and article [Tho80] written by the lead designer of the 6600. In the early 1970s, work began on a new 64-bit architecture, the CDC 8600. The project was canceled in 1974, but the design manual specifies a floating-point format consisting of a 1-bit sign, a 1-bit out-of-range flag, a 14-bit biased exponent in one’s-complement form, and a 48-bit integer coefficient. That provides normalized numbers in the range − + [2 8192 47, (248 − 1) × 28192]. In C99 notation, that is [0x1p-8145, 0xffff_ffff_ffffp+8192], or about [1.29e-2452, 3.07e+2480]. The precision is about 14 decimal digits. The out-of-range flag is set for overflow and undefined results, merging the old Infinity and Indefinite values into a single bit. Integer arithmetic is a modified one’s-complement form where the hardware replaces the all-bits-one pattern of −0 with all-bits-zero for +0, simplifying later tests for zero. With the 8600 abandoned, CDC moved on to a new 64-bit vector machine, the STAR-100. That system provides both 32-bit and 64-bit floating-point arithmetic. The 32-bit format has an 8-bit biased exponent, followed by a 1-bit sign, and a 23-bit integer coefficient. However, the exponent range is restricted, to allow exponents in [0x70, 0x7f] to represent Indefinite, and [0x80, 0x8f] to represent zero. The 64-bit format uses the same layout, but increases the exponent field to 16 bits and the coefficient to 47 bits (about 14 decimal digits). A leading hexadecimal digit of 7 or 8 in the exponent again identifies Indefinite and zero, respectively. The number range is less obvious because of the exponent restrictions, but the Fortran manual claims the range of the 64-bit format to be about [5.19e-8618, 9.53e+8644]. For reasons discussed in the next section, that machine was a commercial failure, and CDC eventually went out of business when its 60-bit product line ceased to attract new customers. 952 Appendix H. Historical floating-point architectures

H.2 Cray family

REVERSING THE MULTIPLIER AND MULTIPLICAND OPERANDS COULD CAUSE SLIGHTLY DIFFERENT RESULTS, THAT IS, A × B IS NOT NECESSARILY THE SAME AS B × A. — Cray 1 Computer System Hardware Reference Manual (1977).

VALUES y AND z MAY EXIST FOR WHICH |y|≤z BUT THE CRAY 1 CALCULATES |y × (1/z)| > 1.

—W.KAHAN Why Do We Need a Floating-Point Arithmetic Standard? (1981).

The Cray vector supercomputer models 1, 1S, 2, X-MP, and Y-MP are 64-bit word-addressed systems [Rus78]. The adjective vector means that the machines have instructions capable of completing a load, or a store, or a floating-point operation, on one or two one-dimensional arrays of numbers, with the result in another array. With the technology of the time, the Cray vector instructions produce one result element per clock tick, a performance rate approached by later RISC processors with superscalar pipelined operation, using multiple arithmetic units and complex, and heavily overlapped, instruction execution. The noun supercomputer refers to a computer that is engineered to provide the utmost floating-point performance compared to its price competitors, even if that means taking shortcuts that compromise the design or function [EM94]. The famous LINPACK benchmark report2 and the list of the TOP 500 supercomputer sites3 continue to track progress in that area. The worldwide market for such machines is small, but the prices are so high that Cray had vigorous competition from at least CDC, ETA, Fujitsu, Hitachi, IBM, and NEC. There was even a market in the 1980s and 1990s for mid-range parallel and/or vector machines, sometimes called departmental supercomputers, with machines from Alliant, Ardent, Convex, Cray, Cydrome, DEC, ELXSI, En- core, Floating-Point Systems, Kendall Square Research, Multiflow, Pyramid, Sequent, Stardent, Stellar, Supertek, Thinking Machines, and others. Although all but Cray failed or were bought by competitors, cheap parallel and vector processing lives on in a low-cost, but high volume, market: graphics display controllers for desktops and game systems. Advances in microprocessor technology, and possibly a ‘killer application’, could yet put vector processing into commodity processors on the desktop. Research projects at Stanford University and the University of California, Berkeley have produced such designs, and one large and important application is the signal processing needed in wireless telephones. Some vector machines permit arbitrary vector lengths, as the CDC STAR-100 and ETA machines do with vectors of up to 65,536 elements stored in memory. However, the Cray systems store at most 64 elements of data in any of several fast vector registers inside the CPU. To accommodate shorter vectors, a separate count register indicates how many elements are actually to be used. Longer vectors are handled by splitting them into 64-element chunks, with a possible remaining smaller chunk, and then processing each chunk with a single vector instruction. The Cray approach proved to be superior: a descendant of the original company survives four decades later, but ETA went out of business because its performance on its customers’ software could not match that of its chief competitor. Lack of adequate memory bandwidth to feed powerful CPUs continues to be a challenging problem faced by all computer vendors, and the performance gap between memory and CPUs has widened dramatically since the introduction of vector supercomputers [Bee94]. The listed Cray models provide two’s-complement arithmetic for 24-bit and 64-bit integers, with instructions for integer addition and subtraction. The integer multiply instruction is available only for the 24-bit address format, so 64-bit multiplication, and integer division, must be done by conversion to and from floating-point. Like the older CDC mainframes, that means that the effective integer width is reduced if multiplication or division are needed, and integer-overflow detection is impractical. Also like the CDC systems, there is no guard digit for floating-point subtraction. The Cray 2 does subtraction slightly differently from the others, but not enough to repair the subtraction problem, leading to anomalies that can cause a cautiously programmed Fortran statement like

IF (x .NE. y) z = 1.0 / (x - y)

2See http://www.netlib.org/benchmark/hpl/. 3See http://www.top500.org/. H.3. DEC PDP-10 953 to fail with a zero-divide error on Cray systems. The guard can also fail on modern IEEE 754 systems when subnormals are not supported. The Cray floating-point format has a 1-bit sign, a 15-bit exponent-of-2 biased by 4_00008 = 400016 = 16 38410, and a 48-bit fraction. There is no hidden bit. Although it is possible to construct unnormalized values, the hardware requires normalized inputs. There is no separate normalization instruction: addition to +0 provides that operation, and is primarily needed for the frequent conversion from integer to floating-point form. Just as 16-bit PDP-11 users continued with the octal notation of their older 12-bit and 18-bit systems, instead of switching to the more suitable hexadecimal form, Cray designers carried the use of octal over from their CDC past. The exponent size suggests that the biased exponent range should be [0, 7_77778], but that is not the case: stored exponents are restricted to the range [2_00008, 5_77778]. Values outside that interval are considered to have under- flowed or overflowed. That decision was perhaps made to simplify the vector arithmetic units so that underflow and overflow could be handled quickly. The allowed number range is thus [0x.8p-8192, 0x.ffff_ffff_ffffp+8191] in C99 notation, or about [4.54e-2467, 5.45e+2465], and the precision is about 14 decimal digits. Although −0 is representable, the hardware never generates such a value. Underflows are silently set to zero, and represented by a word with all bits zero. Overflows produce a value with the computed coefficient, and the exponent clamped to 6_00008. That provides Infinity, but there is no analogue of CDC’s Indefinite. Early Cray 1 machines used a multiplication algorithm that dropped some of the lower digits in the schoolbook method of summing digit-at-a-time products, with the result that multiplication could fail to commute, as the epigraph beginning this section notes. That misfeature was sufficiently upsetting to customers that it was later repaired by an engineering change. For a description of the original multiply algorithm, see [Cray77, pages 3-24ff]. The revised algorithm still drops trailing bits, but with more care [Cray82, pages 4-26ff]. There is no divide instruction: instead, a reciprocal-approximation instruction provides a starting estimate, accurate to 30 bits, for one step of a Newton–Raphson iteration to produce a reciprocal. That introduces additional rounding errors, making division less accurate than it should be, with errors in the last three bits. It also leads to misbehavior near the underflow limit, because in the available exponent range, y may be representable although 1/y overflows. For example, for y near the smallest representable number, the expression 0.06/y on those Cray systems is about a quarter of the largest representable number, but instead, it erroneously overflows. Similar problems can arise even on modern machines when optimizing compilers replace divisions inside a loop with multiplications by a reciprocal computed outside the loop. In IEEE 754 binary and decimal arithmetic, the reciprocal of a number near the overflow limit is subnormal, either losing significant digits, or abruptly underflowing to zero when subnormals are absent. It is worth noting that iterative improvement of a reciprocal approximation can be made to produce a correctly rounded quotient. The Intel IA-64 also lacks a divide instruction, but a careful implementation that exploits fused multiply-add and an extended exponent range allows the lengthy computation to be interleaved with other work, and can be proved correct [Mar00, Chapter 8]. Double-precision arithmetic is not supported in hardware on Cray systems, but is provided in software. For performance reasons, it is rarely used. For more on the Cray floating-point design, see the essay How Cray’s Arithmetic Hurts Scientific Computation [Kah90]. Models of the Cray computers from the late 1990s are based on either commodity (Alpha and SPARC) or custom processors, and provide almost-conforming 32-bit and 64-bit IEEE 754 arithmetic: only subnormals are omitted. Un- fortunately, for tiny numbers, that omission destroys the property that with gradual underflow, x − (x − y) correctly evaluates to y within rounding error when x − y underflows, whereas with flush-to-zero underflow, the result is x. On the newer Cray systems, floating-point compare instructions avoid having to do comparisons by tests on the sign and magnitude of the operand difference.

H.3 DEC PDP-10

21 963 283 741 IS THE ONLY NUMBER SUCH THAT IF YOU REPRESENT IT ON THE PDP-10 AS BOTH AN INTEGER AND A FLOATING-POINT NUMBER, THE BIT PATTERNS OF THE TWO REPRESENTATIONS [243_507_216_4358] ARE IDENTICAL. —NEW HACKER’S DICTIONARY (1993).

CORRECT IMPLEMENTATION OF FLOATING POINT IS SUFFICIENTLY OBSCURE THAT IT IS HARD TO DESIGN A HARDWARE FLOATING-POINT UNIT CORRECTLY. 954 Appendix H. Historical ﬂoating-point architectures

— THE TEAM THAT BUILT THREE PDP-10 CLONES AT XEROX PARC (1978).

The Digital Equipment Corporation (DEC) 36-bit PDP-10 is a descendant of the 36-bit PDP-6, which appeared in late 1964. The PDP-10, introduced in 1967, ran more than ten different operating systems, and was the vendor’s largest computer until it was surpassed by the biggest VAX models in the mid 1980s. During its long life, a small clone market arose, with compatible machines built by Foonly, Systems Concepts, Xerox, and XKL. The Xerox effort did not lead to a commercial product, but the architects at Xerox PARC extended their home- built PDP-10 systems with many new instructions for enhanced support of the Lisp language. That practice of tweaking the instruction set while designing a language later led to the development of the Xerox Alto and Dolphin computers, and the Cedar, Mesa, and Smalltalk languages. The Alto is credited with being the first personal workstation, with the first graphical user interface (GUI), and the first pointing device, the mouse. All desktop systems today share that legacy. The PDP-10 is one of the earliest commercial systems to have integrated networking, and has outstanding timesharing services. Its registers overlap the first sixteen words of memory, but are implemented in faster logic, so small instruction loops run several times faster if moved into the register area. The PDP-10 has a rich instruction set, and its architecture is well-suited to the Lisp language, whose implementation makes heavy use of object pointers. A significant feature of the PDP-10 is an indirect pointer: a word containing an address and a flag bit that, when set, means that another pointer should be fetched from that address, and the process repeated until a direct pointer is found. Thus, a single memory address in an instruction can transparently follow a long chain of linked pointers. The richness and versatility of the PDP-10 led to its wide adoption in universities, particularly in computer- science departments, and it became the machine of choice for most of the early Arpanet sites. That network ultimately evolved into the world-wide Internet. Several influential programming languages, typesetting systems, and utilities were first developed on the PDP- A METAFONT 10, including BIBTEX, Bliss, emacs, Interlisp, kermit,LTEX, MacLisp, Macsyma, MAINSAIL, Maple, , METAPOST , PCL, PSL, PUB, REDUCE, SAIL, Scribe, SPELL, and TEX. The CP/M operating system and Microsoft BASIC were both produced with simulators for the Intel 8080 running on PDP-10 systems before the Intel microprocessors were available, and Microsoft MS-DOS borrowed many features of CP/M. Microsoft built early versions of its WINDOWS operating system on top of MS-DOS. Later, it reversed their logical order, so modern WINDOWS systems still have the old operating system available via the command utility. The mathcw library described in this book also runs on the PDP-10 in the KLH10 (2001) simulator. For further historical highlights of the PDP-10, see [Bee04a], [Bee05], and [BMM78, Chapter 21]. The PDP-10 uses two’s-complement integer arithmetic (see Appendix I.2.3 on page 972), and the larger KL10 model also provides 72-bit integer add, subtract, multiply, and divide instructions, but the Fortran compiler has no support for a double-word integer. The sign bit of the second word is made the same as that of the first word, so the precision is 70 bits. There is also a fixed-point decimal instruction set for commercial applications, and powerful string instructions that can handle any byte size from 1 bit to 36 bits. Single-precision floating-point arithmetic has a 1-bit sign, an 8-bit power-of-2 exponent, and a 27-bit normalized −129 −27 127 fraction. The exponent bias is 2008 = 12810, so the number range is [2 , (1 − 2 ) × 2 ]. In C99 notation, that is [0x0.8p-128, 0x0.ffff_ffep+127], or approximately [1.47e-39, 1.70e+38]. The precision is about 8 decimal digits. For positive numbers, the format matches that of the IBM 7090, which was a member of IBM’s largest family of 36- bit machines before System/360 was announced. However, for negative numbers, the encoding on the PDP-10 was changed to store the fraction in two’s-complement form, with a one’s-complement exponent. That allowed integer comparison instructions to be used for single-precision floating-point numbers. To see how that works, here are some experiments with hoc on the KLH10 (a software implementation of the PDP-10) to display the native encodings of positive and negative floating-point numbers in octal:

hoc36> for (x = 1.0e-2; x <= 1.0e2; x *= 10) { \ hoc36> y=x*PI; \ hoc36> z = PI / x; \ hoc36> printf("%9.3f %s %9.3f %s\n", y, ftoo(y), -z, ftoo(-z)) } 0.031 174401267745 -314.159 566305656352 0.314 177501545736 -31.416 572011260566 3.142 202622077325 -3.142 575155700453 31.416 205766517212 -0.314 600276232042 314.159 211472121426 -0.031 603376510034 H.3. DEC PDP-10 955

hoc36> for (k = -3; k <= 2; ++k) { \ hoc36> x = PI+k*macheps(PI); \ hoc36> printf(" PI%+d*eps %s -PI%+d*eps %s\n", hoc36> k, ftoo(x), -k, ftoo(-x)) } PI-3*eps 202622077322 -PI+3*eps 575155700456 PI-2*eps 202622077323 -PI+2*eps 575155700455 PI-1*eps 202622077324 -PI+1*eps 575155700454 PI+0*eps 202622077325 -PI+0*eps 575155700453 PI+1*eps 202622077326 -PI-1*eps 575155700452 PI+2*eps 202622077327 -PI-2*eps 575155700451

hoc36> x = MINNORMAL hoc36> printf("% 14.6e %s % 14.6e %s\n", x, ftoo(x), -x, ftoo(-x)) 1.469368e-39 000400000000 -1.469368e-39 777400000000

hoc36> x = MAXNORMAL hoc36> printf("% 14.6e %s % 14.6e %s\n", x, ftoo(x), -x, ftoo(-x)) 1.701412e+38 377777777777 -1.701412e+38 400000000001

The octal values taken as integers clearly have the same order as the floating-point numbers. Had the exponent been in two’s-complement form, negative numbers near the underflow limit would have stored exponents of 0008, 7778, 7768,...,instead of 7778, 7768, 7758,...,losing the integer ordering. On the early KA10 processor (1967), double-precision arithmetic is provided in software, using a pair of single- precision numbers, with the exponent of the second word set to 27 less than that of the first word. That gives a precision of 54 bits, or about 16 decimal digits, with the same exponent range as the single-precision format. Short sequences of three to seven instructions implement the four basic operations on software double-precision numbers [DEC76, pages 2-79–2-80]. On the later KI10 (1972), KL10 (1975), and KS10 (1978) CPUs, hardware double precision uses two words, with a 1-bit sign, 8-bit power-of-2 exponent, and 62-bit fraction; the sign bit in the second word is unused, and ignored. The number range is therefore almost identical to that for single-precision arithmetic, but the precision is extended to about 18 decimal digits. Comparisons of values in the hardware double-precision format require three successive integer compare instructions. In the late 1970s, the PDP-10 got a third double-precision format, called G-floating, in hardware. It widens the exponent to 11 bits, reduces the fraction to 59 bits (about 17 decimal digits), and continues to ignore the sign bit of the second word. The new range is [0x.8p-1024, 0x.ffff_ffff_ffff_ffep+1023], or about [2.78e-309, 8.98e+307]. Compiler options select between the two hardware double-precision formats, without the need to introduce new data types into programming languages. Floating-point instructions are available in both truncating and rounding variants, with the rounding ones being the default for most programming languages. However, rounding is peculiar, as we describe and illustrate in Sec- tion 26.3.5 on page 848. The design manual for the planned, but later canceled, KD10 (1983) notes that its rounding instructions were to produce correct unbiased rounding, so at least the problem was recognized, and scheduled to be fixed. The results of addition, multiplication, and subtraction are produced in a double- or triple-length register (depending on the model) and then normalized and, if requested, rounded. Division includes at least one extra bit for rounding. Those actions provide a sufficient number of guard digits to prevent the anomalies of the Cray systems. State flags record the occurrence of underflow, overflow, and zero-divide conditions, and for the first two, the fraction is correct, but the exponent has wrapped. Setting those flags normally traps immediately to a software interrupt handler that replaces overflows by the largest representable number, and underflows by zero. Unfortunately, the two available C compilers do not supply a handler, so underflow and overflow in that language produce incorrect results with small exponents wrapped to large ones, and vice versa, as we illustrate in Section 4.9 on page 71 and Section 4.11 on page 77. Zero divides are suppressed, and in the absence of a handler fixup, the result is the numerator. The Fortran handler sets the result of divide-by-zero to the correct sign and magnitude of the largest representable number. 956 Appendix H. Historical floating-point architectures

H.4 DEC PDP-11 and VAX

I FINALLY GOT TO TRY SOME PARALLEL PROGRAMMING AS A GRADUATE STUDENT IN 1975 AT THE UNIVERSITY OF UTAH.WE HAD AN ADD-ON TO OUR PDP-11 MADE BY A COMPANY CALLED FLOATING POINT SYSTEMS THAT DID PIPELINED FLOATING ADD/MULTIPLIES.UNFORTUNATELY, IT DIED BEFORE I COULD DEBUG MY PROGRAM.

—JIM BLINN (1997).

THE SCIENTISTS WERE UPSET BECAUSE THEY DID NOT YET HAVE A VAX TO GRIND.

—JOHN W. D. CONNOLLY (1978).

The 16-bit DEC PDP-11 [EM79, LE80], introduced in 1970, was one of the most commercially successful minicomputers. Early systems provided software floating-point arithmetic in a three-word format, with a signed 15-bit exponent, and a signed 31-bit fraction. Later models offered an optional floating-point processor that provided 32-bit and 64-bit arithmetic in formats described later in this section. Although early UNIX development had begun in 1969 on the 18-bit PDP-7, and was planned to be moved to the 36-bit PDP-10, budget limitations forced a fallback to the smaller PDP-11. The limited address space and instruction- set architecture of that system had a large impact on the design of both UNIX, and the C programming language, which was developed on the PDP-11 from 1969 to 1973. Ken Thompson, the chief architect of UNIX, had worked on the complex MULTICS operating system project (see Appendix H.5 on page 958), and the name UNIX was chosen partly as a pun, and partly to reflect the designers’ philosophy of small is beautiful [Gan95, Gan03, Ray04, Sal94]. The first 32-bit DEC VAX (for Virtual Address eXtension), announced in 1977, has a 32-bit floating-point format called F-floating, with a 1-bit sign, 8-bit exponent with a bias of 128, and a 24-bit fraction. That total of 33 bits is possible because of the trick of supplying an implicit leading bit of 1, called a hidden bit, when an arithmetic operation is performed. The first VAX also has a 64-bit format, called D-floating, with the same allocation of sign and exponent bits as the 32-bit size, and 56 fraction bits, again with a hidden bit. In response to customer demand, DEC added the 64-bit G-floating format in 1979, with three bits moved from significand to exponent, giving a format similar to IEEE 754 64-bit arithmetic, but without NaN, Infinity, or gradual underflow. In most programming languages, the choice between the two double formats is made by a compile-time option, rather than by a change in a data type. Larger models of the 16-bit DEC PDP-11 systems have the F-floating and D-floating formats, and indeed, for several years, VAX models included a PDP-11 compatibility mode that allowed them to run old code from those smaller systems. During that time, the name VAX-11 was common in DEC literature. When DEC designed the 64-bit Alpha RISC architecture in the early 1990s with floating-point arithmetic based on the IEEE 754 Standard, it also included separate instructions for the VAX F-floating, D-floating, and G-floating formats, to facilitate run-time translation and execution of VAX programs on Alpha processors. In Alpha documentation, the two IEEE 754 formats are called S-floating and T-floating. Later releases of the OSF/1 operating system for the Alpha also provide the 128-bit IEEE 754 extension, implemented in software. More recently, Gentoo GNU/ LINUX distributions for Alpha and SPARC CPUs added that 128-bit arithmetic. When DEC added the G-floating feature, the VAX architecture also got a 128-bit format, H-floating, which is usually implemented in software. The only other system offering 128-bit floating-point arithmetic at the time was the IBM System/360 family, where it had been available for more than a decade (see Appendix H.6 on page 959). VAX floating-point instructions never generate negative zeros. The VAX therefore treats the floating-point bit pattern for a negative zero as a special value, called a reserved operand, that causes a run-time fault with all instructions that access it, even load and store instructions. Unless it is caught at run time and handled, that fault causes immediate program termination. In practice, that makes reserved operands useless for anything but user-specified compile-time initialization of floating-point storage areas. The PDP-11 has the same interpretation of −0, but calls it an undefined variable. Unlike the CDC operating systems, there is no support from compilers or operating systems on the PDP-11 or VAX for execution-time initialization with reserved operands. Although as shown in Figure H.1 on the facing page, VAX floating-point values in CPU registers have the modern format of sign, biased exponent, and significand, the VAX memory layout follows that of the PDP-11, which is little endian [Coh81] in 16-bit words, as illustrated in Figure H.2 through Figure H.4 on page 958. That puts the sign and exponent between two sequences of fraction bits in the byte string in memory [DEC77, DEC79, DEC82, DEC90]. H.4. DEC PDP-11 and VAX 957

s exp fraction (excluding hidden leading 1-bit)

bit 0 1 9 31 F-floating 01 9 63 D-floating 01 12 63 G-floating 01 16 127 H-floating

Figure H.1: VAX binary floating-point logical data layout. The sign bit is 1 for negative, and 0 for zero or positive. The exponent-of-2 is a biased unsigned integer. For nonzero stored exponents, there is a hidden (not-stored) leading fractional bit of 1 that is implicitly prefixed to the stored fraction bits in any arithmetic operation. The binary point lies immediately to the left of the hidden bit. [ 1 ) Thus, the fraction is always normalized, and nonzero fractions are in the range 2 , 1 . The floating-point value is (−1)s × (fraction) × 2exp−bias. When the stored exponent is zero, there is no hidden bit. Such a value with a sign bit of 0 represents a true zero. With a sign bit of 1, and arbitrary stored fraction bits, it is a reserved operand (see text for details).

byte A + 1 s exp f0 byte A + 0 byte A + 3 f1 f2 byte A + 2

Figure H.2: VAX F-floating memory layout. The memory address of the value is A, but data are stored in the order of 16-bit PDP-11 words, so the sign and exponent reside in the middle of a 32-bit field. The exponent width is 8 bits, and the fraction width is 24 bits, representing about 7 decimal digits. A hidden high-order fractional 1-bit logically precedes the stored fraction, so the significand value is the sequence 0.1 f0 f1 f2. The exponent bias is 128, so the number range in C99 hexadecimal floating-point notation is [0x0.8p-127, 0x0.ffff_ffp+127], or about [2.94e-39, 1.70e+38]. A stored exponent of zero represents a numerical zero, independent of the value of the fraction.

Although that peculiar layout is transparent to most numerical software, library primitives that extract the sign, exponent, or significand need to know about it. Zeros are recognized solely by a biased exponent of 0. When a floating-point instruction produces a zero result, the sign and fraction are always zero. Although bit manipulation and storage initialization can construct nonzero fractions with zero exponents, those values are treated as zero by the hardware. Like many systems, the VAX includes condition-code flag bits that record the occurrence of underflow, overflow, zero divide, and a few others, and those status bits can be tested in conditional-branch instructions. The flags are sticky in the sense that floating-point operations never clear them, but might set them. The VAX calling sequence ensures that the condition codes are preserved across procedure calls, and that the call instruction sets them all to zero at procedure entry. That makes it possible, and reliable, to test them long after they have been set, even when there are intervening calls. It also allows any procedure to install a floating-point exception handler to deal with operand or result faults at that call level, or deeper, without disabling handlers established by the caller or its call- sequence ancestors. Exceptions are processed by the nearest registered handler in the call history, so most language implementations install a suitable language-dependent default handler just prior to calling the user’s main program. After 1986, the largest models of the VAX included vector instructions for 32-bit integers, and for D-, F-, and G-floating formats, and the VMS operating system supplied the VAX Vector Instruction Emulation Facility (VVIEF) for software support on models lacking the vector hardware. Vectors contain up to 64 elements, just as on the Cray models discussed in Appendix H.2 on page 952. 958 Appendix H. Historical floating-point architectures

byte A + 1 s exp f0 byte A + 0 byte A + 3 f1 f2 byte A + 2 byte A + 5 f3 f4 byte A + 4 byte A + 7 f5 f6 byte A + 6

Figure H.3: VAX D- and G-floating memory layout. For D-floating, the exponent width is 8 bits, and the fraction width is 56 bits (1 hidden + 55 stored), giving a precision of about 16 decimal digits. For G-floating, the exponent width is 11 bits, and the fraction width is 53 bits (1 hidden + 52 stored), with a precision of about 15 decimal digits. The exponent bias is 128 for D-floating, and 1024 for G-floating. The D-floating number range is [0x0.8p-127, 0x0.ffff_ffff_ffff_ffp+127], barely larger than that for F-floating. The G-floating range is [0x0.8p-1023, 0x0.ffff_ffff_ffff_f8p+1023], or about [5.56e-309, 8.98e+307].

byte A + 1 s exp byte A + 0 byte A + 3 f0 f1 byte A + 2 byte A + 5 f2 f3 byte A + 4 byte A + 7 f4 f5 byte A + 6 byte A + 9 f6 f7 byte A + 8 byte A + 11 f8 f9 byte A + 10 byte A + 13 f10 f11 byte A + 12 byte A + 15 f12 f13 byte A + 14

Figure H.4: VAX H-ﬂoating memory layout. The exponent width is 15 bits and the fraction occupies 113 bits (1 hidden + 112 stored), providing a precision of about 33 decimal digits. The exponent bias is 16384. The range is [0x0.8p-16383, 0x0.ffff_ffff_ffff_ffff_ffff_ffff_ffff_8p+16383], or about [8.40e-4933, 5.94e+4931].

H.5 General Electric 600 series

THE HONEYWELL 6080 COMPUTER ONCE HAD THE PROPERTY THAT − A SMALL NUMBER (APPROXIMATELY −10 39) WHEN DIVIDED BY ROUGHLY 2 GAVE A LARGE RESULT (APPROXIMATELY 1038).... THE COMPUTING WORLD IS A JUNGLE OF INDIVIDUALISTIC AND SOMETIMES TOO CLEVER ARITHMETIC UNITS.

–NORMAN L. SCHRYER Determination of Correct Floating-Point Model Parameters IN Sources and Development of Mathematical Software (1984).

An influential early timesharing operating system, MULTICS, was developed on the General Electric 600 series from 1964 to 1969. The vendor’s computer business was sold to Honeywell in 1970, and MULTICS systems operated until 2000. The 600 series is a 36-bit architecture, and provides two’s-complement integer arithmetic (see Appendix I.2.3 on page 972) with 18-bit, 36-bit, and 72-bit sizes, and 36-bit and 72-bit floating-point arithmetic. The floating-point storage layout has an 8-bit unsigned exponent (in both lengths) biased by 128, followed by a sign and a 27-bit or 63-bit fraction. Unlike the PDP-10, the exponent is stored in two’s-complement form, and in double precision, the high-order bit of the second word is a data bit, rather than a sign bit. Floating-point arithmetic is done in an extended accumulator pair containing an 8-bit exponent in register E, and a sign and a 71-bit fraction in register AQ. The two registers can be accessed separately, or jointly as EAQ. Loads from storage fill the extra bit positions in the accumulator with zeros. There are two 36-bit store instructions, one which truncates, and the other which first rounds by adding 1 at fraction bit 28, then stores the truncated result, approximating a round-to-plus-infinity operation. The 72-bit store merely truncates the accumulator value. Multiplication and H.6. IBM family 959 division of the accumulator by a value in storage truncate the product or quotient. The extra bits in the accumulator fraction supply the important guard digits for subtraction. If a sequence of operations reuses the accumulator value, the result is higher intermediate precision. Although that is normally beneficial, we have seen several times in this book that it can lead to surprises, and even be harmful. The General Electric and Honeywell systems are early examples of machines with arithmetic done in a precision higher than that of stored values. That practice continues in Intel and Motorola microprocessors introduced in the early 1980s, and remains widespread in desktop computers.

H.6 IBM family

ARITHMETIC IN THE OBJECT PROGRAM WILL GENERALLY BY PERFORMED WITH SINGLE-PRECISION 704 FLOATING POINT NUMBERS.THESE NUMBERS PROVIDE 27 BINARY DIGITS (ABOUT 8 DECIMAL DIGITS) OF PRECISION, AND MAY HAVE − MAGNITUDES BETWEEN APPROXIMATELY 10 38 AND 1038, AND ZERO. FIXED POINT ARITHMETIC, BUT FOR INTEGERS ONLY, IS ALSO PROVIDED.

— FORTRAN Automatic Coding System for the IBM 704 EDPM (OCTOBER 15, 1956).

IT WAS POSSIBLE TO FIND VALUES x AND y FOR IBM SYSTEM/360, SUCH THAT, FOR SOME SMALL, POSITIVE , (x + ) × (y + ) < (x × y). MULTIPLICATION HAD LOST ITS MONOTONICITY.SUCH A MULTIPLICATION IS UNRELIABLE AND POTENTIALLY DANGEROUS.

—NIKLAUS WIRTH Good Ideas, Through the Looking Glass COMPUTER 39(1) 28–39 (2006). During the 1950s and early 1960s, IBM’s main scientific computers were models in the 700 and 7000 series. All are 36-bit machines, with the 700 series offering only single-precision floating-point arithmetic, with a 1-bit sign, 8-bit biased exponent-of-2, and 27-bit fraction. The 7000 series added support for double-precision arithmetic, where the second word has the same layout as the first word, but with an exponent reduced by 27, providing a 54-bit fraction.

H.6.1 IBM 7030 Stretch In late 1954, IBM researchers began work on Project Stretch, with the ambitious goal of building a scientific computer to be at least 100 times faster than any existing computer on the market. IBM delivered the first model, called the 7030 Stretch, to Los Alamos Laboratory in April, 1961. Although only nine machines were built, and performance did not quite reach the original goal, Project Stretch produced significant advances in hardware engineering that IBM leveraged in its next machine series. The Stretch design is well-chronicled in a book [Buc62], and a half-century retrospective [Ste11] from 2006 Turing Award winner Frances Allen, and has many innovations for its time. Here are just a few of them: I The magnetic-core memory system contains 64-bit words, but the address space is bit-addressable. Variable- width fields of 1 to 64 bits can transparently cross word boundaries, albeit with a performance penalty. I Hardware arithmetic supports binary and decimal fixed-point and integer, and binary floating-point, data. I Some instructions specify an operand byte size, which may be any number in [1, 8]. I The floating-point format has a 12-bit signed exponent field, and a 52-bit fraction field containing a 4-bit sign- and-flags field. The exponent field has a flag bit recording previous overflow or underflow, a 10-bit exponent, giving an approximate range of [5.56e-308, 1.80e+308] (similar to that of the IEEE 754 64-bit binary format), and a final sign bit. The 48 fraction bits represent roughly 14 decimal digits, and are followed by the fraction sign bit, and three flag bits available for user-defined data tagging. The integer format also has that four-bit field. I The 128-bit double-length format has a 96-bit fraction, with 20 unused bits at the bottom of the second word that are preserved in arithmetic, so they may contain user-defined data. The exponent range is unchanged from the 64-bit format. 960 Appendix H. Historical floating-point architectures

I All arithmetic operations are done in a double-length accumulator, and there is no rounding until its value is stored to memory. The user can choose the truncating store instruction, or the slower store rounded, which adds one to the 49th fraction bit of the fraction magnitude before normalization and storage. That corresponds to rounding to ±∞, a mode that does not exist in the IEEE 754 design.

I The store root instruction produces the square root of the accumulator value and stores it to memory. The accumulator retains its original value.

I There are two kinds of zero: a true zero, with zero fraction, and an order-of-magnitude-zero (OMZ) that results from underﬂow in subtraction, or from subtraction of identical nonzero values. In an OMZ, the fraction is zero, but the exponent is nonzero. Most other architectures produce a true zero for the case of x − x.

I When the exponent flag bit is set, the value represents Infinity if the exponent sign is positive, and Infinitesimal ( ) if the exponent sign is negative. Arithmetic with a normal number, x, and one of those exceptional values behaves like this:

∞ ± x = ∞, x − ∞ = −∞, x ± = x − x = −x, ∞ × x = ∞, × x = , ∞/x = ∞, /x = , x/∞ = , x/ = ∞.

Arithmetic with two exceptional values obeys these rules:

∞ + ∞ = ∞, ∞ − ∞ = ∞, ∞ × ∞ = ∞, ∞/∞ = ∞, − ∞ = −∞, /∞ = , ∞ × = ∞, ∞/ = ∞, ± = , ∞ ± = ∞, × = , / = ∞.

Notice that under IEEE 754 rules, the second and fourth on the ﬁrst line would produce a NaN. Comparison rules are as expected:

+∞ > +x > + > − > −x > −∞, +∞ =+∞, + =+ , −∞ = −∞, − = − .

I There is a run-time selectable noisy mode for floating-point arithmetic. When it is turned on, shifts in addition and subtraction extend one of the operands with 1-bits, instead of with 0-bits. The intent is that a user can run a program twice, once with each choice of the mode, and then compare the output to assess the impact of significance loss in intermediate calculations. The noisy-mode technique can be compared with those of significance arithmetic [AM59] and interval arithmetic [Gus98] for helping to judge the reliability of numeric results.

I A multiply-and-add instruction computes a double-length product and sum from single-word operands. It can be used to improve accuracy of dot products, matrix multiplication, and polynomial evaluation, but only in the 64-bit format.

I Division by zero is suppressed, and an exception ﬂag is set. Thus, if interrupts are turned off, x/0 evaluates as x.

I Floating-point instructions provide for both normalized and unnormalized operation. The latter can be used for both signiﬁcance arithmetic, and with the multiply-and-add instruction and exception ﬂags, for software multiple-precision arithmetic. H.6. IBM family 961

I The floating-point accumulator is also used for integer arithmetic. The Fortran manual describes integer data encoded as unnormalized floating-point values with a fixed exponent of 38, a 38-bit value in the 48-bit fraction field with the lower 10 bits ignored, followed by the four-bit sign-and-flags field. Thus, integers for arithmetic have a sign-magnitude representation (see Appendix I.2.1 on page 971), with a largest value of 274 877 906 943. However, integers used in logical operations can be any size from 1 to 64 bits, and may be either signed or unsigned.

I Fortran LOGICAL data are stored as ﬂoating-point values with the low-order fraction digit (bit 59) set to 1 for true, and 0 for false. The exponent, signs, and ﬂags are then ignored.

The Stretch book has this remark on the consistency of arithmetic with exceptional values:

For example, − = implies that inﬁnitesimals are equal, but ∞ − ∞ = ∞ implies that inﬁnities are different. This problem arises because no consistent logic applies when both operands are singular.

The two kinds of zero pose a problem too:

Since an OMZ represents a range of indeterminacy, multiplication or division by a legitimate number simply increases or decreases the size of the range of indeterminacy appropriately. Division by an OMZ is suppressed and, when it would occur, the zero divisor indicator is turned on. Addition of an OMZ to either a legitimate operand or another OMZ produces either a legitimate result or an OMZ, depending upon the relative magnitudes of the quantities involved. (However, comparison operations call equal all OMZs whose exponents differ by less than 48.)

A zero-multiply flag is turned on whenever multiplication produces a zero fraction, allowing the programmer a choice of whether to fixup the result to a true zero, or to an OMZ. Arithmetic, and its storage formats, on the Stretch architecture are unusual, and complicated, compared to most other designs produced since the early 1960s. Here is a final historical note: in May 1971, researchers at Brigham Young University in Provo, Utah, acquired one of the Stretch machines from government surplus, restored it, and ran it successfully as the last survivor until it was retired in September, 1980.

H.6.2 IBM and Fortran The ﬁrst successful high-level programming language, Fortran, was developed from 1954 to 1956 on the IBM 704. The language was intended to be relatively independent of the underlying hardware, but when a compiler was ﬁrst released in late 1956, the language contained several traces of the 704, including at least these:

I Variable names have at most six characters, because that many can ﬁt in a 36-bit word with the 6-bit BCD character set.

I Floating-point output uses two-digit exponents, because the supported number range is only about [10−39, 10+38]. As we note in Section 26.12.4 on page 873, that shortsighted decision about exponent width still affects software a half-century later.

I Integers are limited to the range [−32768, 32767], because address arithmetic instructions are used for ﬁxed- point arithmetic.

I Statement labels are limited to the range [1, 32767], because their numeric, rather than string, values are used by the implementation.

I Arrays are limited to three subscripts, because the smallest 704 machines have only 4096 words of memory, and the maximum is 32,768 words.

I Built-in function names end in the letter F: ABSF(), INTF(), MODF(), and so on. Arrays are not permitted to have names ending in F, because that special letter is how the compiler distinguishes between function calls and array references without complex lookahead. 962 Appendix H. Historical ﬂoating-point architectures

I GO TO statements transfer control to labeled statements, just as branch, jump, and transfer instructions do in hardware. Unfortunately, that soon produces impenetrable control ﬂow, because any labeled statement can be the target of a jump from somewhere else in the same routine. That mess led to Dijkstra’s famous letter, Go To Statement Considered Harmful [Dij68, Mis10], that spawned a vigorous debate in the programming-language community. Languages invented since that letter have better ways of managing control ﬂow, and some even eliminate the GO TO statement.

I The three-way branch IF (expr) n1, n2, n3 statement tests an expression for negative nonzero, zero, and positive nonzero, transferring control to three corresponding statement labels. It is implemented with three consecutive transfer instructions, TMI, TZE, and TPL (or TRA, for an unconditional jump).

I There are assigned and computed go-to statements for multiway branching:

ASSIGN label to v GO TO v,(label1, label2, label3, ...) k=expr

GO TO (label1, label2, label3, ...), k

They are implemented by an indexed branch into a table of absolute branches, providing a two-instruction route to the desired code block.

I Statements match IBM 80-character punched cards, with a leading C for a comment, or else a 5-character label field, a continuation column, a 66-character statement field, and an 8-character card identification field. It was a good idea to use the latter for a card sequence number, so that a dropped deck could be put into the card sorter and restored to its correct order.

I There are several machine-speciﬁc or compiler-speciﬁc statements:

FREQUENCY n (i, j, k, ...) IF (SENSE LIGHT i) n1, n2 IF (SENSE SWITCH i) n1, n2 IF (ACCUMULATOR OVERFLOW) n1, n2 IF (DIVIDE CHECK) n1, n2 IF (QUOTIENT OVERFLOW) n1, n2 PAUSE n PRINT PUNCH READ READ DRUM READ INPUT TAPE READ TAPE SENSE LIGHT 3 STOP n WRITE DRUM WRITE OUTPUT TAPE WRITE TAPE

The FREQUENCY statement gives the compiler hints about how often statement label n is reached by branches. READ means the most common input device, the card reader, so it has a short name. READ TAPE means text input from tape, whereas READ INPUT TAPE means binary input.

I An EQUIVALENCE statement allows variables whose use does not overlap in time to share storage locations, conserving scarce memory.

I Arrays are declared with a DIMENSION statement, because there are no data type declarations yet. The REAL declaration came later, named to make it distinct from its a companion INTEGER declaration. Only after that was DOUBLE PRECISION added. There was insufﬁcient foresight to have named the ﬂoating-point types SINGLE and DOUBLE. That mistake was later repeated in C with float and double. H.6. IBM family 963

Fortran is not the only language influenced by the IBM 704. The (CAR list) and (CDR list) functions in Lisp extract the first element of a list, and a list of the remaining elements. They are acronyms for Contents of Address Register and Contents of Decrement Register, reflecting the fact that the 704 has instructions for processing fields of a word divided into a 3-bit prefix, a 15-bit decrement, a 3-bit tag, and a 15-bit address. Lisp uses the prefix and tag for data type identification.

H.6.3 IBM System/360 Until the early 1960s, computer models from most manufacturers were often unique designs, and at least a certain amount of code rewriting was needed to move software to another model in the same vendor series. Changing series or vendors required a complete rewrite. Each machine was strongly influenced by the technology of its time, and early manuals are replete with the details of punched-card devices, magnetic and paper tapes, magnetic drums, console switches and displays, the wiring of core memory and plug boards, and so on. Character encodings differed between vendors, and sometimes even between models of the same family, discouraging exchange of data. Until Fortran, COBOL, and Algol were designed and implemented, there was no possibility of exchange of software between unlike systems, because programs were written in symbolic assembly-language code, or worse, in numeric machine code. IBM changed that situation forever when it decided to undertake the design of a family of computer systems that would guarantee upward compatibility, allowing customers to move up the IBM product line as their needs grew, without having to make a large investment in rewriting software. The family would also be the main IBM product line for years to come. That family, announced in 1964, is the now-famous System/360, and it remains the longest surviving computer architecture by far. Its model of 8-bit bytes, byte addressing, and a 32-bit word influenced many subsequent architectures, and its addressing model has grown over four decades from a 24-bit space to a 64-bit space. Even though IBM has since added support in that architecture for IEEE 754 binary [SK99] and decimal [IBM06] floating-point arithmetic, hexadecimal arithmetic, and all of the original CPU instructions, remain available. Its famous Principles of Operation manuals [POP64, POP04], which define the architecture without regard to particular implementations, are landmarks in the history of computing. Its original description [ABB64] is included in a 50th- anniversary collection of influential papers from IBM journals [ABB00].4 The lead author of that description, Gene Amdahl, left IBM in 1970 to found a company that developed and marketed the Amdahl 470 series of IBM-compatible mainframes. It became almost a fad in the computer industry to do so, with competing systems from Fujitsu, Hitachi, Itel, Magnuson, Nanodata, NEC, RCA, Ryad, Siemens, and Xerox. Wang produced systems similar to the System/360, but ran a different operating system. The ultimate success of System/360 was not clear at the beginning, and the complexity of the project almost led to failure. The design and management lessons learned are the subject of a classic book, The Mythical Man Month [Bro82, Bro95], written by Fred Brooks, the second of the three authors of that first description. It should be read along with Tony Hoare’s 1981 ACM Turing Award lecture, The Emperor’s Old Clothes [Hoa81], about a large software project that was less fortunate. The hexadecimal-base systems listed in Table H.1 on page 948 all use the formats first introduced in the System/ 360. Data General, Denelcor, Gould, and Interdata adopted the System/360 hexadecimal floating-point architecture for their minicomputers, to ease data and software exchange with their customers’ mainframes. Those systems all use big-endian addressing [Coh81]: the address of a value is that of its high-order storage byte. They also use sign- magnitude floating-point arithmetic and two’s-complement integer arithmetic (see Appendix I.2.1 on page 971 and Appendix I.2.3 on page 972). The Texas Instruments ASC (Advanced Scientific Computer) adopts the System/360 hexadecimal floating-point format, but reserves the largest exponent for Infinity (nonzero fraction) and Indefinite (zero fraction), concepts borrowed from the larger CDC systems. The ASC also has the concept of a dirty zero, a value with a zero fraction and nonzero exponent. When such a value is used in an arithmetic operation, the result is an Indefinite. The original design choice of hexadecimal floating-point arithmetic was based on a study [Swe65] that analyzed the floating-point operands of a million addition instructions in the binary arithmetic of the 36-bit IBM 704 to find out how often shifting, normalization, underflow, and overflow occurred. For bases larger than 2, there is no possibility of having a hidden bit to increase the precision, but a larger base reduces the frequency of both shifts and normalization. Also, for a fixed number of exponent bits, it extends the representable range, making underflow and

4See http://www.research.ibm.com/journal/50th/. 964 Appendix H. Historical ﬂoating-point architectures

s exp fraction

bit 0 1 8 31 32-bit 01 8 63 64-bit

s exp high-order fraction

bit 0 1 8 63

u u low-order fraction

bit 64 65 72 127 128-bit

Figure H.5: System/360 hexadecimal floating-point data layout. The sign bit is 1 for negative, and 0 for positive. The stored unsigned exponent-of-16 has the same size (7 bits) in all formats. It is biased by 64, so the value is (−1)s × (fraction) × 16exp−16. The sign and exponent are contained entirely in the leading byte, and the fraction has 6, 14, or 28 hexadecimal digits. The sign and exponent fields in the high-order byte of the second part, marked as u, for unspecified, are ignored. The fraction in the second part is treated as an extension of the upper fraction. [ 1 × −64 ( − −h) × 63] The range of normalized nonzero values with h hexadecimal digits in the fraction is 16 16 , 1 16 16 . In C99 notation, that is [0x0.1p-256, 0x0.ff...ffp+252], or about [5.40e-79, 7.23e+75]. When the sign, exponent, and fraction are all zero, the value is called a true zero. Negative zeros (zero exponent and fraction) are possible, and can be generated by hardware.

overflow less likely. By default, those conditions are caught at run time and repaired by software interrupt handlers on System/360, so they are relatively costly. However, it is possible to clear a flag bit in the Program Status Word (PSW) to cause underflows to flush silently to zero in hardware. Choosing β = 16 gave higher speed for larger models of the System/360, and lower cost for small ones. Unfortunately, for a base of the form β = 2K, the normalized significand has no leading zero bits when it lies in [1/2, 1), but has K − 1 leading zero bits in the range [1/β, 1/2). That phenomenon, known as wobbling precision,is one that we deal with many times in this book. For hexadecimal arithmetic, the worst case represents a loss of three bits, or almost one decimal digit. The System/360 architects recognized that problem, and mentioned it as part of the motivation for offering a 64-bit floating-point format, when, at the time, most competing machines provided only 36-bit or 48-bit arithmetic. Figure H.5 shows the System/360 floating-point layout. Although the original design published in 1964 specified only 32-bit and 64-bit floating-point arithmetic, IBM added a 128-bit extension in 1967. All three formats share the same exponent range, which later numerical experience and analysis showed to be an unwise choice: increased precision should always have increased exponent range [Tur87, JP89]. Operands of any floating-point instruction may be normalized or unnormalized. Addition, subtraction, multiplication, and division produce normalized results, but there are also separate instructions for unnormalized addition and subtraction. Addition and subtraction use a single additional hexadecimal guard digit, but on normalization, that extra digit is truncated without further effect on the remaining digits. Multiplication and division truncate their results. Thus, there is no provision for rounding other than the default round-toward-zero. Two decades later, the High Accuracy Arithmetic option for System/370 added support for IEEE-754-like rounding mode control in hexadecimal arithmetic [IBM84]. The 1964 edition of IBM’s Principles of Operation manual [POP64] specified one hexadecimal guard digit for 32- bit arithmetic, but none for the 64-bit case. Regrettably, System/360 models produced from 1964 to 1967 lacked a guard digit, leading to the kinds of anomalies discussed earlier for the CDC and Cray systems. Under pressure from customers, a hexadecimal guard digit was added. The 1967 edition [POP67] noted that both 32-bit and 64-bit formats H.7. Lawrence Livermore S-1 Mark IIA 965 may have one hexadecimal guard digit. More recent editions of the architecture manual [POP75, POP04] specify a guard digit for 32-bit, 64-bit, and 128-bit subtraction and multiplication. Here is an example of the misbehavior of arithmetic when there is no guard digit, from a small C program run on the Interdata 8/32, with annotation appended to mark significant output:

# cc guard.c && ./a.out t = 16**(-5) = 9.5367432e-07 = 0x3C100000 x = 16**(-6) = 5.9604645e-08 = 0x3B100000 u=1+16**(-5) = 1.0000010e+00 = 0x41100001 v=1+16**(-6) * 2 = 1.0000000e+00 = 0x41100000 w=1+16**(-6) = 1.0000000e+00 = 0x41100000 y=1-16**(-6) = 1.0000000e+00 = 0x41100000 <--- WRONG z=1-(1-16**(-6)) = 0.0000000e+00 = 0x00000000 <--- WRONG

Patching y to expected value (number just below 1.0) y=1-16**(-6) = 9.9999990e-01 = 0x40FFFFFF <--- OKAY! z=1-(1-16**(-6)) = 9.5367432e-07 = 0x3C100000 <--- WRONG AGAIN!

The computation of 1 − 16−6 fails to produce the nearest representable number below 1.0, because of the missing guard digit. That number is then constructed manually by assignment of an integer value to the storage location of y, but the subtraction from y again fails to recover the expected value of 16−6, getting 16−5 instead, a result that is wrong by a factor of β.

H.7 Lawrence Livermore S-1 Mark IIA

The last computer design that we consider in this appendix is the Lawrence Livermore National Laboratory S-1 Mark IIA, developed from about 1978 to 1984. The S-1 is a 36-bit vector machine, capable of emulating both the DEC PDP-10 and the Univac 1100, in addition to having its own instruction set. The design goal was about ten times the performance of the Cray 1, with an address space enlarged to 2GB. Although most commercial computers are designed privately by a small team, the S-1 is the result of extensive public scrutiny and comment. The ﬂoating-point architecture is unusual, with ideas and features inherited from its 36-bit DEC and Univac ancestors, plus the large CDC and Cray systems, and also from IEEE 754 arithmetic, which was being designed about the same time. Here is a summary of its extraordinarily rich arithmetic:

I 18-bit, 36-bit, and 72-bit integers;

I normalized base-2 ﬂoating-point numbers;

I one’s complement biased exponent;

I two’s complement signiﬁcand with a hidden bit in each size;

I 18-bit halfword format with 1-bit sign, 5-bit excess-16 exponent, and 13-bit signiﬁcand (intended for signal- processing applications);

I 36-bit fullword format with 1-bit sign, 9-bit excess-256 exponent, and 27-bit signiﬁcand;

I 72-bit doubleword format with 1-bit sign, 15-bit excess-16384 exponent, and 57-bit signiﬁcand;

I Inﬁnity (called OVF, for overﬂow);

I underﬂow produces the smallest nonzero magnitude, called UNF, instead of zero;

I negative zero is called NaN, and is an illegal operand in all ﬂoating-point instructions;

I rounding is controlled by a 5-bit ﬁeld: of the 32 possible patterns, several are reserved or have no effect, but at least seven modes are possible, including to −∞, toward zero, to +∞, away from zero, nearest, nearest with ties to +∞, and PDP-10-style; 966 Appendix H. Historical ﬂoating-point architectures

I exceptions set sticky flags to record underflow, overflow, and NaN, and traps may be enabled or disabled for any of them; I hardware instructions for the four primary operations in complex arithmetic, plus complex conjugate and complex magnitude, for both integer and floating-point operands; I hardware instructions for square root, logarithm, exponential, sine, cosine, sine and cosine pair, arc tangent, and 2-D and 3-D Euclidean distance; I hardware instructions for dot product, convolution, recursive filter, in-place matrix transpose, matrix multiply, normal and inverse Fast Fourier Transform (FFT), bit reversal, and quicksort partitioning. The S-1 also has byte-field instructions for all sizes from 1 to 36 bits, and uses 9-bit characters. The PDP-10 has similar instructions, but normally packs five 7-bit characters with a final unused bit in a word, or else four 8-bit characters followed by four unused bits. The Univac 1100 series stores six 6-bit characters in a word, or with its quarterword instructions, four 9-bit characters.

H.8 Unusual ﬂoating-point systems

We discussed the arithmetic of some of the most important historical computer architectures in the preceding sections to give the reader an understanding of why they are significant, why their floating-point arithmetic designs all have limitations, and why the industry was led to a collaborative effort in the late 1970s to define the IEEE 754 Standard for Binary Floating-Point Arithmetic [IEEE85a], and later, its extension for radix-independent arithmetic [ANS87]. After a decade-long effort, it was further revised in 2008 to incorporate both binary and decimal arithmetic, and a fused multiply-add operation [IEEE08, ISO11]. Every computer, operating system, and computer user today enjoys, and suffers from, the legacy of those systems, so we also described some of their contributions to the industry in the interests of preserving a bit of industrial history that has radically changed human society. Researchers have published many alternative floating-point proposals to try to overcome the problems of precision, range, significance, and exceptional conditions. The volume Computer Arithmetic II [Swa90b, Chapter 7] collects a half dozen important papers on that subject, and more can be found in the bibliography of floating-point arithmetic.5 Here are some of the ideas that have been proposed: √ I representation with unusual number bases, such as i = −1(imaginary), −2(negabinary), and 3 (ternary); I redundant number representations, such as {−1, 0, +1}; I exponential and logarithmic representation, making multiply and divide easy, addition and subtraction hard, and greatly extending the number range to make underflow and overflow unlikely; I interval arithmetic, which keeps strict lower and upper bounds on each operation, to provide error bars on final results; I significance arithmetic, which uses unnormalized arithmetic to keep a record of trustworthy digits [AM59] (the Mathematica symbolic-algebra system does that with its variable-precision binary floating-point arithmetic [Jac92]); I rational number representation, with arbitrary denominators, instead of just powers of the floating-point base;

I representation with extended, but fixed, precision (the C language tried to do that by offering only a double data type); I representation with extended, and variable, precision (symbolic-algebra systems and a few scripting languages do that); I representation with a movable boundary between exponent and significand, sacrificing precision only when a larger range is needed (sometimes called tapered arithmetic);

5See http://www.math.utah.edu/pub/tex/bib/index-table-f.html#fparith. H.9. Historical retrospective 967

I residue number systems that represent values as sums of remainders with respect to division by prime numbers, eliminating carry from addition, making addition and multiplication easy, but division and comparison hard.

However, apart from a strong research interest in residue number systems for applications to signal processing, almost none of them has attracted sufficient commercial interest for vendors to make the large investments needed to implement them in hardware, software, and programming languages, and teach users how to employ them effectively. Also, several of them, by introducing variable numbers of digits, bring back the problem of wobbling precision, making numerical analysis and software design harder. The view of this author, based on decades of experience with many languages and many different computer systems, is that only two features in that list have any serious chance of adoption: longer precision, and interval arithmetic. Longer precision is relatively easy, because it needs only a handful of new arithmetic instructions, and suitable library support. The mathcw library is designed from the start to support octuple-precision arithmetic, or about 70 decimal digits. We have shown repeatedly in this book that many computational problems can be solved much more easily if even a few more digits are available internally. The father of IEEE 754 arithmetic, William Kahan, has observed in his writings that it is unreasonable to expect that ordinary computer users will use clever numerical analysis to arrive at reliable solutions of their numerical problems. High precision, and particularly, the ability to easily rerun a computation in even higher precision, make many of the numerical difficulties disappear. Support for interval arithmetic is one of the important reasons that IEEE 754 has extra rounding modes, although it has taken a long time to get interval arithmetic available outside its small research community. In November 2005, Sun Microsystems released free compilers that provide interval arithmetic for Fortran 90 and C++ on GNU/LINUX and SOLARIS operating systems on AMD64, IA-32, and SPARC hardware. IBM tried to do that on its mainframes with the ACRITH package [Lan87], but it is an optional, and extra cost, feature, and not well integrated into common programming languages, making programmers reluctant to adopt it. Similar problems exist for the High Accuracy Arithmetic option. Merely providing accurate arithmetic for parts of a computation may not be enough: the article Anomalies in the IBM ACRITH Package [KL85] gives numerous examples where continued access to the high-precision accumulator is needed, but ACRITH hides it inside black-box routines. The subject of interval arithmetic is taught in only a few institutions, but it certainly deserves more attention. Re- searchers in engineering, the hard sciences, and medicine are expected to attach error bars to their reported physical data, to allow the reliability of that data to be assessed by others. That has practically never been the case with numerical results from computers, but it should be. One prominent numerical analyst has even called for use of interval, rather than point, arithmetic to be mandatory for certain government projects [Gus98]. Sadly, it may take government force and journal editorial requirements, rather than self-interest, for computer manufacturers and computer users to make interval arithmetic routine. Because rounding occurs only after an extended result has been generated, it should be possible to create interval instructions in hardware that produce two results simultaneously, instead of one, with little performance penalty over ordinary arithmetic. The IEEE 1788 subcommittee was formed in late 2008 to begin work on a proposed standard for interval arithmetic, but the task has proven to be difficult. They produced an official document in 2015 [IEE15], but further standardization work, and research in interval arithmetic, remain active.

H.9 Historical retrospective

The references cited in this appendix provide much additional material for readers who are interested in a better understanding of computer history. From our survey of important historical systems, we conclude that the key features to be desired of any computer-arithmetic system are at least these:

I The design must adhere to as many mathematical properties of arithmetic (of unlimited range and precision) as possible, because it is then more easily analyzed, and importantly for humans, more predictable. I Significantly more precision and range are required than most people think, and designers of floating-point systems should not aim to support just the needs of the average user, or their currently biggest customer. I Although many computer vendors and models have had short market lives, the IBM System/360 design reached the half-century mark after this book was largely completed. Architects are therefore advised to design for the long term, and to allow extensibility for future needs. 968 Appendix H. Historical floating-point architectures

I Programming languages need to make access to higher precision easy, and preferably, without source-code changes. A few compilers provide an option, sometimes called -autodbl, that requests that ﬂoating-point constants and functions be automatically promoted to the next higher precision. I Guard digits and correct rounding matter. The default rounding mode should always be the most unbiased, as is the case with round to nearest with ties to even in IEEE 754 arithmetic. However, other modes are required as well, and they must be standardly and universally available in all programming languages and on all platforms, run-time selectable, and efﬁcient to switch among.

I The number base matters. For several reasons, use of decimal ﬂoating-point is likely to increase sharply, and may ultimately drive out binary and hexadecimal arithmetic. For more on that subject, see Appendix D on page 927.

I Boundary properties and undefined operations matter. Underflow and overflow need careful handling, and their incidence can be decreased by extended range and precision. IEEE 754 NaNs and Infinity seem to be a reasonable compromise in dealing with those boundaries, and also with mathematically undefined operations, like 0/0 and ∞ − ∞. The Rexx [Cow85, Cow90, REXX96] and NetRexx [Cow97, Cow00] scripting languages offer decimal arithmetic with up to 109 decimal digits, and exponents-of-10 with as many as 9 digits. That range is so large that those languages treat underflow and overflow as fatal errors. That is reasonable for most users, but some advanced users, and the designers of mathematical libraries for those languages, need to be cautious near those limits.

I Fast implementations of the fused multiply-add operation and efﬁcient and exact dot products and sums can contribute signiﬁcantly to the design of high-quality, reliable, and robust numerical software.

The marketing of scientific computers seems to be driven largely by instruction speed (megaflops, gigaflops, teraflops, petaflops, and perhaps even exaflops), and processor counts. Regrettably, too many customers appear to want to get a possibly incorrect answer fast, rather than to get a correct answer more slowly. I Integer arithmetic

FOR MOST PROCESSORS, INTEGER ARITHMETIC IS FASTER THAN FLOATING-POINT ARITHMETIC.THIS CAN BE REVERSED IN SPECIAL CASES SUCH AS DIGITAL SIGNAL PROCESSORS.

—TUTORIAL AT osdata.com.

FLIGHT SIMULATORS ARE PARTICULARLY VULNERABLE TO ARITHMETIC PROBLEMS.THE DYNAMIC RANGE OF THE MANY VARIABLES MAKES INTEGER ARITHMETIC INAPPROPRIATE, YET THE TIME COSTS OF FLOATING-POINT CALCULATIONS MAKES THEM PROHIBITIVE.

—TUTORIAL AT erasmatazz.com.

The binary number system was extensively studied by Gottfried Leibniz who published the book Explication de l’Arithmétique Binaire (Explanation of Binary Arithmetic) in 1703, although there is evidence of binary arithmetic from India about 800 BCE. Leibniz may have been the first to use the binary digits 0 and 1. At the hardware level, computers handle integers represented as strings of binary digits, called bits.1 The bit string of architecture-dependent standard size is called the computer word. By the 1990s, almost all laptop, desktop, and larger computers used processors with a word size of 32 bits or 64 bits. Historically, however, many other word sizes have been used, as illustrated in Table I.1 on the next page. The wide variety of sizes is surprising in comparison to modern systems. Some architectures also support integer arithmetic on small submultiples or multiples of the word size, called quarterwords, halfwords, doublewords or longwords, and quadwords. Two particular string sizes have their own special names: a 4-bit nybble (sometimes spelled nibble), and an 8-bit byte2 (called an octet in some countries). A few historical machines have variable byte sizes. On the DEC PDP-10, a byte can be from 1 to 36 bits, and the most common byte size is 7, allowing five ASCII characters in a word. The 60-bit CDC and 64-bit Cray systems are primarily floating-point machines. On the CDC systems, integer multiplication and division are handled by converting to floating-point values, reducing the effective word size to 48 bits, even though 60-bit integer values can be added and subtracted. There are also 18-bit integers, but they are normally used for memory addressing. The early Cray systems support both 24-bit and 64-bit integers; the Cray 2 extends the smaller size to 32 bits, reflecting its much larger address space. Although older architectures address memory by words, the IBM System/360 family, introduced in 1964, addresses memory by 8-bit bytes, and most architectures designed since the late 1970s continue that practice. The IBM 7030 Stretch, planned to be the first supercomputer, is unusual in using bit addressing, and allowing integer word sizes from 1 to 48 (see Section H.6.1 on page 959). The Burroughs B1700 also uses bit addressing, but its integers are always 24 bits.

1The convenient contraction bit was invented by famed Bell Labs scientist John W. Tukey about 1946 or 1947, and first used in a published paper in 1948 by his influential colleague, Claude E. Shannon [Sha48a, Sha48b]. It fortunately has replaced the alternatives bigit and binit. In 1965, IBM research scientist James W. Cooley and Tukey discovered the Fast Fourier Transform (FFT) [CT65] which reduced an important O(n2) computation to O(n log n), revolutionizing many areas of engineering and science. It was later found that Gauss had discovered the FFT around 1805, but wrote about it only in an article in Latin published posthumously in 1866. The FFT was rediscovered by Runge in 1906, and again by Danielson and Lanczos in the field of crystallography in 1942 papers [DL42a, DL42b] that went unnoticed because World War II had most scientists busy elsewhere. Its computational significance only became evident when computers made large values of n possible, and Cooley and Tukey justly deserve the credit. The FFT has been ranked as one of the top ten algorithms of the Twentieth Century [Roc00]. Tukey also introduced the word software to computing in a 1959 article [Tuk58]. Shannon is regarded as the father of information theory (see earlier citations), and also made important contributions to computer science, cryptography, and mathematics [Sha45, GBC+02]. The BibNet Project archives include bibliographies of his works, and those of Tukey. 2The word byte is coined from bite, but respelled to avoid confusion with bit. The word may have first appeared in print in a 1959 article by IBM researchers [BBB59]. It seems to be due to Werner Buchholz in an IBM memo of July 1956: see Timeline of the IBM Stretch/Harvest era (1956–1961), http://archive.computerhistory.org/resources/text/IBM/Stretch/102636400.txt.

Table I.1: Integer word sizes of some historical and current computers. The model listing is representative, but not exhaustive. The ABC, operational in 1939, is credited with being the world’s first operational electronic digital computer. The Z1, from 1936, predates the ABC, and had floating-point arithmetic, but is an electromechanical device. The IBM 704 is the first production computer with floating-point arithmetic (1955). The BRLESC (1962) is unusual in that it provides fixed-point binary arithmetic with 4 integer bits and 60 fractional bits; the remaining bits are used for tags, sign, and parity. The Intel 4004 is the first commercially available microprocessor (1971).

Bits Model 1 IBM 7030 Stretch 4 Intel 4004 8 Intel 8008 9 Calcomp 900 12 CDC 160A and 6000 PPU, DEC PDP-5 and PDP-8, DSI 1000, Honeywell 1400, Univac 1 13 CDC 160G 16 Data General Nova and Eclipse, DEC PDP-11, IBM 1130 and NORC, Intel 8086, Norsk Data NORD-1, Zuse Z2 18 Cambridge EDSAC, DEC PDP-1, PDP-4, PDP-9, and PDP-15, Univac 418, Zuse Z25 20 Elliott 502, Ferranti Mark 1, General Electric GE 235 21 Advanced Scientific ASI 2100, CITAC 210B 22 Raytheon 250, Zuse Z1 and Z3 24 Burroughs B1700, CDC 924 and 3200, Datasaab D21, DEC PDP-2, Ferranti–Packard FP- 6000, General Electric GE 435, Harris /6 and /7, Harvard University Mark I, Raytheon 520, Scientific Data SDS 940, SEL Systems 840A, Zuse Z26 25 Digital Electronics DIGIAC 3800, Univac III 29 CDC G-15 30 Electrologica EL X1 through EL X8, Univac 490 31 Librascope LGP-30 32 CDC G-20 and LGP-21, DEC VAX, Gould 9080, Hewlett–Packard PA-RISC 1.0, IBM Sys- tem/360, POWER, and PowerPC, Intel iAPX 432 and IA-32, Interdata 7/32 and 8/32, LMI Lambda, MIPS (all Rn000 CPU models), Motorola 68000 and 88000, National Semiconduc- tor 32016, Norsk Data NORD-5, SEL Systems System 85/86, Sun Microsystems SPARC, Xerox Sigma 33 El-tronics ALWAC III-E, Matsushita MADIC IIA, Mitsubishi Melcom 1101F, STC ZEBRA 35 Lyons LEO I 36 DEC PDP-3, PDP-6, and PDP-10, General Electric GE 635, Honeywell 600 and 6000, IBM 704, 7040, and 7090, Matsushita MADIC III, Symbolics 3600, Univac 1100 38 Zuse Z22 39 Elliott 503 and 803 40 Autometrics RECOMP II, Hitachi HITAC 3030, Los Alamos Scientific Laboratories MA- NIAC, Princeton University IAS, RAND JOHNNIAC, Regnecentralen DASK and GIER, University of Illinois Illiac I and ORDVAC, Zuse Z23 42 English Electric LEO-Marconi Leo 3, OKI Electric OKITAC 5090H 44 AEI 1010, University of Pennsylvania EDVAC 48 Burroughs B5000, Bull Gamma 60, CDC 1604 and 3600, English Electric KDF9, IBM 7030 Stretch, Hitachi HIPAC 103, National Physical Laboratory Pilot ACE (Automated Comput- ing Engine), Telefunken TR440, University of Manchester Atlas 50 ABC (Atanasoff-Berry Computer) 52 University of Illinois Illiac II 54 Rice Institute R1 56 Philco 2000/213, RCA 601 60 CDC 6000 and 7000 64 Cray 1, 2, X-MP, and Y-MP, DEC Alpha, ELXSI 6400, Hewlett–Packard PA-RISC 2.0, IBM 7030 Stretch, Intel Itanium-1 and Itanium-2 72 Ballistics Research Laboratory BRLESC I.1. Memory addressing and integers 971

Table I.2: Sign-magnitude 4-bit integers.

Bits Value Bits Value 0000 0 1000 −0 0001 1 1001 −1 0010 2 1010 −2 0011 3 1011 −3 0100 4 1100 −4 0101 5 1101 −5 0110 6 1110 −6 0111 7 1111 −7

A p-bit computer word is capable of representing 2p different bit patterns. Thus, with p = 3, we have these possibilities: 0002, 0012, 0102, 0112, 1002, 1012, 1102, and 1112. They represent the unsigned integral values 0 through 2 1 0 7; for example, 510 = 1012 = 1 × 2 + 0 × 2 + 1 × 2 .

I.1 Memory addressing and integers

THERE IS ONLY ONE MISTAKE THAT CAN BE MADE IN COMPUTER DESIGN THAT IS DIFFICULT TO RECOVER FROM — NOT HAVING ENOUGH ADDRESS BITS FOR MEMORY ADDRESSING AND MEMORY MANAGEMENT.THE PDP-11 FOLLOWED THE UNBROKEN TRADITION OF NEARLY EVERY COMPUTER.

—C.G.BELL AND W. D. STRECKER (1976).

A PARTIAL LIST OF SUCCESSFUL MACHINES THAT EVENTUALLY STARVED TO DEATH FOR LACK OF ADDRESS BITS INCLUDES THE PDP-8, PDP-10, PDP-11, INTEL 8080, INTEL 8086, INTEL 80186, INTEL 80286, AMI 6502, ZILOG Z80, CRAY-1, AND CRAY X-MP.

—DAVID A. PATTERSON AND JOHN L. HENNESSY (1990).

Memory addresses are almost always treated as unsigned integers, but they are sometimes limited to fewer bits than the integer word size, for reasons of hardware economy. Arithmetic on addresses is often restricted to just addition and subtraction. Some machines even have separate register sets for address arithmetic.

I.2 Representations of signed integers

For most applications, negative integers are also needed, and there are four important conventions for the representation of negative numbers in binary arithmetic. Those encodings are described in the following subsections, and in each of them, positive numbers are represented identically, and the rightmost bit is the least signiﬁcant.

I.2.1 Sign-magnitude representation As the name suggests, sign-magnitude representation uses a sign bit together with a magnitude, that is, an unsigned value. Typically, the leftmost bit, s, is the sign bit, 0 for positive, and 1 for negative, so the sign can be written (−1)s. Table I.2 shows how that works in a 4-bit system. There are two representations of zero: −0 and +0. The computer hardware must be designed to treat them as equal, which complicates the implementation. The number range of p-bit sign-magnitude arithmetic is −(2p−1 − 1) ... −0 +0... (2p−1 − 1). The negative value −k in sign-magnitude form has the same bit pattern as the unsigned value 2p−1 + k. Sign-magnitude arithmetic has never been widely adopted for binary arithmetic, but it is used in the IBM 704 and 7090 mainframes introduced in 1955 and 1958, respectively, as well as in the IBM 7030 Stretch from 1961. It is also used in most systems with decimal arithmetic. 972 Appendix I. Integer arithmetic

Table I.3: One’s-complement 4-bit integers.

Bits Value Bits Value 0000 0 1000 −7 0001 1 1001 −6 0010 2 1010 −5 0011 3 1011 −4 0100 4 1100 −3 0101 5 1101 −2 0110 6 1110 −1 0111 7 1111 −0

I.2.2 One’s-complement representation In one’s-complement arithmetic, negative integers are represented by inverting (complementing) all bits of the corresponding positive number. Table I.3 illustrates that system for 4-bit words. As in the sign-magnitude representation, there are two zeros, +0 and −0, and the number range is also the same in the two systems: −(2p−1 − 1) ...−0 +0...(2p−1 − 1). The bit pattern for a one’s-complement negative number −k is the same as that for the unsigned value 2p − 1 − k. Subtraction is easy in that system: simply add the one’s-complement of the second operand to the ﬁrst operand, as in this example in our 4-bit system: 2 − 6 = 2 +(−6)

= 00102 + 10012

= 10112 = −4. One’s-complement arithmetic is uncommon today, but it is used on CDC and Univac mainframes built in the 1960s and 1970s. When UNIX, and C, were ported to the 36-bit Univac 1100 series about 1984, the researchers remarked [BHK+84, page 1778]: In actual practice, problems caused by one’s complement arithmetic are rare. Some of the nastiest ones are in the C compiler itself! As a historical note, the Pascaline, an early mechanical calculator developed by Blaise Pascal about 1645, could only do addition, but by expressing the second operand in nine’s complement, subtraction is also possible, albeit labo- rious, because the complement operation (subtracting from 999 999 with no need to borrow) must be done without the aid of the machine: 987 654 − 123 456 = 987 654 +(999 999 − 123 456) − 999 999 =(987 654 + 876 543) − 999 999 = 1 864 197 − 999 999 = 1 864 197 − (1 000 000 − 1) =(1 864 197 − 1 000 000)+1 = 864 197 + 1 = 864 198. Notice that the procedure can be shortened by dropping the leading (overﬂow) digit 1 in the third step, adding it back at the low end, and omitting the complement of subtracting 999 999.

I.2.3 Two’s-complement representation Most modern computer architectures use two’s-complement representation, because certain of its properties simplify the hardware implementation of arithmetic. It is similar to one’s-complement, except that after inverting all of the I.2. Representations of signed integers 973

Table I.4: Two’s-complement 4-bit integers.

Bits Value Bits Value 0000 0 1000 −8 0001 1 1001 −7 0010 2 1010 −6 0011 3 1011 −5 0100 4 1100 −4 0101 5 1101 −3 0110 6 1110 −2 0111 7 1111 −1

bits, you then must add one to the result. Overﬂow is only possible in the addition when the original value is zero, and must be ignored. Although it would appear from our description that negation requires an addition operation, that is not so. Negation can be accomplished by a fast circuit that implements this simple rule:

Starting at the rightmost bit, copy bits up to and including the ﬁrst 1-bit, then invert the remaining bits.

Table I.4 shows the two’s-complement integers in a 4-bit system. From the bit patterns for negative numbers, the bit pattern for −k is the same as the unsigned result 2p − k. As in the one’s-complement system, subtraction can be done by adding the (two’s-) complement of the second operand:

2 − 6 = 2 +(−6)

= 00102 + 10102

= 11002 = −4.

The low-order bit is the parity of the number: the number is even if that bit is 0, and otherwise, it is odd. That property is also enjoyed by sign-magnitude arithmetic, but not by one’s-complement arithmetic. The important differences between two’s-complement arithmetic and the other two systems are that (a) there is only one representation of zero, and (b) there is one more negative number than positive. That is, the number range is −2p−1 ...−10+1...(2p−1 − 1). For high-level language programming, point (a) is unimportant, but point (b) matters. Taking the absolute value of the most negative number in two’s-complement arithmetic generates an integer overﬂow condition, because the result requires p + 1 bits. To see what happens when we negate −8(= 10002) in 4-bit two’s-complement arithmetic, invert its bits to get 01112, then add 1 to get 10002. That is the same as −8 again, instead of +8. That is a general result for any number of bits in two’s-complement arithmetic: −(−2p−1) overﬂows to −2p−1. The following simple Fortran program demonstrates that negation of the most negative number in 32-bit two’s- complement arithmetic produces that number back again, rather than a positive number:

N = -2**30 - 2**30 PRINT *, (N + 1), -(N + 1) PRINT *, N, -N END

The number N is the most-negative integer in the two’s-complement system, so −(N + 1) should be the largest positive integer. The program’s output on a Sun Microsystems workstation is

-2147483647 2147483647 -2147483648 -2147483648 and the nonsense in the last number is a consequence of the overﬂow. 974 Appendix I. Integer arithmetic

Table I.5: Excess-n 4-bit integers. Here, the bias is 24−1 − 1 = 7.

Bits Value Bits Value 0000 −7 1000 1 0001 −6 1001 2 0010 −5 1010 3 0011 −4 1011 4 0100 −3 1100 5 0101 −2 1101 6 0110 −1 1110 7 0111 0 1111 8

When digit strings are converted to integer values, the software should always accumulate a negative result, and then invert the sign if the number should be positive. That way, the most-negative integer that is representable in two’s-complement arithmetic can be input correctly. In addition, the code works properly for the signed zeros and outer limits of one’s-complement and sign-magnitude systems. Of course, overﬂow in the string conversion is still possible, and must be suitably handled, such as by setting a status ﬂag and clamping the result to the nearest representable number.

I.2.4 Excess-n representation If a p-bit string represents an unsigned binary integer, then implicit subtraction of a constant bias allows positive and negative numbers. That is called excess-n representation. Choosing the bias to be n = 2p−1 − 1 produces an optimum split, as illustrated in Table I.5. With that choice of n, there is only a single zero, but there is one more positive number than negative numbers. As with the two’s-complement system, that means that there is a value at one end of the number range that produces itself when negated. The excess-n representation is commonly used for the exponent field in floating-point encodings, but is rarely seen elsewhere. The reason for using a biased exponent is that integer comparison instructions can then be used for ordering of floating-point values, as long as the values are not IEEE 754 NaNs.

I.2.5 Ranges of integers The largest integer that can be represented in most programming languages is limited by the host word size. On many machines, 32-bit integers are often the longest available. The DEC VAX, some supercomputers, and RISC architectures of the 1990s, support 64-bit integers, although computer programming languages may require use of additional integer data types to access them. Table I.6 on the facing page shows the largest signed and unsigned integer values for typical computer word sizes. In sign-magnitude and one’s-complement systems, the corresponding most-negative values are the negatives of the largest signed numbers. In two’s-complement systems, they are the negatives of one more than those numbers. It is a good idea to commit to memory approximate values for p = 8, 16, and 32 (the shaded rows in the table), so that when you program an application that needs large integers, you can quickly determine whether your computer word size is large enough for the task. As a small programming note, observe that you cannot compute the largest 32-bit signed integer in Fortran by the expression 2**31 - 1, because the term 2**31 overflows. Instead, you need to write it as 2**30 + (2**30 - 1), where the parentheses are essential to avoid overflow. Signed integers in 32-bit words are inadequate for many purposes. They are insufficient to represent

I the number of people on Earth;

I the U.S. national debt;

I the annual revenues of many large corporations;

I the number of bytes in the disk systems of many computers; I.3. Parity testing 975

Table I.6: Largest integers in various word sizes.

Word size Largest signed integer Largest unsigned integer 4715 8 127 255 12 2 047 4 095 16 32 767 65 535 18 131 071 262 143 24 8 388 607 16 777 215 32 2 147 483 647 4 294 967 295 36 34 359 738 367 68 719 476 735 40 549 755 813 887 1 099 511 627 775 48 140 737 488 355 327 281 474 976 710 655 60 576 460 752 303 423 487 1 152 921 504 606 846 975 64 9 223 372 036 854 775 807 18 446 744 073 709 551 615

I the estimated age (in years) of the universe; I the number of microseconds in a day, and the number of seconds in a century, both important for time keeping on computers. Integers of 64 bits, and 64-bit addressing, are expected to be adequate for a long time. For example, if you could afford to buy 264 bytes of memory, and your computer could address it all, then if you started to write to that memory at the substantial rate of 100 MB/sec (100 million bytes per second), it would take about 5850 years to ﬁll it just once. Equivalently, a computer incrementing an initially zero counter every nanosecond would take 585 years to reach the largest representable 64-bit number.

I.3 Parity testing

In sign-magnitude and two’s-complement systems, an integer is even if the low-order bit is zero, and otherwise, is odd. The C-language family programming idiom n&1is a common way to test that bit: the expression is 0 for even, and 1 for odd. However, in one’s-complement arithmetic, that test is only correct for nonnegative integers; the result must be complemented for negative n. For the bias chosen in Table I.5 on the preceding page for excess-n arithmetic, the expression is 1 for even, and 0 for odd.

I.4 Sign testing

Even though we do not have an explicit sign bit in one’s-complement and two’s-complement forms, we can always determine the sign of an integer in those systems by examining the leftmost bit. That bit is 1 if the number is negative, and 0 if the number is positive, just as it is for the sign-magnitude system. Low-level assembly-code programs, and the hardware itself, make use of that fact, but in high-level languages, comparisons of entire p-bit words against zero are normally used instead for sign tests. Full-word comparisons may not be sufﬁcient when there are two zeros, as in one’s-complement and sign-magnitude arithmetic, because −0 and +0 compare equal: the sign bit must be examined to distinguish between them. A similar situation exists in IEEE 754 ﬂoating-point arithmetic, where the copysign() and signbit() functions are essential library primitives.

I.5 Arithmetic exceptions

Most computer systems generate an interrupt for a division by zero in integer arithmetic, and often, unless system- dependent corrective action is taken, the program is terminated. 976 Appendix I. Integer arithmetic

However, programmers must be aware that integer overﬂow, that is, the generation of integer values that take more bits to represent than the host word can hold, usually goes undetected, and the result may be complete nonsense. Here is a small example in the Fortran language:

N = 65535 PRINT *, ’N = ’, N PRINT *, ’N*N = ’, N*N

N = 65536 PRINT *, ’N = ’, N PRINT *, ’N*N = ’, N*N

N = 65537 PRINT *, ’N = ’, N PRINT *, ’N*N = ’, N*N

END

16 32 The value 65 53610 = 2 = 1 0000 0000 0000 00002, so its square, 2 , requires 34 bits to represent (33 for the magnitude, and 1 for the sign). Thus, computing N*N causes an overﬂow on systems with 32-bit integer arithmetic. However, when that program is run on DECstation (MIPS), DEC 3000/400 (Alpha), IBM RS/6000 (POWER), IBM 3090, Silicon Graphics Indy (MIPS R4000), Silicon Graphics Indigo-2 Extreme (MIPS R4400), Stardent 1520 (MIPS), Sun Microsystems 3 (Motorola 68020), Sun Microsystems 386 (Intel 80386), and Sun Microsystems 4 (SPARC) systems, the program runs without error and prints these peculiar results:

N = 65535 N*N = -131071 N = 65536 N*N = 0 N = 65537 N*N = 131073

What has happened here? Squaring N produces these exact 32- and 33-bit results:

65 535 × 65 535 = 4 294 836 225 = 0 1111 1111 1111 1110 0000 0000 0000 00012,

65 536 × 65 536 = 4 294 967 296 = 1 0000 0000 0000 0000 0000 0000 0000 00002,

65 537 × 65 537 = 4 295 098 369 = 1 0000 0000 0000 0010 0000 0000 0000 00012.

The arithmetic hardware then truncates the results to 32 bits, giving the values −131 071 (negative because of overflow into the sign bit), 0, and 131 073 = 10 0000 0000 0000 00012. Interestingly, all but one of those systems forced run-time program termination for the overflow condition in a separate program for the computation of N/0, giving messages like those shown in Table I.7 on the facing page. However, the Stardent 1520 produced a nonsensical value of −1 and did not terminate prematurely. Repeating that test on all platforms currently available to this author shows that almost all processors terminate the computation, except for the IBM PowerPC, for which N/0 evaluates to 0. For programs that simply use integers as indexes into arrays of modest size, integer overflow is rarely of concern. However, applications that involve random-number generation, and hash-function computation, can require the formation of large products where overflow can happen. A decade-old integer overflow bug in the Java binarySearch() function was fixed3 in 2004 by replacing the index-averaging calculation

int middle = (low + high) >> 1; by the unsigned shift

int middle = (low + high) >>> 1;

3See http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=5045582. I.6. Notations for binary numbers 977

Table I.7: Behavior of integer division by zero.

System Message and action DECstation Trace/BPT trap (core dumped) DEC 3000/400 forrtl: error: ﬂoating point exception IOT trap (core dumped) Silicon Graphics Indy and Indigo-2 Trace/BPT trap (core dumped) Sun Microsystems 3, 386i, 4 *** IOT Trap = signal 6 code 0 IBM RS/6000 Breakpoint (core dumped) IBM 3090 AFB209I VFNTH : Program interrupt - FIXED-POINT DIVIDE exception

The bug had gone unnoticed until memories got large enough to have an array size of 230, and the resulting overﬂow to a negative value later resulted in an ArrayIndexOutOfBoundsException error, thanks to Java’s mandatory bounds checks for array indexing. The same bug exists in most textbook presentations of the binary-search algorithm. The bug can be prevented in another way that avoids intermediate overﬂow:

int middle = low + (high - low) >> 1; The lesson of this section is that you cannot rely on programming-language implementations to catch integer overﬂow, and sometimes, even zero divides. Your program may run to completion, but generate ridiculous results. Programs that experience uncaught integer overﬂow and then produce nonsensical output have fouled up accounting software, missile guidance systems, a U.S. Navy ship carrying nuclear weapons, electronic voting-system tallies, and even the New York Stock Exchange.

I.6 Notations for binary numbers

The numerical examples in the preceding sections demonstrate that it is tedious to write large numbers in binary, so bases that are larger powers of two are often used. That simplifies conversions from binary, because bit groups of fixed size can be directly converted to digits in the larger base. 3 In base 8 (= 2 ), we have the octal number system, in which digits 0 . . . 7 represent the binary values 0002 . . . 1112. Octal notation is uncommon on modern architectures, but was traditionally used on machines for which the word size is a multiple of 3, such as 12, 18, 24, 36, 48, or 60 bits, and curiously, also on the 16-bit DEC PDP-11 systems and the Cray 64-bit vector machines. In octal, 65 53510 = 177 7778 and 65 53710 = 200 0018. In base 16 (= 24), we have the hexadecimal number system in which the digit values 0 . . . 9 abcdef, represent the binary values 00002 . . . 11112. Hexadecimal notation is commonly used on modern systems with word sizes of 32 or 64, both multiples of 4. In hexadecimal, 65 53510 = ffff16 and 65 53710 = 1000116 The Burroughs B1700 system programming language, SDL, supported binary strings in bases 2, 4, 8, and 16: the base-4 quartal value @(4)3210@ is 3 × 43 + 2 × 42 + 1 × 4 + 0 = 228 in decimal. The Ada programming language has a convenient notation that extends easily to any number base: 65 535 = 10#65535# = 8#177777# = 16#ffff#. Fortran 77 does not provide a standard way of representing numbers in octal or hexadecimal form in program source code, or of using those forms for input and output. However, most compilers provide nonstandard extensions for doing so; regrettably, vendors have not agreed on a common format. Few compilers have provided for binary representations. The forms Zfe01, Z’fe01’, X’fe01’, and ’fe01’X have been used for hexadecimal constants, and "7741, 7741B, O’7741’, and ’7741’O for octal constants. One vendor, the now-defunct ELXSI, also supported the Ada-style notation. Use of such extensions makes code distinctly nonportable. Fortran 90 provides the forms B’1001’ and B"1001" for binary, O’7741’ and O"7741" for octal, and Z’fe01’ and Z"fe01" for hexadecimal. Ada allows underscores to separate digits to make numbers more readable: 8#177777777# = 8#177_777_777#. On the 36-bit DEC PDP-10, large octal integers are normally written in two 18-bit chunks separated by double commas, 123456, , 765432, but that scheme was never generalized. In Fortran, blanks are not significant except in character strings, so they may be used to improve readability of long numbers in program source code. The following pairs of assignments are equivalent: 978 Appendix I. Integer arithmetic

N = 2147483647 N = 2 147 483 647 PI = 3.1415926535897932385 PI = 3.141 592 653 589 793 238 5 Regrettably, few programming languages provide a simple way to read and write numbers with embedded spaces or other separators, despite the fact that in mathematical tables, spacing between digit groups is conventional to enhance readability. The mathcw library extensions to the input and output facilities of the C-language family described in Chapter 26 on page 829 and Chapter 27 on page 879 support digit grouping with underscore separators.

I.7 Summary

The chief lessons of this appendix on integer arithmetic are these: I Integer division by zero is not universally detected. I Integer overflow is almost never detected. Indeed, the specifications or standards for some programming languages require that it not be. The Java language specification [GJSB05] says that built-in integer operators do not indicate overflow or underflow in any way. The same is true in C#, unless the expression is qualified by the checked keyword. The C99 Standard simply declares that behavior is undefined in the event of integer overflow. At the Web site Fun with Fibonacci [Bee04b], this author solved an introductory programming problem in about 50 languages. Only one language, Algol 60 on the DEC PDP-10, caught integer overflow on addition. I Programmers must ensure that integer values required in a computation do not exceed their representable range, to avoid nonsensical results, or tragic failure. I The common programming idiom of testing the low-order bit to determine whether an integer is even or odd fails for negative values in one’s-complement arithmetic. I In the widely used two’s-complement system, the most negative integer has no positive companion, so the result of the integer absolute-value function can be negative. I Compilers for most programming languages, and the C-language family, fail to handle the most negative two’s- complement integer correctly in source code, and also often in program input. That error requires subterfuges like these definitions taken from the C header file :

#define INT16_MIN (-32767 - 1) #define INT32_MIN (-2147483647 - 1) #define INT64_MIN (-9223372036854775807LL - 1LL)

Programmers usually assume that integer arithmetic is trustworthy, but the limits of ﬁnite precision sometimes violate that assumption. Section 4.10.1 on page 74 describes functions in the mathcw library for safe integer arithmetic. If you are interested in learning more about the low-level details of how integer arithmetic works at the electronic circuit and algorithmic level, consult books on computer arithmetic, such as [Omo94, Par00, Kor02, EL04a, KM10, MBdD+10, BZ11, DSC12, Kul13]. Collections of important original papers on computer arithmetic are available in [Swa90a, Swa90b]. The book Hacker’s Delight [War03, War13] presents many clever tricks with integer arithmetic. The Web site http://bitsavers.org holds a large collection of manuals and books for historical computer systems. For an outstanding account of such systems up to about 1980, see Computer Architecture: Concepts and Evolution [BB97], written by two leading architects of the IBM System/360. For a detailed survey of computer systems up to 1967, see Digital Computer User’s Handbook [KK67, Chapter 1.4]. We have considered only binary arithmetic in this appendix, but because numbers can always be represented as 2 polynomials in the number base, as n = c0 + c1β + c2β + . . . , choices other than β = 2 are possible. Ternary (base-3) systems, with digits 0, 1, and 2, balanced ternary systems with digits −1, 0, and +1, base-10 decimal systems, and even systems with negative, imaginary, or complex bases, have all been proposed, and sometimes even implemented in experimental prototype machines. However, except for decimal machines, none of those designs has ever been commercially signiﬁcant. J Java interface

JAVA , n.: A BREED OF DOMESTIC HEN. — New Century Dictionary (1914).

J AVA , n.: COFFEE FROM JAVA; ALSO (SLANG) ANY SORT OF COFFEE. (1926) WE WENT BACK TO THE FIRE AND DISCUSSED BREAKFAST. ‘NOTHING BUT JAVA,’ SAID THE BUM THAT HAD THE COFFEE. — Oxford English Dictionary.

JAVA:STOCK EXCHANGE SYMBOL OF SUN MICROSYSTEMS,INC. (2007).

The Java programming language [GJS96, GJSB00, GJSB05, GJS+13, GJS+14] is defined in terms of an underlying virtual machine [LY97, LY99, SSB01, LYBB13, Set13, LYBB14]. Thus, once the virtual machine is available on a new platform, all existing precompiled Java code can run on it immediately. The Java promotional slogan, Write once, run everywhere!, reflects the wide interest that the language has received since it was first introduced in 1995, and more than 2300 books have been written about Java, far exceeding the book counts for any other programming language.1 The virtual-machine layer has a drawback, however: it makes it impossible to communicate with other languages running on the underlying hardware, unless the virtual machine is augmented with a mechanism for doing so. Fortunately, the Java developers recognized the need to access code in other languages, and provided the standard Java Native Interface (JNI) [GM98, Lia99] for that purpose. The Java type-modifier keyword native on a function definition tells the compiler that code is supplied elsewhere; consequently, the normal braced code body is replaced by a semicolon. Examples are presented on page 981. Compilation of a source-code file with the Java compiler, javac, produces a file of object code, called a class file, for the Java Virtual Machine. The javah utility extracts information from the class file, producing a header file containing prototypes for the wrapper functions. Those functions must then be written in C or C++ to interface to the native code. The C interface code is compiled and linked into a shared object library that is loaded dynamically into the virtual machine at run time when the class is instantiated.

J.1 Building the Java interface

Before looking at code samples, it is helpful to see how the Java interface to the C code in the mathcw library is built. Initially, we have just three hand-coded ﬁles in the java subdirectory:

% cd java %ls Makefile MathCW.c MathCW.java

The Makefile contains the rules for the build process, and the other two files contain the C interface code and the Java class definition. The mixed lettercase is conventional in Java class definitions, and the name MathCW intentionally resembles that of the standard Math class, whose features it can entirely replace and augment. Java requires a 64-bit long int data type, so the mathcw library must be built with a compiler that supports a corresponding type in C. The required long long int type in C is standardly available in C99, and many recent compilers support it as well. However, its use has to be enabled for pre-C99 compilers that can handle that type: defining the symbol HAVE_LONG_LONG_INT does that job. The make utility manages the build, which looks like this on a Sun Microsystems SOLARIS system:

1See http://www.math.utah.edu/pub/tex/bib/index-table-j.html#java for extensive bibliographies.

% make

javac -classpath . MathCW.java

javah -jni MathCW

cc -g -DHAVE_LONG_LONG_INT -I.. -I/usr/java/include -I/usr/java/include/solaris -c -o MathCW.o MathCW.c

cc -G -g -DHAVE_LONG_LONG_INT -I.. -I/usr/java/include -I/usr/java/include/solaris -o libMathCW.so \ MathCW.o -L/usr/local/lib -lmcw The first step creates MathCW.class, and the second step makes MathCW.h. The third step compiles the C interface, producing the object file MathCW.o. The last compilation step creates the shared object library, libMathCW.so, for the interface, as directed by the -G option. The final directory listing shows the four new files: %ls Makefile MathCW.c MathCW.class MathCW.h MathCW.java MathCW.o libMathCW.so The interface library file and the class file should be installed in a system-wide directory for general use, but there are as yet no widely used conventions for the names of such directories. For this demonstration, we assume that the two files are copied into another directory where a small Java test program is available: %ls Makefile MathCW.class libMathCW.so test.java As usual, the make utility directs the process: % make check-test

javac -classpath . test.java

java -Djava.library.path=. test MathCW erf(-2.0) = -0.9953222650189527 MathCW erf(-1.875) = -0.9919900576701199 MathCW erf(-1.75) = -0.9866716712191824 ... MathCW erfc(1.75) = 0.013328328780817555 MathCW erfc(1.875) = 0.008009942329880029 MathCW erfc(2.0) = 0.004677734981047265 Compilation of Java source files requires knowledge of where all referenced class files are stored. The -classpath option provides a list of directories to search, in the event that a suitable list has not been defined by the CLASSPATH environment variable. We set it to the current directory, represented in UNIX by the dot. However, because use of the Java Native Interface is relatively uncommon, most Java implementations do not recognize a companion environment variable for the library path, although all of them have a built-in default search path that may be discoverable only by running a system-call trace on the java program. If the shared object library is not, or cannot be, installed in one of those standard directories, then its location must be supplied at run time, as we did here by defining the java.library.path variable to be the current directory. For Java programs that are used often, it is a nuisance to have to run them by supplying them as arguments to the virtual-machine program, java. The conventional solution in UNIX is to hide the complexity in a shell script, and then invoke that script by name. The javald utility that is provided in some Java distributions makes it easy to create such wrapper scripts.

J.2 Programming the Java MathCW class

The MathCW.java file contains the complete specification of the Java MathCW class. Because none of the functions is implemented in Java, the class file is comparatively small. We present it in parts, with just enough detail to show its general structure, and with large chunks of repetitive code omitted. J.2. Programming the Java MathCW class 981

Like the standard Math class, the MathCW class does not permit subclassing or instantiation. The Java keyword final in its declaration disallows subclasses, and the keyword private in the class constructor function MathCW() prevents other classes from creating new instances of this class:

public final class MathCW { private MathCW() {}

Like the standard Math class, the MathCW class provides names for two important mathematical constants:

public static final double E = 2.71828182845904523536; public static final double PI = 3.14159265358979323846;

In some languages with strict data typing, it is possible for different functions to have identical names, provided that their signatures differ. The function names are then said to be overloaded. The signature of a function is just a list of the number and types of its arguments. The compiler can then deduce which function version is needed by examining how it is called. In practice, the function names are compiled into distinct names that include cryptic summaries of the argument types. That name mangling is generally invisible to programmers, except inside debuggers, or when tools, such as the Unix nm or strings utilities, are used to display names embedded inside object files. Java allows overloading of function names, and standard classes therefore use the same function names when signatures differ but the computation is similar. Because Java supports only two floating-point types, float and double, we need two sets of function definitions that differ only in argument types:

public static native float acos (float x); public static native float acosh (float x); public static native float adx (float x, int n); ... public static native float nanf (String tag); ... public static native float tanh (float x); public static native float tgamma (float x); public static native float trunc (float x);

public static native double acos (double x); public static native double acosh (double x); public static native double adx (double x, int n); ... public static native double nan (String tag); ... public static native double tanh (double x); public static native double tgamma (double x); public static native double trunc (double x);

Overloading is not possible for the functions that take a single String argument, because their signatures are identical. As a result, the class supplies nanf(), qnanf(), and snanf() with float return values, and nan(), qnan(), and snan() with double return values. For similar reasons, many of the routines in the random-number generator family, such as urcwf() and urcw(), are available under their own names. Java does not support pointer types, so pointer arguments in C functions are replaced by one-element arrays. For example, the C prototype

extern float frexpf (float x, int * pn); corresponds to this Java prototype:

public static native float frexp (float x, int pn[/* 1 */]);

The function can then be used in a Java code fragment like this: 982 Appendix J. Java interface

float f, x; int pn[] = new int[1];

x = 1234567.0F; f = MathCW.frexp(x, pn); System.out.println("MathCW.frexp("+x+",pn)="+f+"*2**(" + pn[0] + ")");

After years of stability of the Math class, Java 1.5 (2004) and 1.6 (2006) added several new functions:

cbrt() cosh() expm1() hypot() log10() log1p() scalb() sinh() tanh()

copySign() getExponent() nextAfter() nextUp() signum() ulp() The functions in the first group have counterparts in the C99 and mathcw libraries. Those in the second group are readily implemented in Java, sometimes with the help of other functions in the mathcw interface. All of the new functions are fully supported in the MathCW class, making it a proper superset of the standard Math class. The final part of the class definition is a static initializer that loads the shared library when the class is first instantiated at run time:

static { System.loadLibrary("MathCW"); } } // end of class MathCW

The System.loadLibrary() function maps the generic name of the library to a platform-dependent name, such as libMathCW.so on most UNIX systems, libMathCW.dylib on Apple MAC OS X, or MathCW.dll on Microsoft WIN- DOWS, finds it in the Java library path, and loads its code into the virtual machine for subsequent use when the MathCW class functions are called. Apart from the need to locate additional shared object libraries at run time, Java classes that define functions with the native type-modifier keyword behave exactly like ordinary classes implemented entirely in Java. However, there may be some sacrifice of security and stability, because code implemented outside the Java environment may not be as thoroughly checked as Java requires. For example, an out-of-bounds array index in Java is caught and handled gracefully. A similar bounds violation in dynamically loaded native code could corrupt or crash the entire Java Virtual Machine. That is not a concern for the mathcw library, however, because it is carefully written, and well tested with many different compilers on numerous operating systems and CPU architectures, and it makes little use of bug-prone and dangerous features, such as pointers and run-time array indexing. Timing measurements on several systems with the perf.java benchmark program show that the additional overhead of the JNI wrappers is not significant, except for those functions with trivial implementations, such as fabs() and fmax(), or functions like sqrt() that are replaced with inline hardware instructions at run time by some Java just-in-time compilers. Indeed, on several systems, some of the native functions from the mathcw library are consid- erably faster than those provided by the standard Java Math class. That strongly suggests that the substantial effort that would be required to reimplement, test, and maintain a version of the mathcw library in pure Java code is not warranted.

J.3 Programming the Java C interface

Although the Java primitive types of booleans, characters, integers, and floating-point numbers have exact counterparts in the C language, all of the more complex Java data types require special handling to access them from another language. For the mathcw library, the only such types are one-dimensional arrays of characters or numbers. In order to support that extra special handling, and allow bidirectional communication between Java and the native language, the C interface functions each have two additional arguments. They appear first in the argument lists, and have opaque data types JNIEnv * and jobject. For the mathcw package, we only use those arguments for those few functions that have arguments of strings or numeric arrays. The C interface in MathCW.c begins with some header-file inclusions, and a wrapper for C++ compilation that ensures that the interface will be compiled with C-style linkage, rather than the default C++ style with mangled function names encoding signatures: J.3. Programming the Java C interface 983

#include #include

#ifdef __cplusplus extern "C" { #endif

Next come the deﬁnitions of two private helper functions that simplify the handling of character-string arguments:

static void freestr(JNIEnv *env, jstring str, const char *s) { #ifdef __cplusplus (env)->ReleaseStringUTFChars(str, s); #else (*env)->ReleaseStringUTFChars(env, str, s); #endif }

static const char * getstr(JNIEnv *env, jstring str) { #ifdef __cplusplus return (env->GetStringUTFChars(str, NULL)); #else return ((*env)->GetStringUTFChars(env, str, NULL)); #endif }

These messy definitions handle the different C and C++ interface conventions of the JNI. Their purpose is simple: getstr() converts a Java String in the Unicode character set to a C string in UTF-8 format stored in a dynamically allocated memory block, and freestr() frees that memory when it is no longer needed. The venerable ASCII character set occupies the first 128 slots in Unicode, so for our purposes, no additional character-set code mapping needs to be done. Were that needed, there is another JNI library routine, JNU_GetStringNativeChars(), that could be used instead [Lia99, §10.10, p. 138]. The bulk of the MathCW.c file consists of straightforward wrapper functions that look like this:

JNIEXPORT jfloat JNICALL Java_MathCW_acos__F(JNIEnv *env, jobject obj, jfloat x) { return (acosf(x)); }

JNIEXPORT jdouble JNICALL Java_MathCW_acos__D(JNIEnv *env, jobject obj, jdouble x) { return (acos(x)); }

The interface types jfloat and jdouble are equivalent to the native C types float and double, so no additional conversions or type casts are necessary. The complex function headers are taken directly from the MathCW.h header file that is automatically generated as described in Section J.1 on page 979. The interface types JNIEXPORT, JNICALL, jfloat, and so on, are defined in the system header file , provided in every Java installation. Only the functions with character-string or vector arguments require more than a function body consisting of a single return statement. Those with string arguments are all quite similar, so here is what just one of them looks like:

JNIEXPORT jfloat JNICALL Java_MathCW_nan__F(JNIEnv *env, jobject obj, jstring tag) 984 Appendix J. Java interface

{ float result; const char * s;

s = getstr(env, tag);

if (s == (char *)NULL) result = nanf(""); else { result = nanf(s); freestr(env, tag, s); }

return (result); } The critical point here is that getstr() can fail. When it does, it returns a NULL pointer and registers an OutOfMemory exception to be thrown to the Java caller. However, the exception cannot be raised in the Java program until control returns from the native routine. Therefore, on failure, we simply pass an empty string to nanf(). Otherwise, we pass the user-provided string, and then call freestr() to free the memory for the temporary copy of the argument. In either case, the code properly returns a NaN. This interface function shows how vector arguments are handled: JNIEXPORT void JNICALL Java_MathCW_vercwf(JNIEnv * env, jobject obj, jint n, jfloatArray u) { float * v;

v = (*env)->GetFloatArrayElements(env, u, NULL);

if (v == (float *)NULL) { float q[1]; int k;

q[0] = qnanf("");

for (k = 0; k < n; ++k) (*env)->SetFloatArrayRegion(env, u, k, 1, q); } else { vercwf(n, v); (*env)->ReleaseFloatArrayElements(env, u, v, 0); } } The Java library function GetFloatArrayElements() returns the address of the first element of the array, which might require making a copy to prevent its being moved by memory-management functions running in a background thread. The check for a NULL-pointer return handles the rare case where storage cannot be allocated, in which case, the returned vector is set to quiet NaNs. The ReleaseFloatArrayElements() function transfers the contents of the C array to the original Java array, if necessary, and frees any storage needed for a copy of the array. The final code in MathCW.c provides the closing brace to match the one following the extern declaration at the beginning of the file, and it is visible only to C++ compilers: #ifdef __cplusplus } #endif J.4. Using the Java interface 985

J.4 Using the Java interface

Java requires calls to functions defined in other classes to be prefixed with the class name and a dot. For example, the square-root function provided by the standard Math class is invoked as Math.sqrt(x). All that is needed to convert an existing program to use mathematical functions from the MathCW class is to change the class prefix. Here is a short program that illustrates calls to the ordinary and complementary complete elliptic integral functions, which are absent from the standard Math class:

class sample { public static void main (String[] args) { double x;

for (x = -1.0; x <= 1.0; x += 0.125) { System.out.println("MathCW elle ("+x+")="+MathCW.elle (x)); System.out.println("MathCW ellec("+x+")="+MathCW.ellec(x)); } } }

Assuming that the MathCW class ﬁle and library are in the current directory, the sample program can be compiled and run like this:

% javac sample.java

% java -Djava.library.path=. sample MathCW elle (-1.0) = 1.0 MathCW ellec(-1.0) = 1.5707963267948966 MathCW elle (-0.875) = 1.2011106307369144 MathCW ellec(-0.875) = 1.4742582575626793 ... MathCW elle (0.875) = 1.2011106307369144 MathCW ellec(0.875) = 1.4742582575626793 MathCW elle (1.0) = 1.0 MathCW ellec(1.0) = 1.5707963267948966 L Letter notation

PERHAPS YOU HAVE LEARNED IT WITHOUT BOOK: BUT,IPRAY, CAN YOU READ ANY THING YOU SEE? AY, IF I KNOW THE LETTERS AND THE LANGUAGE.

—SHAKESPEARE’S Romeo and Juliet (1595).

The tables in this Appendix summarize common uses of Latin and Greek letters in this book.

Table L.1: Latin letters used in mathematics in this book.

Name Description d, D decimal digit x, y real variables z complex variable f (x) arbitrary function of x g(x) arbitrary function of x h(x) arbitrary function of x

Bn n-th Bernoulli number

En n-th Euler number

Fn n-th Fibonacci number

Tn n-th tangent number G guard bit in floating-point arithmetic L last stored bit in floating-point arithmetic R rounding bit in floating-point arithmetic S sticky bit in floating-point arithmetic O(expr) order of expr P(expr) probability that expr is true P(x) polynomial approximation Q(x) polynomial approximation R(x) rational polynomial approximation (= P(x)/Q(x)) E(m) complete elliptic integral function of second kind K(m) complete elliptic integral function of first kind

Tn(u) Chebyshev polynomial of degree n of the ﬁrst kind

Iν(z) modified cylindrical Bessel function of order ν of first kind Jν(z) cylindrical Bessel function of order ν of first kind Kν(z) modified cylindrical Bessel function of order ν of second kind Yν(z) cylindrical Bessel function of order ν of second kind

iν(z) modified spherical Bessel function of order ν of first kind jν(z) spherical Bessel function of order ν of first kind kν(z) modified spherical Bessel function of order ν of second kind yν(z) spherical Bessel function of order ν of second kind

Table L.2: Greek letters in mathematics used in this book and related literature, in their order of appearance in the Greek alphabet.

Symbol Description α,A alpha; (lowercase) number base; (lowercase) variable name β,B beta; (lowercase) floating-point base γ gamma; Euler–Mascheroni constant (≈ 0.577 215); with two arguments, complementary incomplete gamma function Γ capital gamma; with one argument, gamma function (generalized factorial function); with two arguments, ordinary incomplete gamma function δ delta; something small Δ capital delta; difference operator; triangle operator ,E epsilon; (lowercase) something small; (lowercase) floating-point big machine epsilon = β1−t, for base β and t-digit significand ε variant epsilon ζ,Z zeta; (lowercase) Riemann zeta function; (lowercase) variable name; (uppercase) elliptic function η,H eta; (lowercase) variable name; (uppercase) elliptic function θ, Θ theta; (lowercase) angle of rotation; (lowercase) variable name; (uppercase) elliptic function ϑ variant theta ι,I iota κ,K kappa λ, Λ lambda μ,M mu; (lowercase) arithmetic mean; (lowercase) variable name ν,N nu; (lowercase) frequency of electromagnetic radiation; (lowercase) number of degrees of freedom; (lowercase) order of Bessel function; (lowercase) variable name ξ, Ξ xi; (lowercase) variable name o, O omicron π pi; one of the most important numbers in mathematics; ratio of circumference of circle to its diameter variant pi Π, ∏ capital pi; product operator ρ,P rho variant rho σ sigma; nonterminal form in Greek words; standard deviation in statistics ς variant sigma; terminal form in Greek words Σ, ∑ capital sigma; summation operator τ,T tau; (lowercase) variable name υ,Y upsilon φ, Φ phi; (lowercase) angle of rotation; (lowercase) golden ratio; (lowercase) variable name; (uppercase) cumulative distribution function ϕ variant phi χ,X chi; χ2 (chi-square) measure in statistics ψ, Ψ psi; (lowercase) psi function ω, Ω omega; (lowercase) angular frequency P Pascal interface

BLAISE PASCAL (1623–1662): FRENCH MATHEMATICIAN, SCIENTIST, AND PHILOSOPHER, AND AT THE AGE OF 19, INVENTOR OF A CALCULATING MACHINE.

The Pascal programming language [JW91], first introduced on the CDC 6400 in 1970, attracted wide interest as a clean and simple language for teaching computer programming. Thanks to its small size, and the free availability of a relatively portable implementation of a compiler that produced P-code, a simple assembly language for a small virtual machine, by the mid 1980s, Pascal had been ported to many computer systems, from 8-bit microcomputers to mainframes. The TEX typesetting system used for the production of this book is written in a markup language from which Pascal code and TEX documentation can be produced. Several restrictions of the Pascal language, however, made it difficult to use for large programming projects, and for programs that need access to the underlying operating system. Its deficiencies are well chronicled in two famous papers [WSH77, Ker81], and when C compilers became widely available by the late 1980s, Pascal use fell sharply. Nevertheless, some popular Pascal compilers introduced language extensions that alleviated many of the un- pleasant restrictions, and that practical experience led to the revised 1990 ISO Extended Pascal Standard [PAS90]. The GNU Pascal compiler, gpc, largely conforms to that Standard, and offers language and library extensions for interfacing to the operating system, making Pascal potentially as available to programmers on modern computing systems as the C language is.

P.1 Building the Pascal interface

Before looking at the details of the interface between Pascal and the mathcw library, it is useful to see how the interface is built. Initially, we have just a few ﬁles in the pascal subdirectory:

% cd pascal %ls exp RCS test02.pas test06.pas test10.pas Makefile README test03.pas test07.pas mathcw.pas test00.pas test04.pas test08.pas okay test01.pas test05.pas test09.pas

The Makefile contains the rules for the build process, and the mathcw.pas file contains the interface definition. The other test*.pas source files are simple tests of some of the library routines. The make utility manages the build, which looks like this on a Sun Microsystems SOLARIS system:

% make

gpc -c mathcw.pas

gpc -c test00.pas gpc test00.o -o test00

gpc -o test01 test01.pas -L.. -lmcw

gpc -o test02 test02.pas -L.. -lmcw

Table P.1: Numeric data types provided by the GNU Pascal compiler, gpc. The sizes shown are typical of modern 32-bit and 64-bit computers.

C type Pascal types size (bits) signed char ByteInt 8 short int ShortInt 16 int Integer 32 long int MedInt 32 or 64 long long int LongInt 64 float ShortReal or Single 32 double Real or Double 64 long double LongReal or Extended 80 or 128 char * CString 32 or 64 const char * protected CString 32 or 64

gpc -o test03 test03.pas -L.. -lmcw

gpc -o test04 test04.pas -L.. -lmcw

gpc -c test05.pas gpc -o test05 test05.o mathcw.o -L.. -lmcw

...

gpc -c test10.pas gpc -o test10 test10.o mathcw.o -L.. -lmcw

The first step compiles the interface, and the remaining ones build the test programs. The first four test programs contain internal directives that tell the compiler how to find the additional object files in the parent directory. The remaining test programs get their object files directly from the mathcw object library. A simple check verifies correct operation of all of the test programs, by running them and comparing their output with correct output stored in the okay subdirectory:

% make check

There should be no output but the test names:

======test00 ======test01 ... ======test10

P.2 Programming the Pascal MathCW module

The original Pascal language had only one integer type, Integer, and one floating-point type, Real, with implementation-dependent sizes. The extended language supported by GNU gpc offers the numeric types shown in Table P.1. Pascal is a case-insensitive language, and the lettercase shown in the table is conventional in the GNU Pascal compiler’s documentation. Other Pascal compilers may offer only some of those types, and may use different names. As in C, the Pascal type sizes are platform dependent, but GNU Pascal ensures that the type correspondence with C is maintained. Thus, on a SPARC system, long int and MedInt are both 32-bit types, whereas on an Alpha, they are both 64-bit types. The CString type is a useful extension provided by the GNU compiler to facilitate communicating with the operating system and its many support libraries. Pascal strings are normally represented by a data structure containing P.2. Programming the Pascal MathCW module 991 a length and an array of characters. The GNU compiler allocates an additional array element that is set to the NUL character to simplify conversion of a fixed-length Pascal string to a NUL-terminated C string. Like C, Pascal normally uses call-by-value argument-passing conventions, but it uses call-by-reference when the argument is declared with the var keyword. That makes all of the arguments needed for the mathcw library easily representable in Pascal. Pascal is a strongly typed language designed for fast one-pass compilation. That means that all functions, procedures, and variables must be declared before use. The GNU compiler allows a function or procedure body to be replaced by external name ’rtnname’, to tell the compiler that the definition is provided elsewhere in another language in a routine named rtnname. A native Pascal implementation of the double-precision square-root function might be written like this:

function Sqrt (x : Real) : Real; begin { implementation code omitted } end;

For an external implementation in C, we can instead write this:

function Sqrt (x : Real) : Real; external name ’sqrt’;

If only one or two functions from the mathcw library are required in a Pascal program, then it is not difficult to supply explicit declarations such as those that we illustrated for Sqrt(). We then have a choice of how to tell the compiler where to find the external routines: by linker directives embedded in comments in the source code, or by supplying either object files or object libraries at link time. The first four test programs take the first approach. For example, test00.pas begins like this:

program test00(input,output);

{$L ’../adxf.o’} {$L ’../expf.o’} {$L ’../fabsf.o’} {$L ’../inftyf.o’} {$L ’../isinff.o’} {$L ’../isnanf.o’} {$L ’../psif.o’} {$L ’../psilnf.o’} {$L ’../qnanf.o’}

var i : Integer; x : ShortReal;

function Psif (x : ShortReal) : ShortReal; external name ’psif’; function Psilnf (x : ShortReal) : ShortReal; external name ’psilnf’;

If each referenced function were defined entirely in a single object file, then only two linker directives would be needed. However, that is rarely the case, and as the code fragment shows, the directive approach requires introducing a hard-to-maintain list of object-file dependencies, exposing irrelevant details that should be hidden. The test programs test01.pas, test02.pas, and test03.pas provide directives for just the object files that they explicitly require, and the Makefile supplies the library name and location for linking. A much better approach is to define a Pascal module containing all of the function prototypes, and then simply reference that module whenever it is needed. The mathcw.pas file that defines the interface part of the module begins like this:

module MathCW interface;

The module statement provides the name, MathCW, by which the module can be referenced in other source ﬁles. Next comes the export statement that supplies a long list of names deﬁned in the interface that are available to users of the module. For convenience, the list is sorted alphabetically within each precision family: 992 Appendix P. Pascal interface

export MathCW = ( { ShortReal family } acosf, acoshf, adxf, asinf, asinhf, atanf, atan2f, ...

{ Real family } acos, acosh, adx, asin, asinh, atan, atan2, ...

{ LongReal family } acosl, acoshl, adxl, asinl, asinhl, atanl, atan2l, ... );

The declarations of the single-precision functions are mostly straightforward:

function acosf(x : ShortReal) : ShortReal; external name ’acosf’; function acoshf(x : ShortReal) : ShortReal; external name ’acoshf’; ... function frexpf(x : ShortReal; var n : Integer) : ShortReal; external name ’frexpf’; ... function nanf(protected s : CString) : ShortReal; external name ’nanf’; ...

The declarations for frexpf() and nanf() show how pointer arguments are handled. The protected keyword prevents modiﬁcation of the argument inside the called function when that function is written in Pascal. Here, it guar- antees that a copy of the original argument is passed to the function. The effect is thus somewhat like that of the C-language const qualiﬁer. The double-precision function declarations are similar, except for the special case of the power function, which must be renamed to avoid a collision with the Pascal pow operator:

function acos(x : Real) : Real; external name ’acos’; function acosh(x : Real) : Real; external name ’acosh’; ... function powd(x : Real; y : Real) : Real; external name ’pow’; ...

The interface part of the module ends with the extended-precision function declarations:

function acosl(x : LongReal) : LongReal; external name ’acosl’; function acoshl(x : LongReal) : LongReal; external name ’acoshl’; ...

end.

The remainder of the mathcw.pas ﬁle deﬁnes the implementation part of the module:

module MathCW implementation;

to begin do begin { module initialization code here: none currently needed } end;

to end do begin { module termination code here: none currently needed } end;

end. P.3. Using the Pascal module interface 993

Any native Pascal code required for the module would be provided in the implementation part, along with the initialization and termination code blocks. We do not require any real implementation code here, because the mathcw library provides it elsewhere, so the implementation block could have been left empty, or even omitted. We prefer to keep a small template in place, however, in case an implementation block is needed in future extensions of the library or its interface from Pascal. Compilation of the mathcw.pas ﬁle produces two output ﬁles:

% ls mathcw.* mathcw.pas

% make mathcw.o gpc -c mathcw.pas

% ls -lo mathcw.* -rw-rw-r-- 1 mcw 107769 2006-04-19 09:23 mathcw.gpi -rw-rw-r-- 1 mcw 872 2006-04-19 09:23 mathcw.o -rw-rw-r-- 1 mcw 22105 2006-04-19 05:57 mathcw.pas

The large interface ﬁle, mathcw.gpi needs to be available to the compiler for use by other programs. Only the small object ﬁle, mathcw.o, needs to be provided to the linker.

P.3 Using the Pascal module interface

There are no standard conventions about where GNU Pascal module ﬁles are stored for system-wide use, so, for simplicity, we assume that the mathcw.pas module ﬁle is in the same directory as the code that requires it. All that is needed to make the entire mathcw library available to a Pascal program is a single import statement following the program statement. Here is a fragment of test05.pas that shows how:

program test05(input,output);

import MathCW;

var i : Integer; x : ShortReal;

begin writeln(’Test of Pascal interface to MathCW library:’); writeln(’’);

x := -2.0;

fori:=0to32do begin writeln(’MathCW erff(’, x:6:3, ’) = ’, erff(x):10:6); x := x + 0.125; end; ... end.

The only additional thing that needs to be done is to supply the interface object ﬁle and the library name and location at link time, like this:

% gpc -o test05 test05.pas mathcw.o -L.. -lmcw

Given the severe limitations of historical Pascal implementations, it is clear that external function declarations and modules provide a powerful extension mechanism for the language, and they make it easy to interface Pascal code to the huge collection of libraries written in C on modern operating systems. What is lacking, compared to Ada, 994 Appendix P. Pascal interface

C++, C#, and Java, is the additional notion of a module or namespace qualiﬁer on function names to disambiguate name conﬂicts.

P.4 Pascal and numeric programming

The numeric function repertoire of early Pascal was a small subset of that of Fortran, but the 1990 revision improved that situation, and also added a complex type with constructor functions cmplx(r, i) and polar(r,theta), compo- nent extractor functions re(z) and im(z), and elementary functions with the same names as their real counterparts. The 1990 extensions include based integers for any base from 2 to 36 (e.g., 16#cafefeed), but alas, no hexadecimal representation of exact floating-point constants, and no predefined names for the various numeric limits and parameters that C supplies in the and header files. The GNU gpc compiler adds interfaces to assembly language, and to the GMP multiple-precision arithmetic library. The limited control of numeric output formatting remains a weak spot in the Pascal language. The test program in the file numtest.pas exercises many features of IEEE 754 64-bit arithmetic, and, at least with the GNU gpc compiler, demonstrates that the IEEE nonstop model of computation is fully supported, and Infinity, NaN, and signed zero are handled correctly. A store() function provides a workaround for the lack of a volatile qualifier, and prevents higher-precision intermediate computation when that is injurious to the job. The needed helper functions are easily expressed in Pascal:

function IsInf(x : Real) : Boolean; begin IsInf := (abs(1.0 / x) = 0.0) and (abs(x) > 1.0) end;

function IsNaN(x : Real) : Boolean; begin IsNaN := (x <> x) end;

function Store(x : Real) : Real; begin Store := x end;

With a substantial external numeric function library interfaced to the language in a similar way to that described earlier in this Appendix, Pascal programmers can enjoy a comfortable numeric programming environment akin to that available in C and Fortran 77. Bibliography

(1870) THE ANNALS OF BIBLIOGRAPHY AFFORD MANY EXAMPLES OF THE DELIRIOUS EXTENT TO WHICH BOOK-FANCYING CAN GO. — Oxford English Dictionary.

Entries are followed by a braced list of page numbers where the entry is cited. Personal names are indexed in the separate author/editor index on page 1039. Some bibliography entries cite other entries, so the braced lists may include pages within the bibliography. Entries include CODEN (Chemical Abstracts Periodical Number), DOI (Digital Object Identifier), ISBN (International Standard Book Number), ISSN (International Standard Serial Number), LCCN (US Library of Congress Call Number), and Web URL (Uniform Resource Locator) data, where available. Prefix http://doi.org/ to any DOI value to convert it to a valid Web address. Should you find that a URL recorded here is no longer accessible, you may be able to locate a historical copy on the Internet Archive WayBack Machine at http://www.archive.org/.

[AAR99] George E. Andrews, Richard Askey, and Ranjan Roy. Special Functions, volume 71 of Encyclopedia of Mathematics and its Applications. Cambridge University Press, Cambridge, UK, 1999. ISBN 0-521-62321-9 (hardcover), 0-521-78988-5 (paperback); 978-0-521-62321-6 (hardcover), 978-0-521-78988-2 (paperback). xvi + 664 pp. LCCN QA351 .A74 1999. {521, 619, 630, 827} [ABB64] Gene M. Amdahl, Gerrit A. Blaauw, and Frederick P. Brooks, Jr. Architecture of the IBM System/360. IBM Journal of Research and Devel- opment, 8(2):87–102, April 1964. CODEN IBMJAE. ISSN 0018-8646 (print), 2151-8556 (electronic). URL http://www.research.ibm.com/ journal/50th/architectures/amdahl.html; http://www.research.ibm.com/journal/rd/082/ibmrd0802C.pdf. DOI 10.1147/ rd.82.0087. {963} [ABB00] Gene M. Amdahl, Gerrit A. Blaauw, and Frederick P. Brooks, Jr. Architecture of the IBM System/360. IBM Journal of Research and Development, 44(1/2):21–36, January/March 2000. CODEN IBMJAE. ISSN 0018-8646 (print), 2151-8556 (electronic). URL http:// www.research.ibm.com/journal/rd/441/amdahl.pdf. DOI 10.1147/rd.441.0021. Special issue: reprints on Evolution of information technology 1957–1999. {963} [ABC+99] Paul H. Abbott, David G. Brush, Clarence W. Clark III, Chris J. Crone, John R. Ehrman, Graham W. Ewart, Clark A. Goodrich, Michel Hack, John S. Kapernick, Brian J. Minchau, William C. Shepard, Ronald M. Smith, Sr., Richard Tallman, Steven Walkowiak, Akio Watanabe, and W. Romney White. Architecture and software support in IBM S/390 Parallel Enterprise Servers for IEEE ﬂoating-point arithmetic. IBM Journal of Research and Development, 43(5/6):723–760, September/November 1999. CODEN IBMJAE. ISSN 0018- 8646 (print), 2151-8556 (electronic). URL http://www.research.ibm.com/journal/rd/435/abbott.html. DOI 10.1147/rd.435.0723. Besides important history of the development of the S/360 ﬂoating-point architecture, this paper has a good description of IBM’s algorithm for exact decimal-to-binary conversion, complementing earlier ones [Cli90, Knu90, SW90, BD96, SW04]. {895, 998, 1004, 1034} [ABM+97] Jeanne C. Adams, Walter S. Brainerd, Jeanne T. Martin, Brian T. Smith, and Jerrold L. Wagener, editors. Fortran 95 Handbook: Complete ISO/ANSI Reference. MIT Press, Cambridge, MA, USA, November 1997. ISBN 0-262-51096-0; 978-0-262-51096-7. xii + 711 pp. LCCN QA76.73.F25 F6 1997. URL http://www.cbooks.com/sqlnut/SP/search/gtsumt?source=&isbn=0262510960. {106} [Ada69] Arthur G. Adams. Remark on Algorithm 304 [S15]: Normal curve integral. Communications of the Association for Computing Machinery, 12(10):565–566, October 1969. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). DOI 10.1145/363235.363253. {618} [Ada83] American National Standard Reference Manual for the Ada Programming Language: ANSI/MIL-STD-1815A. American National Standards Institute, New York, NY, USA, 1983. {vii} [Ada95] ISO/IEC 8652:1995: Information technology — Programming languages — Ada. International Organization for Standardization, Geneva, Switzerland, 1995. 511 pp. URL http://www.adaic.org/standards/05rm/RM-Final.pdf. Available in English only. {vii, 911, 928} [Ada12] ISO/IEC 8652:2012 Information technology — Programming languages — Ada. International Organization for Standardization, Geneva, Switzerland, 2012. 832 (est.) pp. URL http://www.ada-auth.org/standards/ada12.html; http://www.iso.org/iso/home/store/ catalogue_ics/catalogue_detail_ics.htm?csnumber=61507. {vii}

[ADW77a] Donald E. Amos, S. L. Daniel, and M. K. Weston. Algorithm 511: CDC 6600 subroutines IBESS and JBESS for Bessel functions Iν(x) and Jν(x), x ≥ 0, ν ≥ 0 [S18]. ACM Transactions on Mathematical Software, 3(1):93–95, March 1977. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/355719.355727. See erratum [Amo78]. {693, 996}

[ADW77b] Donald E. Amos, S. L. Daniel, and M. K. Weston. CDC 6600 subroutines IBESS and JBESS for Bessel functions Iν(x) and Jν(x), x ≥ 0, ν ≥ 0. ACM Transactions on Mathematical Software, 3(1):76–92, March 1977. CODEN ACMSCU. ISSN 0098-3500 (print), 1557- 7295 (electronic). DOI 10.1145/355719.355726. {693}

[AE06] J. V. Armitage and W. F. Eberlein. Elliptic Functions. London Mathematical Society student texts. Cambridge University Press, Cam- bridge, UK, 2006. ISBN 0-521-78078-0 (hardcover), 0-521-78563-4 (paperback); 978-0-521-78078-0 (hardcover), 978-0-521-78563-1 (paperback). xiii + 387 pp. LCCN QA343 .A95 2006. {627} [AF09] Alan Agresti and Christine A. Franklin. Statistics: The Art and Science of Learning from Data. Pearson Prentice Hall, Upper Saddle River, NJ 07458, USA, second edition, 2009. ISBN 0-13-513199-5 (student edition), 0-13-513240-1 (instructor edition); 978-0-13-513199-2 (student edition), 978-0-13-513240-1 (instructor edition). xxviii + 769 + 47 pp. LCCN QA276.12 .A35 2009. {196} [AG96] Ken Arnold and James Gosling. The Java Programming Language. The Java Series. Addison-Wesley, Reading, MA, USA, May 1, 1996. ISBN 0-201-63455-4; 978-0-201-63455-6. xviii + 333 pp. LCCN QA76.73.J38A76 1996. {vii} [AG98] Ken Arnold and James Gosling. The Java Programming Language. Addison-Wesley, Reading, MA, USA, second edition, 1998. ISBN 0-201-31006-6; 978-0-201-31006-1. xix + 442 pp. LCCN QA76.73.J38A76 1998. {vii} [AGH00] Ken Arnold, James Gosling, and David Holmes. The Java Programming Language. Addison-Wesley, Reading, MA, USA, third edition, 2000. ISBN 0-201-70433-1; 978-0-201-70433-4. xxiv + 595 pp. LCCN QA76.73.J38 A76 2000. {vii} [AH01] Jörg Arndt and Christoph Haenel. Pi — Unleashed. Springer-Verlag, Berlin, Germany / Heidelberg, Germany / London, UK / etc., 2001. ISBN 3-540-66572-2; 978-3-540-66572-4. xii + 270 pp. LCCN QA484.A7513 2001. DOI 10.1007/978-3-642-56735-3. Includes CD-ROM. Translated by Catriona and David Lischka from the 1998 German original, Pi: Algorithmen, Computer, Arithmetik. {14, 623, 632} [AHG+04] Brad Abrams, Anders Hejlsberg, Brian Grunkemeyer, Joel Marcey, Kit George, Krzysztof Cwalina, and Jeffrey Richter. .NET Framework Standard Library Annotated Reference. Volume 1: Base Class Library and Extended Numerics Library. Microsoft .NET development series. Addison-Wesley, Reading, MA, USA, 2004. ISBN 0-321-15489-4 (hardcover); 978-0-321-15489-7 (hardcover). xxvi + 528 pp. LCCN QA76.76.M52 A27 2004. URL http://www.aw-bc.com/catalog/academic/product/0,1144,0321154894,00.html. Foreword by Joel Marcey. {917} [Ale10] Andrei Alexandrescu. The D programming language. Addison-Wesley, Reading, MA, USA, 2010. ISBN 0-321-65953-8 (hardcover), 0-321-63536-1 (paperback); 978-0-321-65953-8 (hardcover), 978-0-321-63536-5 (paperback). xxvii + 463 pp. LCCN QA76.73.D138 A44 2010; QA76.73.D138. {830} [AM59] Robert L. Ashenhurst and Nicholas Metropolis. Unnormalized ﬂoating point arithmetic. Journal of the Association for Computing Machinery, 6(3):415–428, July 1959. CODEN JACOAH. ISSN 0004-5411 (print), 1557-735x (electronic). DOI 10.1145/320986.320996. {960, 966} [Ami62] D. Amit. Algorithm 147 [S14]: PSIF. Communications of the Association for Computing Machinery, 5(12):605, December 1962. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). DOI 10.1145/355580.369107. See certiﬁcations [Tha63, Par69]. {521, 1027, 1035} [Amm77] Urs Ammann. On code generation in a PASCAL compiler. Software — Practice and Experience, 7(3):391–423, May/June 1977. CODEN SPEXBL. ISSN 0038-0644 (print), 1097-024X (electronic). DOI 10.1002/spe.4380070311. {949}

[Amo78] Donald E. Amos. Erratum: “Algorithm 511: CDC 6600 subroutines IBESS and JBESS for Bessel functions Iν(x) and Jν(x), x ≥ 0, ν ≥ 0 [S18]”. ACM Transactions on Mathematical Software, 4(4):411, December 1978. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/356502.356501. See [ADW77a]. {995} [Amo83] Donald E. Amos. Algorithm 610: A portable FORTRAN subroutine for derivatives of the psi function. ACM Transactions on Mathematical Software, 9(4):494–502, December 1983. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/356056.356065. {521} [Amo86] Donald E. Amos. Algorithm 644: A portable package for Bessel functions of a complex argument and nonnegative order. ACM Transactions on Mathematical Software, 12(3):265–273, September 1986. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). URL http://www.acm.org/pubs/citations/journals/toms/1986-12-3/p265-amos/. DOI 10.1145/7921.214331. See remarks [Amo90, Amo95, Kod07]. {693, 996, 1020} [Amo90] Donald E. Amos. Remark on “Algorithm 644: A portable package for Bessel functions of a complex argument and nonnegative order”. ACM Transactions on Mathematical Software, 16(4):404, December 1990. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). URL http://www.acm.org/pubs/citations/journals/toms/1990-16-4/p404-amos/. DOI 10.1145/98267.98299. See [Amo86, Amo95, Kod07]. {996, 1020} [Amo95] Donald E. Amos. A remark on Algorithm 644: A portable package for Bessel functions of a complex argument and nonnegative order. ACM Transactions on Mathematical Software, 21(4):388–393, December 1995. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/212066.212078. See [Amo86, Amo90, Kod07]. {996, 1020} [And98] Larry C. Andrews. Special Functions of Mathematics for Engineers. Oxford University Press, Oxford, UK, second edition, 1998. ISBN 0- 19-856558-5 (Oxford hardcover), 0-8194-2616-4 (SPIE Press hardcover); 978-0-19-856558-1 (Oxford hardcover), 978-0-8194-2616-1 (SPIE Press). xvii + 479 pp. LCCN QA351 .A75 1998. {827} [AND15] P. Ahrens, H. D. Nguyen, and J. Demmel. Efficient reproducible floating point summation and BLAS. Report UCB/EECS-2015-229, EECS Department, University of California, Berkeley, Berkeley, CA, USA, December 8, 2015. URL http://www.eecs.berkeley.edu/ Pubs/TechRpts/2015/EECS-2015-229.html. {385} [AND16] P. Ahrens, H. D. Nguyen, and J. Demmel. Efficient reproducible floating point summation and BLAS. Report UCB/EECS-2016- 121, EECS Department, UC Berkeley, Berkeley, CA, USA, June 18, 2016. URL http://www.eecs.berkeley.edu/Pubs/TechRpts/2016/ EECS-2016-121.html. {385} [Ano94] Anonymous. Corrigenda. ACM Transactions on Mathematical Software, 20(4):553, December 1994. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). See [HFT94]. {1014} Bibliography 997

[ANS87] ANSI/IEEE. ANSI/IEEE Std 854-1987: An American National Standard: IEEE Standard for Radix-Independent Floating-Point Arithmetic. IEEE, New York, NY, USA, October 5, 1987. ISBN 0-7381-1167-8; 978-0-7381-1167-4. v + 14 pp. URL http://ieeexplore.ieee.org/ iel1/2502/1121/00027840.pdf. Revised 1994. INSPEC Accession Number: 3095617. {1, 104, 109, 827, 928, 966} [ANSI78] American National Standard Programming Language FORTRAN: Approved April 3, 1978, American National Standards Institute, Inc.: ANSI X3.9-1978. Revision of ANSI X3.9-1966. American National Standards Institute, New York, NY, USA, revised edition, 1978. 438 pp. {vii, 341} [ANSI97] ANSI/ISO/IEC 1539-1:1997: Information Technology — Programming Languages — Fortran — Part 1: Base language. American National Standards Institute, New York, NY, USA, 1997. URL http://www.fortran.com/fortran/iso1539.html. {106} [AS64] Milton Abramowitz and Irene A. Stegun, editors. Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Ta- bles, volume 55 of Applied mathematics series. U. S. Department of Commerce, Washington, DC, USA, 1964. xiv + 1046 pp. LCCN QA47.A161 1972; QA 55 A16h 1972. Tenth printing, with corrections (December 1972). This book is also available online at http://www.convertit.com/Go/ConvertIt/Reference/AMS55.ASP in bitmap image format. {6, 58, 59, 196, 269, 301, 303, 341, 498, 521, 560, 562, 587, 589, 593, 600, 619, 624, 632, 638, 643, 651, 657, 661, 666, 673, 675, 678, 681–683, 689, 693, 731, 826} [AT17] Jared L. Aurentz and Lloyd N. Trefethen. Chopping a Chebyshev series. ACM Transactions on Mathematical Software, 43(4):33:1–33:21, March 2017. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/2998442. {57} [AW88] Lothar Afflerbach and Klaus Wenzel. Normal random numbers lying on spirals and clubs. Statistical Papers = Statistische Hefte,29 (1):237–244, December 1988. CODEN STPAE4. ISSN 0932-5026 (print), 1613-9798 (electronic). URL http://www.springerlink.com/ content/q7885421202m6565/. DOI 10.1007/BF02924529. {193} [AW05] George B. Arfken and Hans-Jürgen Weber. Mathematical Methods for Physicists. Elsevier, Amsterdam, The Netherlands, sixth edition, 2005. ISBN 0-12-059876-0, 0-12-088584-0 (paperback); 978-0-12-059876-2, 978-0-12-088584-8 (paperback). xii + 1182 pp. LCCN QA37.3 .A74 2005. {8, 196, 303, 582, 627, 693} [AWH13] George B. Arfken, Hans-Jürgen Weber, and Frank E. Harris. Mathematical Methods for Physicists: a Comprehensive Guide. Elsevier Academic Press, Amsterdam, The Netherlands, seventh edition, 2013. ISBN 0-12-384654-4 (hardcover), 1-4832-7782-8 (e-book); 978-0- 12-384654-9 (hardcover), 978-1-4832-7782-0 (e-book). xiii + 1205 pp. LCCN QA37.3 .A74 2013. URL http://www.sciencedirect.com/ science/book/9780123846549. {8, 196, 303, 582, 627, 693} [Ayo74] Raymond Ayoub. Euler and the zeta function. American Mathematical Monthly, 81(10):1067–1086, December 1974. CODEN AMMYAE. ISSN 0002-9890 (print), 1930-0972 (electronic). URL http://www.jstor.org/stable/2319041. DOI 10.2307/2319041. {579, 590} [Bai81] B. J. R. Bailey. Alternatives to Hastings’ approximation to the inverse of the normal cumulative distribution function. Applied Statistics, 30(3):275–276, 1981. CODEN APSTAG. ISSN 0035-9254 (print), 1467-9876 (electronic). URL http://www.jstor.org/stable/2346351. DOI 10.2307/2346351. {618} [Bai95] David H. Bailey. A Fortran-90 based multiprecision system. ACM Transactions on Mathematical Software, 21(4):379–387, December 1995. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/212066.212075. See also extension to complex arithmetic [Smi98]. {1032} [Bak61] Frank B. Baker. A method for evaluating the area of the normal function. Communications of the Association for Computing Machinery,4 (5):224–225, May 1961. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). DOI 10.1145/366532.366544. {618} [Bak92] Louis Baker. C Mathematical Function Handbook. McGraw-Hill programming tools for scientists and engineers. McGraw-Hill, New York, NY, USA, 1992. ISBN 0-07-911158-0; 978-0-07-911158-6. xviii + 757 pp. LCCN QA351.B17 1991; QA351 .B17 1992. {521, 556, 558, 567, 583, 589, 593, 657, 682, 827} [Ban98] Jerry Banks, editor. Handbook of Simulation: Principles, Methodology, Advances, Applications, and Practice. Wiley, New York, NY, USA, 1998. ISBN 0-471-13403-1 (hardcover); 978-0-471-13403-9 (hardcover). xii + 849 pp. LCCN T57.62 .H37 1998. DOI 10.1002/9780470172445. {1003, 1021} [Bar92] John D. Barrow. Pi in the Sky: Counting, Thinking, and Being. Clarendon Press, Oxford, UK, 1992. ISBN 0-19-853956-8; 978-0-19-853956-8. ix + 317 pp. LCCN QA36 .B37 1992. {14, 623} [Bar96] John D. Barrow. Pi in the Sky: Counting, Thinking, and Being. Little, Brown and Company, Boston, Toronto, London, 1996. ISBN 0-316-08259-7; 978-0-316-08259-4. ix + 317 pp. LCCN QA36 .B37 1994. {14, 623} [Bar06] Jason Socrates Bardi. The Calculus Wars: Newton, Leibniz, and the Greatest Mathematical Clash of all Time. Thunder’s Mouth Press, New York, NY, USA, 2006. ISBN 1-56025-992-2, 1-56025-706-7; 978-1-56025-992-3, 978-1-56025-706-6. viii + 277 pp. LCCN QA303 .B2896 2006. {8} [Bay90] Carter Bays. C364. Improving a random number generator: a comparison between two shuffling methods. Journal of Statistical Computation and Simulation, 36(1):57–59, May 1990. CODEN JSCSAJ. ISSN 0094-9655 (print), 1026-7778 (electronic), 1563-5163. URL http://www.tandfonline.com/doi/abs/10.1080/00949659008811264. DOI 10.1080/00949659008811264. See [LL73, BD76] for the two nearly identical shuffling algorithms. This paper explains why the first does not lengthen the generator period, or much reduce the lattice structure of linear congruential generators, but the second improves both dramatically. {179, 998, 1022} [BB83] Jonathan M. Borwein and Peter B. Borwein. A very rapidly convergent product expansion for π [pi]. BIT, 23(4):538–540, December 1983. CODEN BITTEL, NBITAB. ISSN 0006-3835 (print), 1572-9125 (electronic). URL http://www.springerlink.com/openurl.asp? genre=article&issn=0006-3835&volume=23&issue=4&spage=538. DOI 10.1007/BF01933626. {623} [BB87a] Adam W. Bojanczyk and Richard P. Brent. A systolic algorithm for extended GCD computation. Computers and Mathematics with Applications, 14(4):233–238, 1987. CODEN CMAPDK. ISSN 0898-1221 (print), 1873-7668 (electronic). DOI 10.1016/0898-1221(87) 90130-1. {186} 998 Bibliography

[BB87b] Jonathan M. Borwein and Peter B. Borwein. Pi and the AGM: a Study in Analytic Number Theory and Computational Complexity. Canadian Mathematical Society series of monographs and advanced texts = Monographies et études de la Société mathématique du Canada. Wiley, New York, NY, USA, 1987. ISBN 0-471-83138-7, 0-471-31515-X (paperback); 978-0-471-83138-9, 978-0-471-31515-5 (paperback). xv + 414 pp. LCCN QA241 .B774 1987. {623} [BB97] Gerrit A. Blaauw and Frederick P. Brooks, Jr. Computer Architecture: Concepts and Evolution. Addison-Wesley, Reading, MA, USA, 1997. ISBN 0-201-10557-8; 978-0-201-10557-5. xlviii + 1213 pp. LCCN QA76.9.A73 B57 1997. {104, 947, 978} [BB00] Nelson H. F. Beebe and James S. Ball. Algorithm xxx: Quadruple-precision Γ(x) and ψ(x) functions for real arguments. Technical report, Departments of Mathematics and Physics, University of Utah, Salt Lake City, UT 84112, USA, 2000. {521, 525} [BB04] Jonathan M. Borwein and David H. Bailey. Mathematics by Experiment: Plausible Reasoning in the 21st Century. A. K. Peters, Wellesley, MA, USA, 2004. ISBN 1-56881-211-6; 978-1-56881-211-3. x + 288 pp. LCCN QA76.95 .B67 2003. Due to an unfortunate error, some of the citations in the book point to the wrong item in the Bibliography. Here is how to find the correct citation number: [1]–[85]: Citation number is correct; [86, page 100]: [86]; [86, page 2]: [87]; [87]–[156]: Add one to citation number; [157]: [159]; [158, page 139]: [158]; [158, page 97]: [160]; [159]–[196]: Add two to citation number. {268, 622, 624, 631, 632} [BBB59] Frederick P. Brooks, Jr., Gerrit A. Blaauw, and Werner Buchholz. Processing data in bits and pieces. IRE Transactions on Electronic Computers, EC-8(2):118–124, June 1959. CODEN IRELAO. ISSN 0367-9950. URL http://ieeexplore.ieee.org/stamp/stamp.jsp? tp=&arnumber=5219512. DOI 10.1109/TEC.1959.5219512. This paper contains on page 121 the first published reference to the term “byte”. An article of the same title appears in “Information Processing, Proceedings of the International Conference on Information Processing, UNESCO, Paris, 15–20 June 1959”, pp. 375–381, 1959. From [Buc62, page 40]: “Byte denotes a group of bits used to encode a character, or the number of bits transmitted in parallel to and from input-output units. A term other than character is used here because a given character may be represented in different applications by more than one code, and different codes may use different numbers of bits (i.e., different byte sizes). In input-output transmission the grouping of bits may be completely arbitrary and have no relation to actual characters. (The term is coined from bite, but respelled to avoid accidental mutation to bit.)”. {969} [BBB00] Lennart Berggren, Jonathan M. Borwein, and Peter B. Borwein, editors. Pi, a Sourcebook. Springer-Verlag, Berlin, Germany / Heidel- berg, Germany / London, UK / etc., second edition, 2000. ISBN 0-387-98946-3 (hardcover); 978-0-387-98946-4 (hardcover). xix + 736 pp. LCCN QA484 .P5 2000. {14, 59, 623} [BBBP97] David H. Bailey, Jonathan M. Borwein, Peter B. Borwein, and Simon Plouffe. The quest for pi. The Math- ematical Intelligencer, 19(1):50–57, January 1997. CODEN MAINDC. ISSN 0343-6993 (print), 1866-7414 (electronic). URL http://crd.lbl.gov/~dhbailey/dhbpapers/pi-quest.pdf; http://docserver.carma.newcastle.edu.au/164/; http:// link.springer.com/article/10.1007%2FBF03024340. DOI 10.1007/BF03024340. {622, 623} [BBC+07] David H. Bailey, Jonathan M. Borwein, Neil J. Calkin, Roland Girgensohn, D. Russell Luke, and Victor Moll. Experimental Mathematics in Action. A. K. Peters, Wellesley, MA, USA, 2007. ISBN 1-56881-271-X; 978-1-56881-271-7. xii + 322 pp. LCCN QA8.7 .E97 2007. {631} [BBG03] Jonathan M. Borwein, David H. Bailey, and Roland Girgensohn. Experimentation in Mathematics: Computational Paths to Discovery.A. K. Peters, Wellesley, MA, USA, 2003. ISBN 1-56881-136-5; 978-1-56881-136-9. x + 357 pp. LCCN QA12 .B67 2004. {631} [BC09] Franky Backeljauw and Annie Cuyt. Algorithm 895: A continued fractions package for special functions. ACM Transactions on Mathematical Software, 36(3):15:1–15:20, July 2009. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/ 1527286.1527289. {776, 827} [BCD+14] G. Ballard, E. Carson, J. Demmel, M. Hoemmen, N. Knight, and O. Schwartz. Communication lower bounds and optimal algorithms for numerical linear algebra. Acta Numerica, 23:1–155, 2014. CODEN ANUMFU. ISSN 0962-4929 (print), 1474-0508 (electronic). DOI 10.1017/S0962492914000038. {385} [BCDH09] Javier D. Bruguera, Marius Cornea, Debjit DasSarma, and John Harrison, editors. Proceedings of the 19th IEEE Symposium on Computer Arithmetic, June 8–10, 2009, Portland, Oregon, USA. IEEE Computer Society Press, Silver Spring, MD, USA, 2009. ISBN 0-7695-3670-0; 978-0-7695-3670-5. ISSN 1063-6889. LCCN QA76.6. URL http://www.ac.usc.es/arith19/. {1014} [BD76] Carter Bays and S. D. Durham. Improving a poor random number generator. ACM Transactions on Mathematical Software, 2(1):59–64, March 1976. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/355666.355670. See also [LL73] for a slightly different, but inferior, shuffling algorithm, and [Bay90] for a comparison, both mathematical, and graphical, of the two algorithms. Reference [3] for IBM Report GC20-8011-0 is incorrectly given year 1969; the correct year is 1959. {178, 997, 1022} [BD96] Robert G. Burger and R. Kent Dybvig. Printing floating-point numbers quickly and accurately. ACM SIGPLAN Notices, 31(5):108–116, May 1996. CODEN SINODQ. ISSN 0362-1340 (print), 1523-2867 (print), 1558-1160 (electronic). URL http://www.acm.org:80/pubs/ citations/proceedings/pldi/231379/p108-burger/. DOI 10.1145/231379.231397. This paper offers a significantly faster algorithm than that of [SW90], together with a correctness proof and an implementation in Scheme. See also [Cli90, ABC+99, SW04, Cli04]. {895, 995, 1004, 1034} [BD03a] Sylvie Boldo and Marc Daumas. Representable correcting terms for possibly underflowing floating point operations. In Bajard and Schulte [BS03], pages 79–86. ISBN 0-7695-1894-X; 978-0-7695-1894-7. ISSN 1063-6889. LCCN QA76.6 .S919 2003. URL http:// www.dec.usc.es/arith16/papers/paper-156.pdf. DOI 10.1109/ARITH.2003.1207663. {366, 1002} [BD03b] Sylvie Boldo and Marc Daumas. A simple test qualifying the accuracy of Horner’s rule for polynomials. Research Report 2003-01, École Normale Supérieure de Lyon, 69364 Lyon Cedex 07, France, January 2003. 41 pp. URL ftp://ftp.inria.fr/INRIA/publication/ publi-pdf/RR/RR-4707.pdf. {89} [BD04] Sylvie Boldo and Marc Daumas. A simple test qualifying the accuracy of Horner’s rule for polynomials. Numerical Algorithms, 37(1–4): 45–60, December 2004. CODEN NUALEG. ISSN 1017-1398 (print), 1572-9265 (electronic). URL http://link.springer.com/article/ 10.1023/B%3ANUMA.0000049487.98618.61. DOI 10.1023/B:NUMA.0000049487.98618.61. SCAN2002 International Conference (Guest Editors: Rene Alt and Jean-Luc Lamotte). {89} Bibliography 999

[BD09] Jonathan M. Borwein and Keith J. Devlin. The Computer as Crucible: an Introduction to Experimental Mathematics. A. K. Peters, Wellesley, MA, USA, 2009. ISBN 1-56881-343-0; 978-1-56881-343-1. xi + 158 pp. LCCN QA8.7 .B67 2009. {631} [BDS07] Robert E. Bradley, Lawrence A. D’Antonio, and Charles Edward Sandifer, editors. Euler at 300: an Appreciation, volume 5 of The MAA tercentenary Euler celebration; Spectrum series. Mathematical Association of America, Washington, DC, USA, 2007. ISBN 0-88385-565-8; 978-0-88385-565-2. xvi + 298 pp. LCCN QA29.E8 E95 2007. {591} [BE92] Lee J. Bain and Max Engelhardt. Introduction to Probability and Mathematical Statistics. The Duxbury advanced series in statistics and decision sciences. PWS-Kent Publishers, Boston, MA, USA, second edition, 1992. ISBN 0-534-92930-3, 0-534-98563-7 (international student edition); 978-0-534-92930-5, 978-0-534-98563-9 (international student edition). xii + 644 pp. LCCN QA273 .B2546 1991. {196} [Bec73] Petr Beckmann. Orthogonal Polynomials for Engineers and Physicists. Golem Press, Boulder, CO, USA, 1973. ISBN 0-911762-14-0; 978-0- 911762-14-3. 280 pp. LCCN QA404.5 .B35. {59} [Bec93] Petr Beckmann. A History of π [pi]. Barnes and Noble, New York, NY, USA, 1993. ISBN 0-88029-418-3; 978-0-88029-418-8. 200 pp. LCCN QA484 .B4 1971. Reprint of the third edition of 1971. {14, 59, 623} [Bee94] Nelson H. F. Beebe. The impact of memory and architecture on computer performance. Technical report, Department of Mathematics, University of Utah, Salt Lake City, UT, USA, February 23, 1994. viii + 62 pp. URL http://www.math.utah.edu/~beebe/memperf.pdf. Supplemental class notes prepared for Mathematics 118 and 119. {952} METAFONT [Bee04a] Nelson H. F. Beebe. 25 years of TEX and : Looking back and looking forward: TUG 2003 keynote address. TUGboat, 25(1): 7–30, 2004. ISSN 0896-3207. URL http://www.math.utah.edu/~beebe/talks/tug2003/; http://www.tug.org/TUGboat/tb25-1/ beebe-2003keynote.pdf. {954} [Bee04b] Nelson H. F. Beebe. Java programming: Fun with Fibonacci. World-Wide Web document, March 2004. URL http:// www.math.utah.edu/~beebe/software/java/fibonacci/. This report summarizes the origin of the Fibonacci sequence, giving the full Latin text from the original book written in 1202 (not previously available on the Web). Computation of the Fibonacci sequence, and its term ratios, is implemented in about 50 different programming languages. The report comments on the relative difficulty of the task in some of those languages, and on their suitability for numerical computation. It also provides a complete floating-point formatted output package for Java. {15, 73, 978} METAFONT [Bee05] Nelson H. F. Beebe. Keynote address: The design of TEX and : A retrospective. TUGboat, 26(1):33–51, 2005. ISSN 0896- 3207. URL http://www.tug.org/TUGboat/tb26-1/beebe.pdf. Proceedings of the Practical TeX 2005 conference, Chapel Hill, NC, June 14–17, 2005. {954} [BEJ76] J. M. Blair, C. A. Edwards, and J. H. Johnson. Rational Chebyshev approximations for the inverse of the error function. Mathematics of Computation, 30(136):827–830, October 1976. CODEN MCMPAF. ISSN 0025-5718 (print), 1088-6842 (electronic). URL http:// www.jstor.org/stable/2005402. DOI 10.2307/2005402. {600} [Bel37] Eric Temple Bell. Men of mathematics: The Lives and Achievements of the Great Mathematicians from Zeno to Poincaré. Simon and Schuster, New York, NY, USA, 1937. ISBN 0-671-62818-6; 978-0-671-62818-5. xxi + 592 pp. LCCN QA28 .B4. {59} [Bel68] W. W. (William Wallace) Bell. Special Functions for Scientists and Engineers. Van Nostrand, London, UK, 1968. xiv + 247 pp. LCCN QA351 .B4. {827} [Bel04] W. W. (William Wallace) Bell. Special Functions for Scientists and Engineers. Dover books on mathematics. Dover, New York, NY, USA, 2004. ISBN 0-486-43521-0; 978-0-486-43521-3. xiv + 247 pp. LCCN QA351 .B4 2004. {827} [Ber68] A. Bergson. Certification of and remark on Algorithm 304 [S15]: Normal curve integral. Communications of the Association for Computing Machinery, 11(4):271, April 1968. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). DOI 10.1145/362991.363048. See [HJ67a, HJ67b]. {618, 1015} [BF71] Paul F. Byrd and Morris D. Friedman. Handbook of Elliptic Integrals for Engineers and Scientists, volume 67 of Die Grundlehren der mathematischen Wissenschaften in Einzeldarstellungen. Springer-Verlag, Berlin, Germany / Heidelberg, Germany / London, UK / etc., second edition, 1971. ISBN 0-387-05318-2 (New York); 978-0-387-05318-9 (New York). xvi + 358 pp. LCCN QA343 .B95 1971. DOI 10.1007/978-3-642-65138-0. {58, 619, 630, 659, 664, 666, 682, 683, 686} [BFN94] Paul Bratley, Bennett L. Fox, and Harald Niederreiter. Algorithm 738: Programs to generate Niederreiter’s low-discrepancy sequences. ACM Transactions on Mathematical Software, 20(4):494–495, December 1994. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). URL http://www.acm.org/pubs/citations/journals/toms/1994-20-4/p494-bratley/. DOI 10.1145/198429.198436. {203} [BFSG74] A. R. Barnett, D. H. Feng, J. W. Steed, and L. J. B. Goldfarb. Coulomb wave functions for all real η [eta] and ρ [rho]. Computer Physics Communications, 8(5):377–395, December 1974. CODEN CPHCBZ. ISSN 0010-4655 (print), 1879-2944 (electronic). DOI 10.1016/ 0010-4655(74)90013-7. {17} [BGA90] Walter S. Brainerd, Charles H. Goldberg, and Jeanne C. Adams. Programmer’s Guide to Fortran 90. McGraw-Hill, New York, NY, USA, 1990. ISBN 0-07-000248-7; 978-0-07-000248-7. vii + 410 pp. LCCN QA76.73.F25 B735 1990. {106} [BGM96] George A. Baker, Jr. and Peter Graves-Morris. Padé Approximants, volume 59 of Encyclopedia of Mathematics and its Applications. Cam- bridge University Press, Cambridge, UK, second edition, 1996. ISBN 0-521-45007-1 (hardcover); 978-0-521-45007-2 (hardcover). xiv + 746 pp. LCCN QC20.7.P3 B35 1996. {589} [BGVHN99] Adhemar Bultheel, Pablo Gonzales-Vera, Erik Hendriksen, and Olav Njastad, editors. Orthogonal Rational Functions, volume 5 of Cambridge Monographs on Applied and Computational Mathematics. Cambridge University Press, Cambridge, UK, 1999. ISBN 0-521- 65006-2 (hardcover); 978-0-521-65006-9 (hardcover). xiv + 407 pp. LCCN QA404.5 .O75 1999. {59} 1000 Bibliography

[BH07] Nicolas Brisebarre and Guillaume Hanrot. Floating-point L2-approximations to functions. In Kornerup and Muller [KM07], pages 177–186. ISBN 0-7695-2854-6; 978-0-7695-2854-0. ISSN 1063-6889. LCCN QA76.9.C62. URL http://www.lirmm.fr/arith18/. DOI 10.1109/ARITH.2007.38. {42, 89} [BHK+84] D. E. Bodenstab, Thomas F. Houghton, Keith A. Kelleman, George Ronkin, and Edward P. Schan. UNIX operating system porting experiences. AT&T Bell Laboratories Technical Journal, 63(8 part 2):1769–1790, October 1984. CODEN ABLJER. ISSN 0748-612X (print), 2376-7162 (electronic). DOI 10.1002/j.1538-7305.1984.tb00064.x. {74, 972} [BHY80] Richard P. Brent, Judith A. Hooper, and J. Michael Yohe. An AUGMENT interface for Brent’s multiple precision arithmetic package. ACM Transactions on Mathematical Software, 6(2):146–149, June 1980. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/355887.355889. See [Bre78b, Bre79, Smi98]. {1001, 1032} [BK15] David Biancolin and Jack Koenig. Hardware accelerator for exact dot product. Report, ASPIRE Laboratory, University of California, Berkeley, Berkeley, CA, USA, June 19, 2015. {385} [BKMM07] J. Baik, T. Kriecherbauer, K. T.-R. McLaughlin, and P. D. Miller, editors. Discrete Orthogonal Polynomials: Asymptotics and Applications, volume 164 of Annals of mathematics studies. Princeton University Press, Princeton, NJ, USA, 2007. ISBN 0-691-12733-6 (hardcover), 0-691-12734-4 (paperback); 978-0-691-12733-0 (hardcover), 978-0-691-12734-7 (paperback). vi + 170 pp. LCCN QA404.5 .D57 2007. URL http://press.princeton.edu/titles/8450.html. {59} [Bla64] G. Blanch. Numerical evaluation of continued fractions. SIAM Review, 6(4):383–421, October 1964. CODEN SIREAD. ISSN 0036-1445 (print), 1095-7200 (electronic). DOI 10.1137/1006092. {13} [Bla97] David Blatner. The Joy of π [pi]. Walker and Co., New York, NY, USA, 1997. ISBN 0-8027-1332-7 (hardcover), 0-8027-7562- 4 (paperback); 978-0-8027-1332-2 (hardcover), 978-0-8027-7562-7 (paperback). xiii + 129 pp. LCCN QA484 .B55 1997. URL http://www.walkerbooks.com/books/catalog.php?key=4. {14, 59, 623} [Blu78] James L. Blue. A portable Fortran program to ﬁnd the Euclidean norm of a vector. ACM Transactions on Mathematical Software, 4(1): 15–23, March 1978. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/355769.355771. {223} [BM58] G. E. P. Box and Mervin E. Muller. A note on the generation of random normal deviates. Annals of Mathematical Statistics, 29(2): 610–611, June 1958. CODEN AASTAD. ISSN 0003-4851. URL http://projecteuclid.org/euclid.aoms/1177706645; http:// www.jstor.org/stable/2237361. DOI 10.1214/aoms/1177706645. {193} [BM04] Sylvie Boldo and Guillaume Melquiond. When double rounding is odd. Research Report RR2004-48, École Normale Supérieure de Lyon, 69364 Lyon Cedex 07, France, November 2004. 2 + 7 pp. URL http://www.ens-lyon.fr/LIP/Pub/Rapports/RR/RR2004/ RR2004-48.pdf. {403} [BM05] Sylvie Boldo and Jean-Michel Muller. Some functions computable with a fused-mac. In Montuschi and Schwarz [MS05], pages 52–58. ISBN 0-7695-2366-8; 978-0-7695-2366-8. LCCN QA76.9.C62 .S95 2005. URL http://arith17.polito.it/final/paper-106.pdf. DOI 10.1109/ARITH.2005.39. {397, 406} [BM08] Sylvie Boldo and Guillaume Melquiond. Emulation of a FMA and correctly rounded sums: Proved algorithms using rounding to odd. IEEE Transactions on Computers, 57(4):462–471, April 2008. CODEN ITCOB4. ISSN 0018-9340 (print), 1557-9956 (electronic). DOI 10.1109/TC.2007.70819. {403} [BM11] Sylvie Boldo and Jean-Michel Muller. Exact and approximated error of the FMA. IEEE Transactions on Computers, 60(2):157–164, February 2011. CODEN ITCOB4. ISSN 0018-9340 (print), 1557-9956 (electronic). DOI 10.1109/TC.2010.139. {397, 403, 406} [BMM78] C. Gordon Bell, J. Craig Mudge, and John E. McNamara, editors. Computer Engineering: A DEC View of Hardware Systems Design. Digital Press, Bedford, MA, USA, 1978. ISBN 0-932376-00-2; 978-0-932376-00-8. xxii + 585 pp. LCCN TK7885 .C64. URL http:// www.bitsavers.org/pdf/dec/Bell-ComputerEngineering.pdf. {954} [BMY07] N. N. Bogolyubov, G. K. Mikha˘ılov, and A. P. Yushkevich, editors. Euler and Modern Science, volume 4 of MAA tercentenary Euler celebration: Spectrum series. Mathematical Association of America, Washington, DC, USA, English edition, 2007. ISBN 0-88385-564-X; 978-0-88385-564-5. xiv + 425 pp. LCCN Q143.E84 R3913 2007. Translated by Robert Burns from the 1988 Russian original, Razvitie ide˘ı Leonarda Eulera i sovremennaya nauka. {591} [Bol09] Sylvie Boldo. Kahan’s algorithm for a correct discriminant computation at last formally proven. IEEE Transactions on Computers, 58(2): 220–225, February 2009. CODEN ITCOB4. ISSN 0018-9340 (print), 1557-9956 (electronic). DOI 10.1109/TC.2008.200. See [Kah04b] for the original algorithm. {472, 1018} [Boy89] Joan Boyar. Inferring sequences produced by pseudo-random number generators. Journal of the Association for Computing Machinery, 36(1):129–141, January 1989. CODEN JACOAH. ISSN 0004-5411 (print), 1557-735x (electronic). DOI 10.1145/58562.59305. {207} [BPZ07] Richard P. Brent, Colin Percival, and Paul Zimmermann. Error bounds on complex ﬂoating-point multiplication. Mathemat- ics of Computation, 76(259):1469–1481, July 2007. CODEN MCMPAF. ISSN 0025-5718 (print), 1088-6842 (electronic). URL http://www.ams.org/mcom/2007-76-259/S0025-5718-07-01931-X/. DOI 10.1090/S0025-5718-07-01931-X. {458, 476} [BR91] Claude Brezinski and Michela Redivo Zaglia. Extrapolation Methods: Theory and Practice, volume 2 of Studies in Computational Mathe- matics. North-Holland, Amsterdam, The Netherlands, 1991. ISBN 0-444-88814-4; 978-0-444-88814-3. ix + 464 pp. LCCN QA281 .B74 1991. {589} [Bre76a] Richard P. Brent. Analysis of the binary Euclidean algorithm. In J. F. Traub, editor, Algorithms and Complexity: Recent Results and New Directions: [Proceedings of a Symposium on New Directions and Recent Results in Algorithms and Complexity held by the Computer Science Department, Carnegie-Mellon University, April 7–9, 1976], pages 321–355. Academic Press, New York, NY, USA, 1976. ISBN 0-12-697540- X; 978-0-12-697540-6. LCCN QA76.6 .S9195 1976. URL http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.122.7959. The complexity of the binary Euclidean algorithm for the greatest common denominator is shown to be O(0.705 lg N) for large N = max(|u|, |v|). See [Bre00] for an update, and a repair to an incorrect conjecture in this paper. See also [Bre99], where the worst case complexity is shown to be O(lg N), and the number of right shifts at most 2 lg(N). {184, 1001} Bibliography 1001

[Bre76b] Richard P. Brent. Fast multiple-precision evaluation of elementary functions. Journal of the Association for Computing Machinery, 23(2): 242–251, April 1976. CODEN JACOAH. ISSN 0004-5411 (print), 1557-735x (electronic). DOI 10.1145/321941.321944. {623} [Bre78a] Richard P. Brent. A Fortran multiple-precision arithmetic package. ACM Transactions on Mathematical Software, 4(1):57–70, March 1978. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/355769.355775. {28} [Bre78b] Richard P.Brent. Algorithm 524: MP, A Fortran multiple-precision arithmetic package [A1]. ACM Transactions on Mathematical Software, 4(1):71–81, March 1978. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/355769.355776. See also [Bre79, BHY80, Smi98]. {28, 1000, 1001, 1032} [Bre79] Richard P. Brent. Remark on “Algorithm 524: MP, A Fortran multiple-precision arithmetic package [A1]”. ACM Transactions on Mathematical Software, 5(4):518–519, December 1979. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/ 355853.355868. See [Bre78b, BHY80, Smi98]. {1000, 1001, 1032} [Bre91] Claude Brezinski. History of Continued Fractions and Padé Approximants, volume 12 of Springer series in computational mathematics. Springer-Verlag, Berlin, Germany / Heidelberg, Germany / London, UK / etc., 1991. ISBN 3-540-15286-5 (Berlin), 0-387-15286-5 (New York); 978-3-540-15286-6 (Berlin), 978-0-387-15286-8 (New York). 551 pp. LCCN QA295 .B79 1990. DOI 10.1007/978-3-642-58169-4. {19, 59} [Bre99] Richard P. Brent. Further analysis of the binary Euclidean algorithm. Technical Report TR-7-99, Programming Research Group, Oxford University, Oxford, UK, November 4, 1999. 18 pp. URL http://arxiv.org/pdf/1303.2772.pdf. See also earlier work [Bre76a]. {184, 1000} [Bre00] Richard P. Brent. Twenty years’ analysis of the binary Euclidean algorithm. In Jim Davies, A. W. Roscoe, and Jim Woodcock, editors, Millennial perspectives in computer science: proceedings of the 1999 Oxford–Microsoft Symposium in honour of Professor Sir Antony Hoare, pages 41–52. Palgrave, Basingstoke, UK, 2000. ISBN 0-333-92230-1; 978-0-333-92230-9. LCCN QA75.5 .O8 2000. URL http://www.cs.ox.ac.uk/people/richard.brent/pd/rpb183pr.pdf. {184, 1000} [Bre04] Richard P. Brent. Note on Marsaglia’s xorshift random number generators. Journal of Statistical Software, 11(5):1–5, 2004. CODEN JSSOBK. ISSN 1548-7660. URL http://www.jstatsoft.org/counter.php?id=101&url=v11/i05/v11i05.pdf&ct=1. DOI 10.18637/ jss.v011.i05. See [Mar03b, PL05, Vig16]. This article shows the equivalence of xorshift generators and the well-understood linear feedback shift register generators. {1024, 1028} [Bro73] R. Broucke. ACM Algorithm 446: Ten subroutines for the manipulation of Chebyshev series [C1]. Communications of the Association for Computing Machinery, 16(4):254–256, April 1973. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). DOI 10.1145/ 362003.362037. See remark and certiﬁcation [PM75]. {48, 1028} [Bro82] Frederick P. Brooks, Jr. The Mythical Man-Month — Essays on Software Engineering. Addison-Wesley, Reading, MA, USA, 1982. ISBN 0-201-00650-2; 978-0-201-00650-6. xi + 195 pp. LCCN QA 76.6 B75 1982. {963} [Bro95] Frederick P. Brooks, Jr. The Mythical Man-Month — Essays on Software Engineering. Addison-Wesley, Reading, MA, USA, anniversary edition, 1995. ISBN 0-201-83595-9; 978-0-201-83595-3. xiii + 322 pp. LCCN QA76.758 .B75 1995. {963} [Bry08] Yury Aleksandrovich Brychkov. Handbook of Special Functions: Derivatives, Integrals, Series and other Formulas. CRC Press, Boca Raton, FL, USA, 2008. ISBN 1-58488-956-X; 978-1-58488-956-4. xix + 680 pp. LCCN QA351 .B79 2008. {58, 521, 556, 827} [BS77] J. D. Beasley and S. G. Springer. Statistical algorithms: Algorithm AS 111: The percentage points of the normal distribution. Applied Statistics, 26(1):118–121, March 1977. CODEN APSTAG. ISSN 0035-9254 (print), 1467-9876 (electronic). URL http://lib.stat.cmu.edu/apstat/111. DOI 10.2307/2346889. {618} [BS80] Jon Louis Bentley and James B. Saxe. Generating sorted lists of random numbers. ACM Transactions on Mathematical Software, 6(3): 359–364, September 1980. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/355900.355907. {168} [BS92] Ronald F. Boisvert and Bonita V. Saunders. Portable vectorized software for Bessel function evaluation. ACM Transactions on Mathematical Software, 18(4):456–469, December 1992. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). URL http://www.acm.org/pubs/citations/journals/toms/1992-18-4/p456-boisvert/. DOI 10.1145/138351.138370. See correction [BS93]. {693, 823, 1001} [BS93] Ronald F. Boisvert and Bonita V. Saunders. Corrigendum: “Algorithm 713: Portable vectorized software for Bessel function evaluation”. ACM Transactions on Mathematical Software, 19(1):131, March 1993. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). See [BS92]. {823, 1001} [BS03] Jean Claude Bajard and Michael J. Schulte, editors. 16th IEEE Symposium on Computer Arithmetic: ARITH-16 2003: proceedings: Santiago de Compostela, Spain, June 15–18, 2003. IEEE Computer Society Press, Silver Spring, MD, USA, 2003. ISBN 0-7695-1894-X; 978-0-7695- 1894-7. ISSN 1063-6889. LCCN QA76.6 .S919 2003. URL http://www.dec.usc.es/arith16/. {998, 1005, 1032} [BS07] Robert E. Bradley and Charles Edward Sandifer, editors. Leonhard Euler: Life, Work, and Legacy, volume 5 of Studies in the History and Philosophy of Mathematics. Elsevier, Amsterdam, The Netherlands, 2007. ISBN 0-444-52728-1; 978-0-444-52728-8. viii + 534 pp. LCCN QA29.E8 L465 2007. URL http://www.sciencedirect.com/science/book/9780444527288. {591} [BS12] Michael Baudin and Robert L. Smith. A robust complex division in Scilab. CoRR, abs/1210.4539, 2012. URL http://arxiv.org/abs/ 1210.4539. {463} [BSI03a] The C Standard: Incorporating Technical Corrigendum 1. Wiley, New York, NY, USA, 2003. ISBN 0-470-84573-2; 978-0-470-84573-8. 538 pp. LCCN QA76.73.C15C185 2003. BS ISO/IEC 9899:1999. {4} [BSI03b] The C++ Standard: Incorporating Technical Corrigendum 1: BS ISO. Wiley, New York, NY, USA, second edition, 2003. ISBN 0-470-84674-7; 978-0-470-84674-2. xxxiv + 782 pp. LCCN QA76.73.C153C16 2003. {vii} 1002 Bibliography

[Buc62] Werner Buchholz, editor. Planning a computer system: Project Stretch. McGraw-Hill, New York, NY, USA, 1962. xvii + 322 pp. LCCN 1876. URL http://ed-thelen.org/comp-hist/IBM-7030-Planning-McJones.pdf. This important book is the primary description of the influential IBM 7030 Stretch computer, written by its architects. {959, 998} [Bur07] David M. Burton. The History of Mathematics: An Introduction. McGraw-Hill, New York, NY, USA, sixth edition, 2007. ISBN 0-07- 305189-6; 978-0-07-305189-5. xii + 788 pp. LCCN QA21 .B96 2007. {59} [BW10] Richard Beals and R. (Roderick) Wong. Special Functions: a Graduate Text, volume 126 of Cambridge studies in advanced mathematics. Cambridge University Press, Cambridge, UK, 2010. ISBN 0-521-19797-X; 978-0-521-19797-7. ix + 456 pp. LCCN QA351 .B34 2010; QA351 BEA 2010. {827} [BWKM91] Gerd Bohlender, W. Walter, Peter Kornerup, and David W. Matula. Semantics for exact floating point operations. In Ko- rnerup and Matula [KM91], pages 22–26. ISBN 0-8186-9151-4 (case), 0-8186-6151-8 (microfiche), 0-7803-0187-0 (library binding); 978-0-8186-9151-5 (case), 978-0-8186-6151-8 (microfiche), 978-0-7803-0187-0 (library binding). LCCN QA76.9.C62 S95 1991. DOI 10.1109/ARITH.1991.145529. See [BD03a] for some special cases that this paper may have overlooked. {366} [BZ11] Richard P. Brent and Paul Zimmermann. Modern Computer Arithmetic, volume 18 of Cambridge monographs on applied and computational mathematics. Cambridge University Press, Cambridge, UK, 2011. ISBN 0-521-19469-5 (hardcover); 978-0-521-19469-3 (hardcover). xvi + 221 pp. LCCN QA76.9.C62 BRE 2011. URL http://www.loria.fr/~zimmerma/mca/pub226.html. {104, 407, 574, 978} [C90] ISO/IEC 9899:1990: Programming languages — C. International Organization for Standardization, Geneva, Switzerland, 1990. URL http://www.iso.ch/cate/d17782.html. {vii, 1, 4, 827} [C++98] ISO/IEC 14882:1998: Programming languages — C++. International Organization for Standardization, Geneva, Switzerland, Septem- ber 1, 1998. 732 pp. URL http://www.iso.ch/cate/d25845.html. Available in electronic form for online purchase at http://webstore.ansi.org/ and http://www.cssinfo.com/. {vii, 1, 57, 106} [C99] ISO/IEC 9899:1999: Programming Languages — C. International Organization for Standardization, Geneva, Switzerland, De- cember 16, 1999. 538 pp. URL http://anubis.dkuug.dk/JTC1/SC22/open/n2620/n2620.pdf; http://anubis.dkuug.dk/ JTC1/SC22/WG14/www/docs/n897.pdf; http://webstore.ansi.org/ansidocstore/product.asp?sku=ISO%2FIEC+9899%3A1999; http://www.iso.ch/cate/d29237.html. Available in electronic form for online purchase at http://webstore.ansi.org/ and http://www.cssinfo.com/. {vii, 1, 4, 106, 441, 449, 455, 456, 460, 482, 490, 496, 507, 513, 514, 518, 525, 534} [C++03a] ISO/IEC 14882:2003: Programming languages — C++. International Organization for Standardization, Geneva, Switzerland, 2003. 757 pp. URL http://www.iso.org/iso/en/CatalogueDetailPage.CatalogueDetail?CSNUMBER=38110. {vii, 1, 57, 106} [C#03b] ISO/IEC 23270:2003: Information technology — C# Language Specification. International Organization for Standardization, Geneva, Switzerland, 2003. xiii + 471 pp. URL http://standards.iso.org/ittf/PubliclyAvailableStandards/c036768_ISO_IEC_23270_ 2003(E).zip. {80, 917} [C#06a] ISO/IEC 23270:2006: Information technology — Programming languages — C#. Technical report. International Organization for Stan- dardization, Geneva, Switzerland, 2006. URL http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm? csnumber=42926. {vii, 917} [C06b] ISO/IEC JTC1 SC22 WG14 N1154: Extension for the programming language C to support decimal floating-point arithmetic. World- Wide Web document, February 27, 2006. URL http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1154.pdf. {875, 928} [C06c] ISO/IEC JTC1 SC22 WG14 N1161: Rationale for TR 24732: Extension to the programming language C: Decimal floating-point arithmetic. World-Wide Web document, February 27, 2006. URL http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1161.pdf. {875, 928} [C06d] ISO/IEC JTC1 SC22 WG14 N1176: Extension for the programming language C to support decimal floating-point arithmetic. World- Wide Web document, May 24, 2006. URL http://open-std.org/jtc1/sc22/wg14/www/docs/n1176.pdf. {875, 928} [C09] ISO/IEC TR 24732:2009 Information technology — Programming languages, their environments and system software interfaces — Extension for the programming language C to support decimal floating-point arithmetic. Technical report. International Organization for Standardization, Geneva, Switzerland, 2009. URL http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=38842. {928} [C++10] ISO/IEC 29124:2010: Information technology — Programming languages, their environments and system software interfaces — Extensions to the C++ Library to support mathematical special functions. Technical report. International Organization for Standardization, Geneva, Switzerland, 2010. URL http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=50511. {57} [C++11a] ISO/IEC 14882:2011 Information technology — Programming languages — C++. International Organization for Standardization, Geneva, Switzerland, third edition, September 1, 2011. URL http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm? csnumber=50372. {vii, 1} [C11b] ISO/IEC 9899:2011 Information technology — Programming languages — C. International Organization for Standardization, Geneva, Switzerland, December 8, 2011. 683 (est.) pp. URL http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm? csnumber=57853. {vii, 1} [C++14] ISO/IEC 14882:2014 Information technology — Programming languages — C++. International Organization for Standardization, Geneva, Switzerland, fourth edition, December 15, 2014. URL http://www.iso.org/iso/home/store/catalogue_ics/catalogue_detail_ ics.htm?csnumber=64029. {1} [CAH+07] Marius Cornea, Cristina Anderson, John Harrison, Ping Tak Peter Tang, Eric Schneider, and Charles Tsen. A software implementation of the IEEE 754R decimal floating-point arithmetic using the binary encoding format. In Kornerup and Muller [KM07], pages 29–37. ISBN 0-7695-2854-6; 978-0-7695-2854-0. ISSN 1063-6889. LCCN QA76.9.C62. URL http://www.lirmm.fr/arith18/papers/CorneaM_ Decimal_ARITH18.pdf. DOI 10.1109/ARITH.2007.7. {928} Bibliography 1003

[Cai11] Liang-Wu Cai. On the computation of spherical Bessel functions of complex arguments. Computer Physics Communications, 182(3):663– 668, March 2011. CODEN CPHCBZ. ISSN 0010-4655 (print), 1879-2944 (electronic). URL http://www.sciencedirect.com/science/ article/pii/S0010465510004650. DOI 10.1016/j.cpc.2010.11.019. {693} [Caj91] Florian Cajori. A History of Mathematics. Chelsea Publishing Company, New York, NY, USA, fifth edition, 1991. ISBN 0-8284-2303-6; 978-0-8284-2303-8. xi + 524 pp. LCCN QA21 .C15 1991. {59} [Cal95] Ronald Calinger, editor. Classics of Mathematics. Prentice-Hall, Upper Saddle River, NJ, USA, 1995. ISBN 0-02-318342-X; 978-0-02- 318342-3. xxi + 793 pp. LCCN QA21 .C55 1995. {7} [Cam80] J. B. Campbell. On Temme’s algorithm for the modified Bessel function of the third kind. ACM Transactions on Mathematical Software, 6(4):581–586, December 1980. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/355921.355928. {693} [Car63] L. Carlitz. The inverse of the error function. Pacific Journal of Mathematics, 13(2):459–470, 1963. CODEN PJMAAI. ISSN 0030-8730 (print), 1945-5844 (electronic). URL http://projecteuclid.org/euclid.pjm/1103035736. {600} [Car70] Bille Chandler Carlson. Hidden symmetries of special functions. SIAM Review, 12(3):332–345, July 1970. CODEN SIREAD. ISSN 0036-1445 (print), 1095-7200 (electronic). URL http://www.jstor.org/stable/2028552. DOI 10.1137/1012078. {646} [Car71] Bille Chandler Carlson. Algorithms involving arithmetic and geometric means. American Mathematical Monthly, 78(5):496–505, May 1971. CODEN AMMYAE. ISSN 0002-9890 (print), 1930-0972 (electronic). URL http://www.jstor.org/stable/2317754. DOI 10.2307/ 2317754. {623} [Car77] Bille Chandler Carlson. Special Functions of Applied Mathematics. Academic Press, New York, NY, USA, 1977. ISBN 0-12-160150-1; 978-0-12-160150-8. xv + 335 pp. LCCN QA351 .C32. {644–646, 653, 682, 827} [Car79] Bille Chandler Carlson. Computing elliptic integrals by duplication. Numerische Mathematik, 33(1):1–16, March 1979. CODEN NUMMA7. ISSN 0029-599X (print), 0945-3245 (electronic). DOI 10.1007/BF01396491. {646, 649, 651} [Car95] Bille Chandler Carlson. Numerical computation of real or complex elliptic integrals. Numerical Algorithms, 10(1–2):13–26, July 1995. CODEN NUALEG. ISSN 1017-1398 (print), 1572-9265 (electronic). DOI 10.1007/BF02198293. Special functions (Torino, 1993). {646, 648} [Cat03] Don Catlin. The Lottery Book: The Truth behind the Numbers. Bonus Books, Chicago, IL, USA, 2003. ISBN 1-56625-193-1; 978-1-56625- 193-8. xvii + 181 pp. LCCN HG6126 .C38 2003. This book describes US lotteries, and how their odds and payouts are determined. {297} [CBB+99] Jean-Luc Chabert, E. Barbin, Jacques Borowczyk, Michel Guillemot, Anne Michel-Pajus, Ahmed Djebbar, and Jean-Claude Martzloff, editors. Histoire d’Algorithmes. A History of Algorithms: from the Pebble to the Microchip. Springer-Verlag, Berlin, Germany / Heidelberg, Germany / London, UK / etc., 1999. ISBN 3-540-63369-3 (softcover); 978-3-540-63369-3 (softcover). ix + 524 pp. LCCN QA58 .H5813 1998. DOI 10.1007/978-3-642-18192-4. Translated by Chris Weeks from the 1994 French original, Histoire d’algorithmes. Du caillou à la puce. {59} [CBGK13] Mathew A. Cleveland, Thomas A. Brunner, Nicholas A. Gentile, and Jeffrey A. Keasler. Obtaining identical results with double precision global accuracy on different numbers of processors in parallel particle Monte Carlo simulations. Journal of Com- putational Physics, 251:223–236, October 15, 2013. CODEN JCTPAH. ISSN 0021-9991 (print), 1090-2716 (electronic). URL http://www.sciencedirect.com/science/article/pii/S0021999113004075. DOI 10.1016/j.jcp.2013.05.041. {385} [CCG+84] William J. Cody, Jr., Jerome T. Coonen, David M. Gay, K. Hanson, David G. Hough, William M. Kahan, Richard Karpinski, John F. Palmer, Frederic N. Ris, and David Stevenson. A proposed radix- and word-length-independent standard for floating-point arithmetic. IEEE Micro, 4(4):86–100, August 1984. CODEN IEMIDZ. ISSN 0272-1732 (print), 1937-4143 (electronic). DOI 10.1109/MM.1984.291224. {104, 152} [CDGI15] Sylvain Collange, David Defour, Stef Graillat, and Roman Iakymchuk. Numerical reproducibility for the parallel reduction on multi- and many-core architectures. Parallel Computing, 49:83–97, November 2015. CODEN PACOEJ. ISSN 0167-8191 (print), 1872-7336 (electronic). URL http://www.sciencedirect.com/science/article/pii/S0167819115001155. DOI 10.1016/j.parco.2015.09.001. {385} [CGL90] R. Coquereaux, A. Grossmann, and B. E. Lautrup. Iterative method for calculation of the Weierstrass elliptic function. IMA Journal of Numerical Analysis, 10(1):119–128, January 1990. CODEN IJNADH. ISSN 0272-4979 (print), 1464-3642 (electronic). DOI 10.1093/ imanum/10.1.119. {689} [CH67] William J. Cody, Jr. and K. E. Hillstrom. Chebyshev approximations for the natural logarithm of the gamma function. Math- ematics of Computation, 21(98):198–203, April 1967. CODEN MCMPAF. ISSN 0025-5718 (print), 1088-6842 (electronic). URL http://www.jstor.org/stable/2004160. DOI 10.2307/2004160. {521} [CH75] Tien Chi Chen and Irving T. Ho. Storage-efficient representation of decimal data. Communications of the Association for Com- puting Machinery, 18(1):49–52, January 1975. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). URL http:// www2.hursley.ibm.com/decimal/chen-ho.html. DOI 10.1145/360569.360660. Collection of articles honoring Alston S. Householder. See comment [Smi75]. {928, 1032} [Che98] Russell C. H. Cheng. Random variate generation. In Banks [Ban98], pages 138–172. ISBN 0-471-13403-1 (hardcover); 978-0-471-13403-9 (hardcover). LCCN T57.62 .H37 1998. DOI 10.1002/9780470172445.ch5. {196} [Chi78] Theodore Seio Chihara. An Introduction to Orthogonal Polynomials, volume 13 of Mathematics and its applications. Gordon and Breach, New York, NY, USA, 1978. ISBN 0-677-04150-0; 978-0-677-04150-6. xii + 249 pp. LCCN QA404.5 .C44. {59} [CHT02] Marius Cornea, John Harrison, and Ping Tak Peter Tang. Scientific computing on Itanium-based systems. Intel Corporation, Santa Clara, CA, USA, 2002. ISBN 0-9712887-7-1; 978-0-9712887-7-5. xvii + 406 pp. LCCN QA76.8.I83 C67 2002. URL http://www.intel.com/ intelpress/sum_scientific.htm. {299} 1004 Bibliography

[CJW06] James A. Carlson, Arthur Jaffe, and Andrew Wiles, editors. The Millennium Prize Problems. American Mathematical Society, Providence, RI, USA, 2006. ISBN 0-8218-3679-X; 978-0-8218-3679-8. viii + 165 pp. LCCN QA43 .M493 2006. URL http://www.claymath.org/ publications/Millennium_Problems/. {60, 303, 521, 579, 590} [CKCFR03] Martin Campbell-Kelly, Mary Croarken, Raymond Flood, and Eleanor Robson, editors. The History of Mathematical Tables: From Sumer to Spreadsheets. Oxford University Press, Oxford, UK, 2003. ISBN 0-19-850841-7; 978-0-19-850841-0. viii + 361 pp. LCCN QA47 .H57 2003. {59} [CKP+79] Jerome T. Coonen, William M. Kahan, John F. Palmer, Tom Pittman, and David Stevenson. A proposed standard for binary floating point arithmetic: Draft 5.11. ACM SIGNUM Newsletter, 14(3S):4–12, October 1979. CODEN SNEWD6. ISSN 0163-5778 (print), 1558- 0237 (electronic). DOI 10.1145/1057520.1057521. {104} [CKT07] Kalyan Chakraborty, Shigeru Kanemitsu, and Haruo Tsukada. Vistas of Special Functions II. World Scientific Publishing, Singapore, 2007. ISBN 981-270-774-3; 978-981-270-774-1. xii + 215 pp. LCCN QA351 .K35 2007. {827} [Clay09] Clay Mathematics Institute. Web site., 2009. URL http://www.claymath.org/. This institute sponsors research in advanced mathematics, and offers large monetary prizes for solutions of selected famous unsolved problems in mathematics. {303, 521, 579, 590} [Cle03] Brian Clegg. A Brief History of Infinity: The Quest to Think the Unthinkable. Constable and Robinson, London, UK, 2003. ISBN 1-84119- 650-9; 978-1-84119-650-3. 255 pp. LCCN BD411. {59} [Cli90] William D. Clinger. How to read floating point numbers accurately. ACM SIGPLAN Notices, 25(6):92–101, June 1990. CODEN SINODQ. ISBN 0-89791-364-7; 978-0-89791-364-5. ISSN 0362-1340 (print), 1523-2867 (print), 1558-1160 (electronic). URL http:// www.acm.org:80/pubs/citations/proceedings/pldi/93542/p92-clinger/. DOI 10.1145/93548.93557. See also output algorithms in [Knu90, SW90, BD96, ABC+99, SW04] and retrospective [Cli04]. {895, 896, 995, 998, 1004, 1020, 1034} [CLI03] ISO/IEC 23271:2003: Information technology — Common Language Infrastructure. International Organization for Standardiza- tion, Geneva, Switzerland, 2003. xi + 99 (Part I), ix + 164 (Part II), vi + 125 (Part III), iii + 16 (Part IV), iv + 79 (Part V) pp. URL http://standards.iso.org/ittf/PubliclyAvailableStandards/c036769_ISO_IEC_23271_2003(E).zip; http:// www.iso.org/iso/en/CatalogueDetailPage.CatalogueDetail?CSNUMBER=36769. {917} [Cli04] William D. Clinger. Retrospective: How to read floating point numbers accurately. ACM SIGPLAN Notices, 39(4):360–371, April 2004. CODEN SINODQ. ISSN 0362-1340 (print), 1523-2867 (print), 1558-1160 (electronic). DOI 10.1145/989393.989430. Best of PLDI 1979–1999. Reprint of, and retrospective on, [Cli90]. {895, 998, 1004, 1020, 1034} [CLI05] ISO/IEC TR 23272: Information technology — Common Language Infrastructure — Profiles and Libraries. International Organization for Standardization, Geneva, Switzerland, 2005. 6 pp. URL http://standards.iso.org/ittf/PubliclyAvailableStandards/c036770_ ISO_IEC_TR_23272_2003(E).zip. {vii, 80, 917} [CLI06] ISO/IEC 23271:2006: Information technology: Common Language Infrastructure (CLI) Partitions I to VI. International standard. International Organization for Standardization, Geneva, Switzerland, second edition, 2006. {vii, 917} [CLK99] Patrick Chan, Rosanna Lee, and Doug Kramer. The Java Class Libraries: java.io, java.lang, java.math, java.net, java.text, java.util, volume 1. Addison-Wesley, Reading, MA, USA, second edition, 1999. ISBN 0-201-31002-3; 978-0-201-31002-3. xxvi + 2050 pp. LCCN QA76.73.J38 C47 1998. {vii} [CMF77] William J. Cody, Jr., Rose M. Motley, and L. Wayne Fullerton. The computation of real fractional order Bessel functions of the second kind. ACM Transactions on Mathematical Software, 3(3):232–239, September 1977. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/355744.355747. {693} [CN81] Bille Chandler Carlson and Elaine M. Notis. Algorithm 577: Algorithms for incomplete elliptic integrals [S21]. ACM Transactions on Mathematical Software, 7(3):398–403, September 1981. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). URL http://www.netlib.org/toms/577. DOI 10.1145/355958.355970. {646, 648, 650} [COB02] ISO/IEC 1989:2002: Information technology — Programming languages — COBOL. International Organization for Standardization, Geneva, Switzerland, 2002. 859 pp. URL http://www.iso.org/iso/en/CatalogueDetailPage.CatalogueDetail?CSNUMBER=28805. {928} [Cod64] William J. Cody, Jr. Double-precision square root for the CDC-3600. Communications of the Association for Computing Machinery, 7(12): 715–718, December 1964. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). DOI 10.1145/355588.365122. {949} [Cod65a] William J. Cody, Jr. Chebyshev approximations for the complete elliptic integrals K and E. Mathematics of Computation, 19(89–92):105– 112, April 1965. CODEN MCMPAF. ISSN 0025-5718 (print), 1088-6842 (electronic). URL http://www.jstor.org/stable/2004103. DOI 10.2307/2004103. See corrigenda [Cod66]. {644, 1004} [Cod65b] William J. Cody, Jr. Chebyshev polynomial expansions of complete elliptic integrals. Mathematics of Computation, 19(89–92):249–259, April 1965. CODEN MCMPAF. ISSN 0025-5718 (print), 1088-6842 (electronic). URL http://www.jstor.org/stable/2003350. DOI 10.2307/2003350. {644} [Cod66] William J. Cody, Jr. Corrigenda: “Chebyshev approximations for the complete elliptic integrals K and E”. Mathematics of Computation, 20(93):207, January 1966. CODEN MCMPAF. ISSN 0025-5718 (print), 1088-6842 (electronic). URL http://www.jstor.org/stable/ 2004329. DOI 10.2307/2004329. See [Cod65a]. {1004} [Cod69] William J. Cody, Jr. Rational Chebyshev approximations for the error function. Mathematics of Computation, 23(107):631–637, July 1969. CODEN MCMPAF. ISSN 0025-5718 (print), 1088-6842 (electronic). URL http://www.jstor.org/stable/2004390. DOI 10.2307/ 2004390. {593} [Cod80] William J. Cody, Jr. Preliminary report on software for modified Bessel functions of the first kind. Technical Memo AMD TM-357, Argonne National Laboratory, Argonne, IL, USA, 1980. {693} Bibliography 1005

[Cod81] William J. Cody, Jr. Analysis of proposals for the floating-point standard. Computer, 14(3):63–69, March 1981. CODEN CPTRB4. ISSN 0018-9162 (print), 1558-0814 (electronic). URL http://ieeexplore.ieee.org/document/1667286/. DOI 10.1109/C-M.1981.220379. See [IEEE85a]. {63, 1016} [Cod83] William J. Cody, Jr. Algorithm 597: Sequence of modified Bessel functions of the first kind. ACM Transactions on Mathematical Software, 9(2):242–245, June 1983. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/357456.357462. {693} [Cod88a] William J. Cody, Jr. Performance evaluation of programs for the error and complementary error functions. Mathematics and Computer Science Preprint MCS-P13-0988, Argonne National Laboratory, Argonne, IL, USA, September 1988. Published in [Cod90]. {593} [Cod88b] William J. Cody, Jr. Performance evaluation of programs related to the real gamma function. Mathematics and Computer Science Preprint MCS-P12-0988, Argonne National Laboratory, Argonne, IL, USA, September 1988. Published in [Cod91]. {521, 1005} [Cod90] William J. Cody, Jr. Performance evaluation of programs for the error and complementary error functions. ACM Transactions on Mathematical Software, 16(1):29–37, March 1990. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). URL http:// www.acm.org/pubs/toc/Abstracts/0098-3500/77628.html. DOI 10.1145/77626.77628. {593, 1005} [Cod91] William J. Cody, Jr. Performance evaluation of programs related to the real gamma function. ACM Transactions on Mathematical Software, 17(1):46–54, March 1991. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). URL http://www.acm.org/ pubs/toc/Abstracts/0098-3500/103153.html. DOI 10.1145/103147.103153. Preprint in [Cod88b]. {521, 525, 1005} [Cod93a] William J. Cody, Jr. Algorithm 714: CELEFUNT: A portable test package for complex elementary functions. ACM Transactions on Mathematical Software, 19(1):1–21, March 1993. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/ 151271.151272. {476} [Cod93b] William J. Cody, Jr. Algorithm 715: SPECFUN: A portable FORTRAN package of special function routines and test drivers. ACM Transactions on Mathematical Software, 19(1):22–32, March 1993. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). URL http://www.acm.org/pubs/toc/Abstracts/0098-3500/151273.html. DOI 10.1145/151271.151273. {521, 525, 593, 693} [Coh81] Danny Cohen. On Holy Wars and a plea for peace. Computer, 14(10):48–54, October 1981. CODEN CPTRB4. ISSN 0018-9162 (print), 1558-0814 (electronic). DOI 10.1109/C-M.1981.220208. This is an entertaining account of the Big-Endian and Little-Endian problems of bit and byte ordering. {956, 963} [Con67] Control Data Corporation, St. Paul, MN, USA. Control Data 6400/6500/6600 Computer Systems Reference Manual, 1967. vi + 153 pp. URL http://www.bitsavers.org/pdf/cdc/6x00/60100000D_6600refMan_Feb67.pdf. {949} [Con71] Control Data Corporation, St. Paul, MN, USA. Control Data 7600 Computer Systems Reference Manual, February 1971. v + 194 pp. URL http://www.bitsavers.org/pdf/cdc/7600/60258200C_7600_RefMan_Feb71.pdf. {949} [Coo80] Jerome T. Coonen. An implementation guide to a proposed standard for floating-point arithmetic. Computer, 13(1):68–79, January 1980. CODEN CPTRB4. ISSN 0018-9162 (print), 1558-0814 (electronic). DOI 10.1109/MC.1980.1653344. See [IEEE85a], and errata in [Coo81a]. {63, 104, 1005, 1016} [Coo81a] Jerome T. Coonen. Errata: An implementation guide to a proposed standard for floating point arithmetic. Computer, 14(3):62, March 1981. CODEN CPTRB4. ISSN 0018-9162 (print), 1558-0814 (electronic). DOI 10.1109/C-M.1981.220378. See [Coo80, IEEE85a]. {63, 1005, 1016} [Coo81b] Jerome T. Coonen. Underflow and the denormalized numbers. Computer, 14(3):75–87, March 1981. CODEN CPTRB4. ISSN 0018- 9162 (print), 1558-0814 (electronic). URL http://ieeexplore.ieee.org/document/1667289/. DOI 10.1109/C-M.1981.220382. See [IEEE85a]. {63, 79, 104, 1016} [Coo84] Jerome T. Coonen. Contributions to a Proposed Standard for Binary Floating-Point Arithmetic. Thesis (Ph.D. in mathematics), Department of Mathematics, University of California at Berkeley, Berkeley, CA, USA, December 18, 1984. 320 pp. {856} [Cow84] Wayne R. Cowell, editor. Sources and Development of Mathematical Software. Prentice-Hall Series in Computational Mathematics, Cleve Moler, Advisor. Prentice-Hall, Upper Saddle River, NJ, USA, 1984. ISBN 0-13-823501-5; 978-0-13-823501-7. xii + 404 pp. LCCN QA76.95 .S68 1984. {823, 826} [Cow85] Michael F. Cowlishaw. The REXX Language: a Practical Approach to Programming. Prentice-Hall, Upper Saddle River, NJ, USA, 1985. ISBN 0-13-780735-X (paperback); 978-0-13-780735-2 (paperback). xi + 176 pp. LCCN QA76.73.R24 C69 1985. {viii, 928, 968} [Cow90] Michael F. Cowlishaw. The REXX Language: a Practical Approach to Programming. Prentice-Hall, Upper Saddle River, NJ, USA, second edition, 1990. ISBN 0-13-780651-5; 978-0-13-780651-5. xii + 203 pp. LCCN QA76.73.R24 C69 1990. URL http://vig.prenhall.com/ catalog/academic/product/0,1144,0137806515,00.html. {viii, 928, 968} [Cow97] Michael F. Cowlishaw. The NetRexx Language. Prentice-Hall, Upper Saddle River, NJ, USA, 1997. ISBN 0-13-806332-X; 978-0-13-806332- 0. viii + 197 pp. LCCN QA76.73.N47 C68 1997. See also supplement [Cow00]. {viii, 928, 968, 1005} [Cow00] Michael F. Cowlishaw. NetRexx Language Supplement. IBM UK Laboratories, Hursley Park, Winchester, England, August 23, 2000. iii + 45 pp. URL http://www-306.ibm.com/software/awdtools/netrexx/nrlsupp.pdf. Version 2.00. This document is a supplement to [Cow97]. {968, 1005} [Cow02] Michael F. Cowlishaw. Densely packed decimal encoding. IEE Proceedings. Computers and Digital Techniques, 149(3):102–104, 2002. CODEN ICDTEA. ISSN 1350-2387 (print), 1359-7027 (electronic). DOI 10.1049/ip-cdt:20020407. {928} [Cow03] Michael F. Cowlishaw. Decimal floating-point: algorism for computers. In Bajard and Schulte [BS03], pages 104–111. ISBN 0-7695- 1894-X; 978-0-7695-1894-7. ISSN 1063-6889. LCCN QA76.6 .S919 2003. URL http://www.dec.usc.es/arith16/papers/paper-107.pdf. DOI 10.1109/ARITH.2003.1207666. {927} [Cow05] Michael F. Cowlishaw. General decimal arithmetic specification. Report Version 1.50, IBM UK Laboratories, Hursley, UK, December 9, 2005. iii + 63 pp. URL http://www2.hursley.ibm.com/decimal/decarith.pdf. {109} 1006 Bibliography

[Cow07] Michael F. Cowlishaw. The decNumber C library. IBM Corporation, San Jose, CA, USA, April 18, 2007. URL http:// download.icu-project.org/ex/files/decNumber/decNumber-icu-340.zip. Version 3.40. {387, 433, 897, 928} [CPV+08] Annie Cuyt, Vigdis B. Petersen, Brigitte Verdonk, Haakon Waadeland, and William B. Jones. Handbook of Continued Fractions for Special Functions. Springer-Verlag, Berlin, Germany / Heidelberg, Germany / London, UK / etc., 2008. ISBN 1-4020-6948-0; 978-1-4020-6948- 2. xx + 440 pp. LCCN QA295 .H275 2008. DOI 10.1007/978-1-4020-6949-9. {19, 58, 776, 827} [Cray75] Cray Research, Inc., Mendota Heights, MN, USA. The Cray 1 Computer Preliminary Reference Manual, June 1975. vi + 75 pp. URL http://www.bitsavers.org/pdf/cray/CRAY-1_PrelimRefRevA_Jun75.pdf. {949} [Cray77] Cray Research, Inc., Minneapolis, MN, USA. CRAY-1 Hardware Reference Manual, November 4, 1977. URL http://www.bitsavers.org/ pdf/cray/2240004C-1977-Cray1.pdf. Publication number 2240004, revision C. {953} [Cray82] Cray Research, Inc., Mendota Heights, MN, USA. Cray X-MP Computer Systems Mainframe Reference Manual, November 1982. x + 206 pp. URL http://www.bitsavers.org/pdf/cray/HR-0032_X-MP_MainframeRef_Nov82.pdf. {949, 953} [CS89] William J. Cody, Jr. and L. Stoltz. Performance evaluation of programs for certain Bessel functions. ACM Transactions on Mathematical Software, 15(1):41–48, March 1989. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). URL http://www.acm.org/pubs/ toc/Abstracts/0098-3500/62039.html. DOI 10.1145/62038.62039. Also published as Technical Report MCS-P14-0988, Argonne National Laboratory, Argonne, IL, USA. {693, 769} [CS91] William J. Cody, Jr. and L. Stoltz. The use of Taylor series to test accuracy of function programs. ACM Transactions on Mathematical Software, 17(1):55–63, March 1991. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). URL http://www.acm.org/ pubs/toc/Abstracts/0098-3500/103154.html. DOI 10.1145/103147.103154. {521, 593, 693, 769} [CST73] William J. Cody, Jr., Anthony J. Strecok, and Henry C. Thacher, Jr. Chebyshev approximations for the psi function. Mathe- matics of Computation, 27(21):123–127, January 1973. CODEN MCMPAF. ISSN 0025-5718 (print), 1088-6842 (electronic). URL http://www.jstor.org/stable/2005253. DOI 10.2307/2005253. {521} [CT65] James W. Cooley and John W. Tukey. An algorithm for the machine calculation of complex Fourier series. Mathematics of Computation, 19(90):297–301, April 1965. CODEN MCMPAF. ISSN 0025-5718 (print), 1088-6842 (electronic). URL http://www.jstor.org/stable/ 2003354. DOI 10.2307/2003354. {969} [CVZ00] Henri Cohen, Fernando Rodriguez Villegas, and Don Zagier. Convergence acceleration of alternating series. Experimental Mathematics, 9(1):3–12, 2000. ISSN 1058-6458 (print), 1944-950x (electronic). URL http://projecteuclid.org/euclid.em/1046889587; http:// www.math.u-bordeaux.fr/~cohen/sumalt2new.ps. DOI 10.1080/10586458.2000.10504632. {589} [CW80] William J. Cody, Jr. and William Waite. Software Manual for the Elementary Functions. Prentice-Hall, Upper Saddle River, NJ, USA, 1980. ISBN 0-13-822064-6; 978-0-13-822064-8. x + 269 pp. LCCN QA331 .C635 1980. {viii, 1, 270, 344, 411, 763, 823, 939} [CW08] D. Cavagnino and A. E. Werbrouck. Efficient algorithms for integer division by constants using multiplication. The Computer Journal, 51(4):470–480, July 2008. CODEN CMPJA6. ISSN 0010-4620 (print), 1460-2067 (electronic). URL http://comjnl.oxfordjournals.org/cgi/content/abstract/51/4/470; http://comjnl.oxfordjournals.org/cgi/content/ full/51/4/470; http://comjnl.oxfordjournals.org/cgi/reprint/51/4/470. DOI 10.1093/comjnl/bxm082. {176} [CW11] D. Cavagnino and A. E. Werbrouck. An analysis of associated dividends in the DBM algorithm for division by constants using multiplication. The Computer Journal, 54(1):148–156, January 2011. CODEN CMPJA6. ISSN 0010-4620 (print), 1460-2067 (electronic). URL http://comjnl.oxfordjournals.org/content/54/1/148.full.pdf+html. DOI 10.1093/comjnl/bxp117. [DBM = Division by Multiplication]. {176} [Cyv64] S. J. Cyvin. Algorithm 226: Normal distribution function. Communications of the Association for Computing Machinery, 7(5):295, May 1964. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). DOI 10.1145/364099.364315. See remarks [HJ67b]. {618, 1015} [dDDL04] Florent de Dinechin, David Defour, and Christoph Lauter. Fast correct rounding of elementary functions in double precision using double-extended arithmetic. Research Report RR2004-10, École Normale Supérieure de Lyon, 69364 Lyon Cedex 07, France, March 2004. 2 + 12 pp. URL http://www.ens-lyon.fr/LIP/Pub/Rapports/RR/RR2004/RR2004-10.pdf. {28} [dDG04] Florent de Dinechin and Nicolas Gast. Towards the post-ultimate libm. Research Report RR2004-47, École Normale Supérieure de Lyon, 69364 Lyon Cedex 07, France, November 2004. URL http://www.ens-lyon.fr/LIP/Pub/Rapports/RR/RR2004/RR2004-47.pdf. {28} [DDZ+07] A. Y. Duale, M. H. Decker, H.-G. Zipperer, M. Aharoni, and T. J. Bohizic. Decimal floating-point in z9: An implementation and testing perspective. IBM Journal of Research and Development, 51(1/2):217–227, January /March 2007. CODEN IBMJAE. ISSN 0018-8646 (print), 2151-8556 (electronic). URL http://www.research.ibm.com/journal/rd/511/duale.html. DOI 10.1147/rd.511.0217. {927} [DEC76] Digital Equipment Corporation, Maynard, MA, USA. DECsystem-10/20 Hardware Manual, fourth edition, November 1976. Publication DEC-10-XSRMA-A-D. Also co-published with the FAIL Assembly Language Manual as Stanford Artificial Intelligence Laboratory Operating Note 75 and LOTS Computer Facility Operating Note 2. {848, 955} [DEC77] Digital Equipment Corporation, Maynard, MA, USA. Digital VAX 11/780 Architecture Handbook, 1977. x + 324 pp. URL http:// www.bitsavers.org/pdf/dec/vax/VAX_archHbkVol1_1977.pdf. {956} [DEC79] Digital Equipment Corporation, Maynard, MA, USA. Digital VAX 11/780 Hardware Handbook, 1979. x + 324 pp. URL http:// www.bitsavers.org/pdf/dec/vax/VAX_archHbkVol1_1977.pdf. {956} [DEC82] Digital Equipment Corporation, Maynard, MA, USA. VAX-11 Architecture Reference Manual, May 20, 1982. URL http:// www.bitsavers.org/pdf/dec/vax/archSpec/EL-00032-00-decStd32_Jan90.pdf. Revision 6.1. {956} Bibliography 1007

[DEC90] Digital Equipment Corporation, Bedford, MA, USA. DEC STD 032 VAX Architecture Standard, January 15, 1990. vi + 486 pp. URL http://www.bitsavers.org/pdf/dec/vax/archSpec/EL-00032-00-decStd32_Jan90.pdf. {956} [Dek71] Theodorus J. Dekker. A floating-point technique for extending the available precision. Numerische Mathematik, 18(3):224–242, June 1971. CODEN NUMMA7. ISSN 0029-599X (print), 0945-3245 (electronic). URL http://www-gdz.sub.uni-goettingen.de/cgi-bin/ digbib.cgi?PPN362160546_0018. DOI 10.1007/BF01397083. {353, 361, 365, 379} [Dem81] James Demmel. Effects of underflow on solving linear systems. In Proceedings: 5th Symposium on Computer Arithmetic, May 18–19, 1981, University of Michigan, Ann Arbor, Michigan, pages 113–119. IEEE Computer Society Press, Silver Spring, MD, USA, 1981. LCCN QA 76.6 S985t 1981. URL http://www.acsel-lab.com/arithmetic/arith5/papers/ARITH5_Demmel.pdf. IEEE catalog number 81CH1630- C. {79} [Den05] Lih-Yuan Deng. Efficient and portable multiple recursive generators of large order. ACM Transactions on Modeling and Computer Sim- ulation, 15(1):1–13, January 2005. CODEN ATMCEZ. ISSN 1049-3301 (print), 1558-1195 (electronic). DOI 10.1145/1044322.1044323. {1023} [Der03] John Derbyshire. Prime Obsession: Bernhard Riemann and the Greatest Unsolved Problem in Mathematics. Joseph Henry Press, Washington, DC, USA, 2003. ISBN 0-309-08549-7; 978-0-309-08549-6. xv + 422 pp. LCCN QA246 .D47 2003. {59, 60, 303, 521, 579, 590} [Dev86] Luc Devroye. Non-Uniform Random Variate Generation. Springer-Verlag, Berlin, Germany / Heidelberg, Germany / London, UK / etc., 1986. ISBN 0-387-96305-7; 978-0-387-96305-1. xvi + 843 pp. LCCN QA274 .D48 1986. DOI 10.1007/978-1-4613-8643-8. {196} [Dev02] Keith J. Devlin. The Millennium Problems: the Seven Greatest Unsolved Mathematical Puzzles of our Time. Basic Books, New York, NY, USA, 2002. ISBN 0-465-01729-0; 978-0-465-01729-4. x + 237 pp. LCCN QA93 .D485 2002. {303, 521} [Dev08a] Keith J. Devlin. The Unfinished Game: Pascal, Fermat, and the Seventeenth-Century Letter that Made the World Modern: a Tale of How Mathematics is Really Done. Basic ideas. Basic Books, New York, NY, USA, 2008. ISBN 0-465-00910-7; 978-0-465-00910-7. x + 191 pp. LCCN QA273 .D455 2008. {60} [Dev08b] Jay L. Devore. Probability and Statistics for Engineering and the Sciences. Thomson/Brooks/Cole, Belmont, CA, USA, seventh edition, 2008. ISBN 0-495-38217-5; 978-0-495-38217-1. xvi + 720 pp. LCCN QA273 .D46 2008. {196, 610} [Dev11] Keith J. Devlin. The man of numbers: Fibonacci’s arithmetic revolution. Walker and Company, New York, NY, USA, 2011. ISBN 0-8027- 7812-7 (hardcover); 978-0-8027-7812-3 (hardcover). viii + 183+8pp.{15, 59} [DGD04] Guy Waldo Dunnington, Jeremy Gray, and Fritz-Egbert Dohse. Carl Friedrich Gauss: titan of science. Mathematical Association of America, Washington, DC, USA, 2004. ISBN 0-88385-547-X; 978-0-88385-547-8. xxix + 537 + 16 pp. LCCN QA29.G3 D8 2004. {59} [DH97a] Iosif G. Dyadkin and Kenneth G. Hamilton. A family of enhanced Lehmer random number generators, with hyperplane suppression, and direct support for certain physical applications. Computer Physics Communications, 107(1–3):258–280, December 22, 1997. CODEN CPHCBZ. ISSN 0010-4655 (print), 1879-2944 (electronic). DOI 10.1016/S0010-4655(97)00101-X. {170, 189} [DH97b] Iosif G. Dyadkin and Kenneth G. Hamilton. A study of 64-bit multipliers for Lehmer pseudorandom number generators. Computer Physics Communications, 103(2–3):103–130, July 1997. CODEN CPHCBZ. ISSN 0010-4655 (print), 1879-2944 (electronic). URL http:// www.sciencedirect.com/science/article/pii/S0010465597000520. DOI 10.1016/S0010-4655(97)00052-0. {170} [DH00] Iosif G. Dyadkin and Kenneth G. Hamilton. A study of 128-bit multipliers for congruential pseudorandom number generators. Computer Physics Communications, 125(1–3):239–258, March 2000. CODEN CPHCBZ. ISSN 0010-4655 (print), 1879-2944 (electronic). URL http://cpc.cs.qub.ac.uk/summaries/ADLK; http://www.elsevier.com/gej-ng//10/15/40/55/25/ 42/abstract.html; http://www.sciencedirect.com/science/article/pii/S0010465599004671. DOI 10.1016/S0010-4655(99) 00467-1. {170} [DH04] James Demmel and Yozo Hida. Fast and accurate floating point summation with application to computational geometry. Numer- ical Algorithms, 37(1–4):101–112, December 2004. CODEN NUALEG. ISSN 1017-1398 (print), 1572-9265 (electronic). URL http: //ipsapp009.kluweronline.com/IPS/content/ext/x/J/5058/I/58/A/6/abstract.htm. DOI 10.1023/B:NUMA.0000049458.99541.38. {385} [Dij68] Edsger W. Dijkstra. Letter to the Editor: Go to statement considered harmful. Communications of the Association for Computing Machinery, 11(3):147–148, March 1968. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). DOI 10.1145/362929.362947. This letter in support of structured programming, and in favor of eliminating control-flow disruption caused by go to statements, inspired scores of others, published mainly in SIGPLAN Notices up to the mid-1980s. The best-known is [Knu74]. {962, 1020} [DKKM87] Cipher A. Deavours, David Kahn, Louis Kruh, and Greg Mellen, editors. Cryptology Yesterday, Today, and Tomorrow. The Artech House communication and electronic defense library. Artech House Inc., Norwood, MA, USA, 1987. ISBN 0-89006-253-6; 978-0-89006-253-1. xi + 519 pp. LCCN Z103.C76 1987. First volume of selected papers from issues of Cryptologia. {1029} [DL42a] Gordon C. Danielson and Cornelius Lanczos. Some improvements in practical Fourier analysis and their application to X-ray scat- tering from liquids. Journal of The Franklin Institute, 233(4):365–380, April 1942. CODEN JFINAB. ISSN 0016-0032 (print), 1879-2693 (electronic). DOI 10.1016/S0016-0032(42)90767-1. {969} [DL42b] Gordon C. Danielson and Cornelius Lanczos. Some improvements in practical Fourier analysis and their application to X-ray scat- tering from liquids. Journal of The Franklin Institute, 233(5):435–452, May 1942. CODEN JFINAB. ISSN 0016-0032 (print), 1879-2693 (electronic). DOI 10.1016/S0016-0032(42)90624-0. {969} [DLS09] Lih-Yuan Deng, Huajiang Li, and Jyh-Jen Horng Shiau. Scalable parallel multiple recursive generators of large order. Parallel Comput- ing, 35(1):29–37, January 2009. CODEN PACOEJ. ISSN 0167-8191 (print), 1872-7336 (electronic). URL http://www.sciencedirect.com/ science/article/pii/S0167819108001099. DOI 10.1016/j.parco.2008.09.012. {1023} 1008 Bibliography

[Dom03] Diego Dominici. Nested derivatives: a simple method for computing series expansions of inverse functions. International Jour- nal of Mathematics and Mathematical Sciences, 58:3699–3715, 2003. ISSN 0161-1712 (print), 1687-0425 (electronic). URL http:// www.hindawi.com/journals/ijmms/2003/457271/abs/. DOI 10.1155/S0161171203303291. {600} [Don06] Aleksander Donev. Interoperability with C in Fortran 2003. ACM Fortran Forum, 25(1):8–12, April 2006. ISSN 1061-7264 (print), 1931-1311 (electronic). DOI 10.1145/1124708.1124710. {941} [DR84] Philip J. Davis and Philip Rabinowitz. Methods of Numerical Integration. Academic Press, New York, NY, USA, second edition, 1984. ISBN 0-12-206360-0; 978-0-12-206360-2. xiv + 612 pp. LCCN QA299.3 .D28 1984. {560} [dRHG+99] Theo de Raadt, Niklas Hallqvist, Artur Grabowski, Angelos D. Keromytis, and Niels Provos. Cryptography in OpenBSD: An overview. In USENIX, editor, Usenix Annual Technical Conference. June 6–11, 1999. Monterey, California, USA, pages 93–101. USENIX, Berkeley, CA, USA, 1999. ISBN 1-880446-33-2; 978-1-880446-33-1. LCCN A76.8.U65 U843 1999. URL http://www.openbsd.org/ papers/crypt-paper.ps. {207} [dS03] Marcus du Sautoy. The Music of the Primes: Searching to Solve the Greatest Mystery in Mathematics. HarperCollins College Publishers, New York, NY, USA, 2003. ISBN 0-06-621070-4; 978-0-06-621070-4. 335 pp. LCCN QA246 .D8 2003. {60, 303, 521} [DSC12] Jean-Pierre Deschamps, Gustavo D. Sutter, and Enrique Cantó. Guide to FPGA implementation of arithmetic functions, volume 95 of Lecture Notes in Electrical Engineering. Springer-Verlag, Berlin, Germany / Heidelberg, Germany / London, UK / etc., 2012. ISBN 94-007-2986-3 (hardcover), 94-007-2987-1 (e-book); 978-94-007-2986-5 (hardcover), 978-94-007-2987-2 (e-book). xv + 469 pp. LCCN TK7895.G36. DOI 10.1007/978-94-007-2987-2. {978} [DSL12a] Lih-Yuan Deng, Jyh-Jen H. Shiau, and Henry Horng-Shing Lu. Efficient computer search of large-order multiple recursive pseudorandom number generators. Journal of Computational and Applied Mathematics, 236(13):3228–3237, July 2012. CODEN JCAMDI. ISSN 0377-0427 (print), 1879-1778 (electronic). DOI 10.1016/j.cam.2012.02.023. {176, 1023} [DSL12b] Lih-Yuan Deng, Jyh-Jen Horng Shiau, and Henry Horng-Shing Lu. Large-order multiple recursive generators with modulus 231 − 1. INFORMS Journal on Computing, 24(4):636–647, Fall 2012. ISSN 1091-9856 (print), 1526-5528 (electronic). URL http://joc.journal.informs.org/content/24/4/636. DOI 10.1287/ijoc.1110.0477. {1023} [Dub83] Augustin A. Dubrulle. Class of numerical methods for the computation of Pythagorean sums. IBM Journal of Research and Development, 27(6):582–589, November 1983. CODEN IBMJAE. ISSN 0018-8646 (print), 2151-8556 (electronic). DOI 10.1147/rd.276.0582. See [MM83] and generalization [Jam89]. {228, 1017, 1024} [Dun55] Guy Waldo Dunnington. Carl Friedrich Gauss, titan of science: a study of his life and work. Exposition-university book. Exposition Press, New York, NY, USA, 1955. xi + 479 pp. LCCN QA29.G38 D85 1955. {59} [Dun91] William Dunham. Journey through Genius: The Great Theorems of Mathematics. Penguin, New York, NY, USA, 1991. ISBN 0-14-014739-X; 978-0-14-014739-1. xiii + 300 pp. {541, 591} [Dun92] Charles B. Dunham. Surveyor’s Forum: “What every computer scientist should know about floating-point arithmetic”. ACM Comput- ing Surveys, 24(3):319, September 1992. CODEN CMSVAN. ISSN 0360-0300 (print), 1557-7341 (electronic). See [Gol91a, Gol91b, Wic92]. {1013, 1037} [Dun99] William Dunham. Euler: The Master of Us All, volume 22 of The Dolciani mathematical expositions. Mathematical Association of America, Washington, DC, USA, 1999. ISBN 0-88385-328-0; 978-0-88385-328-3. xxviii + 185 pp. LCCN QA29.E8 D86 1999. {59, 591} [Dun07] William Dunham, editor. The Genius of Euler: Reflections on his Life and Work, volume 2 of Spectrum series; MAA tercentenary Euler celebration. Mathematical Association of America, Washington, DC, USA, 2007. ISBN 0-88385-558-5; 978-0-88385-558-4. xvi + 309 pp. LCCN QA29.E8 G46 2007. {591} [DX03] Lih-Yuan Deng and Hongquan Xu. A system of high-dimensional, efficient, long-cycle and portable uniform random number generators. ACM Transactions on Modeling and Computer Simulation, 13(4):299–309, October 2003. CODEN ATMCEZ. ISSN 1049-3301 (print), 1558-1195 (electronic). DOI 10.1145/945511.945513. {1023} [ECM05] ECMA. ECMA-367: Eiffel analysis, design and programming language. ECMA (European Association for Standardizing Information and Communication Systems), Geneva, Switzerland, June 2005. URL http://www.ecma-international.org/publications/files/ ECMA-ST/ECMA-367.pdf; http://www.ecma-international.org/publications/standards/Ecma-367.htm. {830} [ECM06a] ECMA. ECMA-334: C# Language Specification. ECMA (European Association for Standardizing Information and Communication Systems), Geneva, Switzerland, fourth edition, June 2006. xix + 531 pp. URL http://www.ecma-international.org/publications/ files/ecma-st/ECMA-334.pdf; http://www.ecma-international.org/publications/standards/Ecma-334.htm. {vii, 917} [ECM06b] ECMA. ECMA-335: Common Language Infrastructure (CLI). ECMA (European Association for Standardizing Information and Commu- nication Systems), Geneva, Switzerland, fourth edition, June 2006. vii + 104 (Part I), viii + 191 (Part II), iv + 138 (Part III), ii + 20 (Part IV),i+4(Part V), ii + 57 (Part VI) pp. URL http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-335.pdf; http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-335.zip; http://www.ecma-international.org/ publications/standards/Ecma-335.htm. {917, 918} [EH92] Jürgen Eichenauer-Herrmann. Inversive congruential pseudorandom numbers: a tutorial. International Statistical Review = Revue Internationale de Statistique, 60(2):167–176, August 1992. CODEN ISTRDP. ISSN 0306-7734 (print), 1751-5823 (electronic). URL http:// www.jstor.org/stable/1403647. DOI 10.2307/1403647. {180} [EH95] Jürgen Eichenauer-Herrmann. Pseudorandom number generation by nonlinear methods. International Statistical Review = Revue Internationale de Statistique, 63(2):247–255, August 1995. CODEN ISTRDP. ISSN 0306-7734 (print), 1751-5823 (electronic). URL http:// www.jstor.org/stable/1403620. DOI 10.2307/1403620. {177, 1026, 1035} Bibliography 1009

[EHHW98] Jürgen Eichenauer-Herrmann, Eva Herrmann, and Stefan Wegenkittl. A survey of quadratic and inversive congruential pseudorandom numbers. In Harald Niederreiter, Peter Hellekalek, Gerhard Larcher, and Peter Zinterhof, editors, Monte Carlo and Quasi-Monte Carlo methods 1996: proceedings of a conference at the University of Salzburg, Austria, July 9–12, 1996, volume 127 of Lecture Notes in Statis- tics, pages 66–97. Springer-Verlag, Berlin, Germany / Heidelberg, Germany / London, UK / etc., 1998. ISBN 0-387-98335-X (softcover); 978-0-387-98335-6 (softcover). LCCN Q183.9 .M67 1998. DOI 10.1007/978-1-4612-1690-2_4. {180} [El 06] Refaat A. El Attar. Special Functions and Orthogonal Polynomials, volume 3 of Mathematical series. Lulu Press, Morrisville, NC, USA, 2006. ISBN 1-4116-6690-9 (paperback); 978-1-4116-6690-0 (paperback). vi + 302 pp. LCCN QA404.5 .E5 2006; QA351 .E5 2006. {59} [EL86] Jürgen Eichenauer and Jürgen Lehn. A non-linear congruential pseudo random number generator. Statistical Papers = Statistische Hefte, 27(1):315–326, September 1986. CODEN STPAE4. ISSN 0932-5026 (print), 1613-9798 (electronic). DOI 10.1007/BF02932576. {180} [EL04a] Miloš Dragutin Ercegovac and Tomás Lang. Digital Arithmetic. Morgan Kaufmann Publishers, Los Altos, CA 94022, USA, 2004. ISBN 1-55860-798-6; 978-1-55860-798-9. xxv + 709 pp. LCCN QA76.9.C62 E72 2004. {104, 407, 881, 978} [EL04b] Pierre Eymard and Jean-Pierre Lafon. The Number π [pi]. American Mathematical Society, Providence, RI, USA, 2004. ISBN 0-8218- 3246-8; 978-0-8218-3246-2. x + 322 pp. LCCN QA484 .E9613 2004. URL http://www.ams.org/bookpages/tnp/. Translated by Stephen S. Wilson from the 1999 French original, Autour du nombre π [pi]. {14, 59, 623} [EM79] Richard H. Eckhouse, Jr. and L. Robert Morris. Minicomputer Systems: Organization, Programming, and Applications (PDP-11). Prentice- Hall, Upper Saddle River, NJ, USA, 1979. ISBN 0-13-583914-9; 978-0-13-583914-0. xix + 491 pp. LCCN QA76.8.P2E26 1979. {956} [EM94] Boelie Elzen and Donald MacKenzie. The social limits of speed: The development and use of supercomputers. IEEE Annals of the History of Computing, 16(1):46–61, Spring 1994. CODEN IAHCEX. ISSN 1058-6180 (print), 1934-1547 (electronic). URL http:// dlib.computer.org/an/books/an1994/pdf/a1046.pdf; http://www.computer.org/annals/an1994/a1046abs.htm. DOI 10.1109/ 85.251854. {952} [Ent98] Karl Entacher. Bad subsequences of well-known linear congruential pseudorandom number generators. ACM Transactions on Modeling and Computer Simulation, 8(1):61–70, January 1998. CODEN ATMCEZ. ISSN 1049-3301 (print), 1558-1195 (electronic). DOI 10.1145/ 272991.273009. {172} [ESC05] D. Eastlake, 3rd, J. Schiller, and S. Crocker. RFC 4086: Randomness recommendations for security, June 2005. URL ftp:// ftp.internic.net/rfc/rfc4086.txt. {214} [ESU01] Karl Entacher, Thomas Schell, and Andreas Uhl. Optimization of random number generators: efficient search for high-quality LCGs. Probabilistic Engineering Mechanics, 16(4):289–293, October 2001. CODEN PEMEEX. ISSN 0266-8920 (print), 1878-4275 (electronic). URL http://www.sciencedirect.com/science/article/pii/S0266892001000212. DOI 10.1016/S0266-8920(01)00021-2. {170} [ETZ09] Andreas Enge, Philippe Théveny, and Paul Zimmermann. mpc — A library for multiprecision complex arithmetic with exact rounding. INRIA, France, 0.8.1 edition, December 2009. URL http://mpc.multiprecision.org/. {825} [Eul92] Leonhard Euler. Leonhardi Euleri Opera Omnia: Series Prima: Opera Mathematica. Birkhäuser, Cambridge, MA, USA; Berlin, Germany; Basel, Switzerland, 1992. ISBN 3-7643-1474-5; 978-3-7643-1474-3. 29 volumes in first series alone. {591} [Eve83] Howard Eves. An Introduction to the History of Mathematics. Saunders College Publishing, Philadelphia, PA, USA, 1983. ISBN 0-03- 062064-3; 978-0-03-062064-5. xviii + 593 pp. LCCN QA21.E8. {59} [FC64] M. A. Fisherkeller and William J. Cody, Jr. Tables of the complete elliptic integrals K, K, E, and E. Technical Memo ANL AMD 71, Argonne National Laboratory, Argonne, IL, USA, 1964. 14 pp. See review by John W. Wrench in Mathematics of Computation, 19(89–92), 342, 1965. {644} [Fel07] Emil Alfred Fellmann. Leonhard Euler. Birkhäuser, Cambridge, MA, USA; Berlin, Germany; Basel, Switzerland, 2007. ISBN 3-7643- 7538-8; 978-3-7643-7538-6. xv + 179 pp. LCCN QA29.E8 F452 2007. Translated by E. Gautschi and W. Gautschi from the 1995 German original of the same title. {591} [Fer95] Warren E. Ferguson, Jr. Exact computation of a sum or difference with applications to argument reduction. In Knowles and McAllister [KM95], pages 216–221. ISBN 0-8186-7089-4 (paperback), 0-8186-7089-4 (case), 0-8186-7149-1 (microfiche), 0-8186-7089-4 (softbound), 0-7803-2949-X (casebound); 978-0-8186-7089-3 (paperback), 978-0-8186-7089-3 (case), 978-0-8186-7149-4 (microfiche), 978-0-8186-7089- 3 (softbound), 978-0-7803-2949-2 (casebound). LCCN QA 76.9 C62 S95 1995. URL http://www.acsel-lab.com/arithmetic/arith12/ papers/ARITH12_Ferguson.pdf. DOI 10.1109/ARITH.1995.465355. {271} [Fet74] Henry E. Fettis. A stable algorithm for computing the inverse error function in the ‘tail-end’ region. Mathematics of Computation, 28(126): 585–587, April 1974. CODEN MCMPAF. ISSN 0025-5718 (print), 1088-6842 (electronic). URL http://www.jstor.org/stable/2005933. DOI 10.2307/2005933. {600} [FF01] Sarah Flannery and David Flannery. In Code: A [Young Women’s] Mathematical Journey. Algonquin Books of Chapel Hill, Chapel Hill, NC, USA, 2001. ISBN 1-56512-377-8; 978-1-56512-377-9. ix + 341 pp. LCCN QA29.F6 A3 2003. {208, 591} [FHL+07] Laurent Fousse, Guillaume Hanrot, Vincent Lefèvre, Patrick Pélissier, and Paul Zimmermann. MPFR: A multiple-precision binary floating-point library with correct rounding. ACM Transactions on Mathematical Software, 33(2):1–15, June 2007. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/1236463.1236468. {401, 407} [FHS78a] Phyllis A. Fox, A. D. Hall, and Norman L. Schryer. Algorithm 528: Framework for a portable library [Z]. ACM Transactions on Mathematical Software, 4(2):177–188, June 1978. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/ 355780.355789. See remarks [Fox79, GG99]. {823, 1010, 1012} [FHS78b] Phyllis A. Fox, A. D. Hall, and Norman L. Schryer. The PORT mathematical subroutine library. ACM Transactions on Mathematical Software, 4(2):104–126, June 1978. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/355780.355783. {341, 352} 1010 Bibliography

[FI94] Toshio Fukushima and Hideharu Ishizaki. Numerical computation of incomplete elliptic integrals of a general form. Celestial Mechanics and Dynamical Astronomy, 59(3):237–251, July 1994. CODEN CLMCAV. ISSN 0923-2958 (print), 1572-9478 (electronic). URL http:// www.springerlink.com/content/0923-2958/. DOI 10.1007/BF00692874. {645, 690} [Fin97] B. F. Finkel. Biography: Leonhard Euler. American Mathematical Monthly, 4(12):297–302, December 1897. CODEN AMMYAE. ISSN 0002-9890 (print), 1930-0972 (electronic). URL http://www.jstor.org/stable/2968971. DOI 10.2307/2968971. {591} [Fin03] Steven R. Finch. Mathematical Constants, volume 94 of Encyclopedia of Mathematics and its Applications. Cambridge Univer- sity Press, Cambridge, UK, 2003. ISBN 0-521-81805-2; 978-0-521-81805-6. xix + 602 pp. LCCN QA41 .F54 2003. URL http://numbers.computation.free.fr/Constants/constants.html. {59} [FIS64] A. D. Falkoff, K. E. Iverson, and E. H. Sussenguth. A formal description of SYSTEM/360. IBM Systems Journal, 3(2):198–261, 1964. CODEN IBMSA7. ISSN 0018-8670. URL http://www.research.ibm.com/journal/sj/032/falkoff.pdf. DOI 10.1147/sj.32.0198. {928} [FM82] George S. Fishman and Louis R. Moore III. A statistical evaluation of multiplicative congruential random number generators with modulus 231 − 1. Journal of the American Statistical Association, 77(377):129–136, March 1982. CODEN JSTNAL. ISSN 0162- 1459 (print), 1537-274x (electronic). URL http://links.jstor.org/sici?sici=0162-1459%28198203%2977%3A377%3C129%3AASEOMC% 3E2.0.CO%3B2-Q. DOI 10.2307/2287778. {170} [FM86a] George S. Fishman and Louis R. Moore III. An exhaustive analysis of multiplicative congruential random number generators with modulus 231 − 1. SIAM Journal on Scientiﬁc and Statistical Computing, 7(1):24–45, January 1986. CODEN SIJCD4. ISSN 0196-5204. URL http://link.aip.org/link/?SCE/7/24/1. DOI 10.1137/0907002. See erratum [FM86b]. {170, 1010} [FM86b] George S. Fishman and Louis R. Moore III. Erratum: “An exhaustive analysis of multiplicative congruential random number generators with modulus 231 − 1”. SIAM Journal on Scientiﬁc and Statistical Computing, 7(3):1058, July 1986. CODEN SIJCD4. ISSN 0196-5204. URL http://epubs.siam.org/sisc/resource/1/sjoce3/v7/i3/p1058_s1; http://link.aip.org/link/?SCE/7/1058/ 1. DOI 10.1137/0907072. See [FM86a]. {1010} [FO01] Michael J. Flynn and Stuart F. Oberman. Advanced Computer Arithmetic Design. Wiley, New York, NY, USA, 2001. ISBN 0-471-41209-0; 978-0-471-41209-0. xv + 325 pp. LCCN TK7895.A65 F59 2001. {17} [For69a] George E. Forsythe. Solving a quadratic equation on a computer. In George A. W. Boehm, editor, The Mathematical Sciences: a Collection of Essays, pages 138–152. MIT Press, Cambridge, MA, USA, 1969. LCCN QA11 .M39. Edited by the National Research Council’s Committee on Support of Research in the Mathematical Sciences (COSRIMS) with the collaboration of George A. W. Boehm. {472, 474} [For69b] George E. Forsythe. What is a satisfactory quadratic equation solver? In Bruno Dejon and Peter Henrici, editors, Constructive aspects of the fundamental theorem of algebra: Proceedings of a symposium conducted at the IBM Research Laboratory, Zürich-Rüschlikon, Switzerland, June 5–7, 1967, pages 53–61. Wiley-Interscience, New York, NY, USA, 1969. ISBN 0-471-20300-9; 978-0-471-20300-1. LCCN QA212 .C65. URL http://www.dtic.mil/dtic/tr/fulltext/u2/657639.pdf. {472} [Fox79] Phyllis A. Fox. Remark on “Algorithm 528: Framework for a portable library [Z]”. ACM Transactions on Mathematical Software, 5(4):524, December 1979. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/355853.355871. See [FHS78a, GG99]. {1009, 1012} [FP68] L. Fox and I. B. Parker. Chebyshev Polynomials in Numerical Analysis. Oxford mathematical handbooks. Oxford University Press, Oxford, UK, 1968. ix + 205 pp. LCCN QA297 .F65. {58} [Fra99] Donald R. Franceschetti, editor. Biographical Encyclopedia of Mathematicians. Marshall Cavendish, New York, NY, USA, 1999. ISBN 0-7614-7069-7 (set), 0-7614-7070-0 (vol. 1), 0-7614-7071-9 (vol. 2); 978-0-7614-7069-4 (set), 978-0-7614-7070-0 (vol. 1), 978-0-7614-7071-7 (vol. 2). xiv + 585 + xix pp. LCCN QA28 .B544 1999. {59} [Fri67] Paul Friedland. Algorithm 312: Absolute value and square root of a complex number. Communications of the Association for Computing Machinery, 10(10):665, October 1967. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). DOI 10.1145/363717.363780. {481} [FS03] Niels Ferguson and Bruce Schneier. Practical Cryptography. Wiley, New York, NY, USA, 2003. ISBN 0-471-22894-X (hardcover), 0-471- 22357-3 (paperback); 978-0-471-22894-3 (hardcover), 978-0-471-22357-3 (paperback). xx + 410 pp. LCCN QA76.9.A25 F466 2003. URL http://www.counterpane.com/book-practical.html. {168, 206, 214, 591} [FSK10] Niels Ferguson, Bruce Schneier, and Tadayoshi Kohno. Cryptography Engineering: Design Principles and Practical Applications. Wiley, New York, NY, USA, 2010. ISBN 0-470-47424-6 (paperback); 978-0-470-47424-2 (paperback). xxix + 353 pp. LCCN QA76.9.A25 F466 2010. {214} [FTN91] International Standard: Information, Technology, Programming Languages, Fortran. International Organization for Standardization, Geneva, Switzerland, second edition, 1991. xvii + 369 pp. URL http://www.iso.ch/cate/d26933.html; http://www.iso.ch/ cate/d26934.html; http://www.iso.ch/cate/d29926.html. {vii, 106} [FTN97] ISO/IEC 1539-1:1997: Information technology — Programming languages — Fortran — Part 1: Base language. International Organization for Standardization, Geneva, Switzerland, 1997. URL http://webstore.ansi.org/ansidocstore/product.asp?sku=ISO%2FIEC+1539% 2D1%3A1997. {vii} [FTN04a] Draft International Standard ISO/IEC 1539-1:2004(E): Information technology — Programming languages — Fortran Part 1: Base Language. International Organization for Standardization, Geneva, Switzerland, May 2004. xiv + 569 pp. URL ftp://ftp.nag.co.uk/sc22wg5/ N1601-N1650/N1601.pdf.gz. {341} [FTN04b] ISO/IEC 1539-1:2004 Information technology — Programming languages — Fortran – Part 1: Base language. International Organization for Standardization, Geneva, Switzerland, 2004. xiv + 569 pp. URL http://www.dkuug.dk/jtc1/sc22/open/n3661.pdf. {941} Bibliography 1011

[FTN10] ISO/IEC 1539-1:2010 Information technology — Programming languages — Fortran — Part 1: Base language. International Organization for Standardization, Geneva, Switzerland, June 2010. xviii + 603 pp. URL ftp://ftp.nag.co.uk/sc22wg5/N1801-N1850/N1830.pdf. {vii, 223, 591, 593, 694, 941} [Fuk09a] Toshio Fukushima. Fast computation of complete elliptic integrals and Jacobian elliptic functions. Celestial Mechanics and Dy- namical Astronomy, 105(4):305–328, December 2009. CODEN CLMCAV. ISSN 0923-2958 (print), 1572-9478 (electronic). URL http://www.springerlink.com/content/0923-2958/. DOI 10.1007/s10569-009-9228-z. {627, 645, 690} [Fuk09b] Toshio Fukushima. Fast computation of Jacobian elliptic functions and incomplete elliptic integrals for constant values of elliptic parameter and elliptic characteristic. Celestial Mechanics and Dynamical Astronomy, 105(1–3):245–260, 2009. CODEN CLMCAV. ISSN 0923- 2958 (print), 1572-9478 (electronic). URL http://www.springerlink.com/content/0923-2958/. DOI 10.1007/s10569-008-9177-y. {627, 645, 690} [Fuk10] Toshio Fukushima. Fast computation of incomplete elliptic integral of first kind by half argument transformation. Nu- merische Mathematik, 116(4):687–719, October 2010. CODEN NUMMA7. ISSN 0029-599X (print), 0945-3245 (electronic). URL http://www.springerlink.com/openurl.asp?genre=article&issn=0029-599X&volume=116&issue=4&spage=687. DOI 10.1007/ s00211-010-0321-8. {645, 690} [Fuk11] Toshio Fukushima. Precise and fast computation of the general complete elliptic integral of the second kind. Math- ematics of Computation, 80(275):1725–1743, July 2011. CODEN MCMPAF. ISSN 0025-5718 (print), 1088-6842 (electronic). URL http://www.ams.org/journals/mcom/2011-80-275/S0025-5718-2011-02455-5/; http://www.ams.org/journals/ mcom/2011-80-275/S0025-5718-2011-02455-5/S0025-5718-2011-02455-5.pdf. DOI 10.1090/S0025-5718-2011-02455-5. {690} [Fuk12] Toshio Fukushima. Series expansions of symmetric elliptic integrals. Mathematics of Computation, 81(278):957–990, April 2012. CODEN MCMPAF. ISSN 0025-5718 (print), 1088-6842 (electronic). URL http://www.ams.org/journals/mcom/ 2012-81-278/S0025-5718-2011-02531-7; http://www.ams.org/journals/mcom/2012-81-278/S0025-5718-2011-02531-7/ S0025-5718-2011-02531-7.pdf. DOI 10.1090/S0025-5718-2011-02531-7. {690} [Fuk13a] Toshio Fukushima. Precise and fast computation of Jacobian elliptic functions by conditional duplication. Numerische Mathematik, 123(4):585–605, April 2013. CODEN NUMMA7. ISSN 0029-599X (print), 0945-3245 (electronic). URL http://link.springer.com/ article/10.1007/s00211-012-0498-0. DOI 10.1007/s00211-012-0498-0. {690} [Fuk13b] Toshio Fukushima. Recursive computation of derivatives of elliptic functions and of incomplete elliptic integrals. Applied Mathematics and Computation, 221:21–31, September 15, 2013. CODEN AMHCBQ. ISSN 0096-3003 (print), 1873-5649 (electronic). URL http:// www.sciencedirect.com/science/article/pii/S0096300313006152. DOI 10.1016/j.amc.2013.06.008. {690} [Ful81a] L. Wayne Fullerton. FNLIB user’s manual. Technical report CSTR 95, Bell Telephone Laboratories, Murray Hill, NJ, USA, March 1981. {341, 352} [Ful81b] L. Wayne Fullerton. FNLIB user’s manual explanatory table of contents. Technical report CSTR 92, Bell Telephone Laboratories, Murray Hill, NJ, USA, March 1981. {341, 352} [FvGM90] W. H. J. Feijen, A. J. M. van Gasteren, David Gries, and J. Misra, editors. Beauty is our Business: a Birthday Salute to Edsger W. Dijkstra. Springer-Verlag, Berlin, Germany / Heidelberg, Germany / London, UK / etc., 1990. ISBN 0-387-97299-4; 978-0-387-97299-2. xix + 453 pp. LCCN QA76 .B326 1990. DOI 10.1007/978-1-4612-4476-9. Contains important treatment of accurate binary-to-decimal conversion [Gri90, Knu90]. {1013, 1020} [Gam88] George Gamow. One, Two, Three, ..., Infinity: Facts and Speculations of Science. Dover, New York, NY, USA, 1988. ISBN 0-486-25664-2 (paperback); 978-0-486-25664-1 (paperback). xii + 340 pp. LCCN Q162 .G23 1988. {59} [Gan95] Mike Gancarz. The UNIX philosophy. Digital Press, Bedford, MA, USA, 1995. ISBN 1-55558-123-4; 978-1-55558-123-7. xix + 151 pp. LCCN QA76.76.O63G365 1995. {956} [Gan03] Mike Gancarz. Linux and the Unix Philosophy. Digital Press, Bedford, MA, USA, 2003. ISBN 1-55558-273-7; 978-1-55558-273-9. xxvii + 220 pp. LCCN QA76.76.O63G364 2003. {956} [Gau64] Walter Gautschi. ACM Algorithm 236: Bessel functions of the first kind [S17]. Communications of the Association for Computing Machin- ery, 7(8):479–480, August 1964. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). DOI 10.1145/355586.355587. See remark [Sko75]. {693, 1032} [Gau67] Walter Gautschi. Computational aspects of three-term recurrence relations. SIAM Review, 9(1):24–82, January 1967. CODEN SIREAD. ISSN 0036-1445 (print), 1095-7200 (electronic). URL http://link.aip.org/link/?SIR/9/24/1. DOI 10.1137/1009002. {705} [Gau79a] Walter Gautschi. Algorithm 542: Incomplete gamma functions [S14]. ACM Transactions on Mathematical Software, 5(4):482–489, Decem- ber 1979. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/355853.355864. {562} [Gau79b] Walter Gautschi. A computational procedure for incomplete gamma functions. ACM Transactions on Mathematical Software, 5(4): 466–481, December 1979. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/355853.355863. {562} [Gau04] Walter Gautschi. Orthogonal Polynomials: Computation and Approximation. Oxford University Press, Oxford, UK, 2004. ISBN 0-19- 850672-4; 978-0-19-850672-0. viii + 301 pp. LCCN QA404.5 .G356 2004. {58, 59} [Gau08] Walter Gautschi. Leonhard Euler: His life, the man, and his works. SIAM Review, 50(1):3–33, 2008. CODEN SIREAD. ISSN 0036-1445 (print), 1095-7200 (electronic). URL http://link.aip.org/link/?SIR/50/3/1. DOI 10.1137/070702710. {59, 591} [Gay90] David M. Gay. Correctly rounded binary-decimal and decimal-binary conversions. Numerical Analysis Manuscript 90-10, AT&T Bell Laboratories, November 30 1990. 16 pp. URL http://cm.bell-labs.com/cm/cs/doc/90/4-10.ps.gz; http: //www.ampl.com/ampl/REFS/rounding.ps.gz; http://www.netlib.org/fp/dtoa.c; http://www.netlib.org/fp/g_fmt.c; http://www.netlib.org/fp/gdtoa.tgz; http://www.netlib.org/fp/rnd_prod.s. {895} 1012 Bibliography

[GB91] Shmuel Gal and Boris Bachelis. An accurate elementary mathematical library for the IEEE floating point standard. ACM Transactions on Mathematical Software, 17(1):26–45, March 1991. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). URL http:// www.acm.org/pubs/citations/journals/toms/1991-17-1/p26-gal/. DOI 10.1145/103147.103151. {827} [GBC+02] Solomon W. Golomb, Elwyn Berlekamp, Thomas M. Cover, Robert G. Gallager, James L. Massey, and Andrew J. Viterbi. Claude Elwood Shannon (1916–2001). Notices of the American Mathematical Society, 49(1):8–16, January 2002. CODEN AMNOAN. ISSN 0002- 9920 (print), 1088-9477 (electronic). URL http://www.ams.org/notices/200201/fea-shannon.pdf. {969} [GBGL08] Timothy Gowers, June Barrow-Green, and Imre Leader, editors. The Princeton Companion to Mathematics. Princeton University Press, Princeton, NJ, USA, 2008. ISBN 0-691-11880-9; 978-0-691-11880-2. xx + 1034 pp. LCCN QA11.2 .P745 2008. {59, 60} [GDT+05] Mark Galassi, Jim Davies, James Theiler, Brian Gough, Gerard Jungman, Michael Booth, and Fabrice Rossi. GNU Scientific Library: Reference Manual. Network Theory Ltd., Bristol, UK, second revised edition, 2005. ISBN 0-9541617-3-4; 978-0-9541617-3-6. xvi + 601 pp. LCCN QA76.73.C15. URL http://www.network-theory.co.uk/gsl/manual/. {567, 583, 693, 694, 825} [Gen03] James E. Gentle. Random Number Generation and Monte Carlo Methods. Springer-Verlag, Berlin, Germany / Heidelberg, Germany / London, UK / etc., second edition, 2003. ISBN 0-387-00178-6; 978-0-387-00178-4. xv + 381 pp. LCCN QA298 .G46 2003. URL http://www.science.gmu.edu/~jgentle/rngbk/. DOI 10.1007/b97336. {214} [GG98] I. Grattan-Guinness. The Norton History of the Mathematical Sciences: the Rainbow of Mathematics. Norton history of science. W. W. Norton & Co., New York, NY, USA, 1998. ISBN 0-393-04650-8; 978-0-393-04650-2. 817 pp. LCCN QA21 .G695 1998. {59} [GG99] David M. Gay and Eric Grosse. Self-adapting Fortran 77 machine constants: Comment on Algorithm 528. ACM Transactions on Mathematical Software, 25(1):123–126, March 1999. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). URL http:// cm.bell-labs.com/who/ehg/mach/d1mach.ps. DOI 10.1145/305658.305711. See [FHS78a, Fox79]. {1009, 1010} [GH85] Paul Griffiths and Ian David Hill, editors. Applied Statistics Algorithms. Ellis Horwood series in mathematics and its applications. Ellis Horwood, New York, NY, USA, 1985. ISBN 0-85312-772-7 (UK), 0-470-20184-3 (US); 978-0-85312-772-7 (UK), 978-0-470-20184-8 (US). 307 pp. LCCN QA276.4 .A57 1985. Published for the Royal Statistical Society. {1037} [Gil51] S. Gill. A process for the step-by-step integration of differential equations in an automatic digital computing machine. Proceedings of the Cambridge Philosophical Society. Mathematical and physical sciences, 47(1):96–108, January 1951. CODEN PCPSA4. ISSN 0008-1981. DOI 10.1017/S0305004100026414. {353} [GJS96] James Gosling, Bill Joy, and Guy L. Steele Jr. The Java Language Specification. The Java Series. Addison-Wesley, Reading, MA, USA, 1996. ISBN 0-201-63451-1; 978-0-201-63451-8. xxv + 825 pp. LCCN QA76.73.J38G68 1996. URL http://www.aw.com/cp/javaseries.html; http://www.aw.com/cseng/titles/0-201-63451-1/. {979} [GJS+13] James Gosling, Bill Joy, Guy L. Steele Jr., Gilad Bracha, and Alex Buckley. The Java Language Specification. Addison-Wesley, Reading, MA, USA, Java SE 7 edition, 2013. ISBN 0-13-326022-4 (paperback); 978-0-13-326022-9 (paperback). xxvii + 644 pp. LCCN QA76.73.J38 G68 2013. {vii, 979} [GJS+14] James Gosling, Bill Joy, Guy L. Steele Jr., Gilad Bracha, and Alex Buckley. The Java Language Specification. Addison-Wesley, Addison- Wesley, Java SE 8 edition, 2014. ISBN 0-13-390069-X (paperback); 978-0-13-390069-9 (paperback). xxii + 758 pp. LCCN QA76.73.J38 G68 2014. {vii, 979} [GJSB00] James Gosling, Bill Joy, Guy L. Steele Jr., and Gilad Bracha. The Java language specification. Java series. Addison-Wesley, Reading, MA, USA, second edition, 2000. ISBN 0-201-31008-2; 978-0-201-31008-5. xxv + 505 pp. LCCN QA76.73.J38 G68 2000. URL http:// java.sun.com/people/jag/. {vii, 979} [GJSB05] James Gosling, Bill Joy, Guy L. Steele Jr., and Gilad Bracha. The Java Language Specification. The Java series. Addison-Wesley, Reading, MA, USA, third edition, 2005. ISBN 0-321-24678-0 (paperback); 978-0-321-24678-3 (paperback). xxxii + 651 pp. {vii, 978, 979} [GLL05] Stef Graillat, Philippe Langlois, and Nicolas Louvet. Compensated Horner scheme. Research Report RR2005-04, Équipe de Recherche DALI, Laboratoire LP2A, Université de Perpignan, Via Domitia, Perpignan, France, July 24, 2005. ii + 25 pp. URL http://gala.univ-perp.fr/~graillat/papers/rr2005-04.pdf. {89} [GLL06] Stef Graillat, Philippe Langlois, and Nicolas Louvet. Improving the compensated Horner scheme with a fused multiply and add. In Hisham M. Haddad, editor, Applied computing 2006: proceedings of the 2006 ACM Symposium on Applied Computing, Dijon, France, April 23–27, 2006, pages 1323–1327. ACM Press, New York, NY 10036, USA, 2006. ISBN 1-59593-108-2; 978-1-59593-108-5. LCCN QA76.76.A65 S95 2006. URL http://portal.acm.org/toc.cfm?id=1141277. DOI 10.1145/1141277.1141585. {89} [GM74] M. W. Gentleman and S. B. Marovich. More on algorithms that reveal properties of floating point arithmetic units. Communications of the Association for Computing Machinery, 17(5):276–277, May 1974. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). DOI 10.1145/360980.361003. See [Mal72]. {1023} [GM98] Robert Gordon and Alan McClellan. Essential JNI: Java Native Interface. Prentice-Hall, Upper Saddle River, NJ, USA, 1998. ISBN 0-13-679895-0; 978-0-13-679895-8. xxvii + 499 pp. LCCN QA76.73.J38 G665 1998. URL http://www.prenhall.com/ptrbooks/ptr_ 0136798950.html. {979} [GME99] Fred G. Gustavson, José E. Moreira, and Robert F. Enenkel. The fused multiply-add instruction leads to algorithms for extended- precision floating point: applications to Java and high-performance computing. In Stephen A. MacKay and J. Howard Johnson, editors, CASCON ’99: Proceedings of the 1999 Conference of the Centre for Advanced Studies on Collaborative Research. November 8–11, 1999, Mississauga, Ontario, Canada, page [4]. IBM Corporation, San Jose, CA, USA, 1999. URL http://tinyurl.com/z9dzuxf. Dedicated to Cleve Moler on his 60th birthday. {354} [Gol67] I. Bennett Goldberg. 27 bits are not enough for 8-digit accuracy. Communications of the Association for Computing Machinery, 10(2): 105–106, February 1967. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). DOI 10.1145/363067.363112. {840, 844, 851} Bibliography 1013

[Gol91a] David Goldberg. What every computer scientist should know about floating-point arithmetic. ACM Computing Surveys, 23(1):5–48, March 1991. CODEN CMSVAN. ISSN 0360-0300 (print), 1557-7341 (electronic). URL http://www.acm.org/pubs/toc/Abstracts/ 0360-0300/103163.html. DOI 10.1145/103162.103163. This widely cited article is an outstanding presentation of floating-point arithmetic. See also correction [Gol91b] and remarks [Dun92, Wic92]. {1008, 1013, 1037} [Gol91b] David Goldberg. Corrigendum: “What every computer scientist should know about floating-point arithmetic”. ACM Computing Surveys, 23(3):413, September 1991. CODEN CMSVAN. ISSN 0360-0300 (print), 1557-7341 (electronic). See [Gol91a, Dun92, Wic92]. {103, 1008, 1013, 1037} [Gol02] David Goldberg. Computer arithmetic. In Computer Architecture — A Quantitative Approach [PH02], chapter H, pages H–1–H–74. ISBN 1-55860-596-7; 978-1-55860-596-1. LCCN QA76.9.A73 P377 2003. URL http://books.elsevier.com/companions/1558605967/ appendices/1558605967-appendix-h.pdf. The complete Appendix H is not in the printed book; it is available only at the book’s Web site: http://www.mkp.com/CA3. {103} [Goo69] I. J. Good. How random are random numbers? The American Statistician, 23(4):42–45, October 1969. CODEN ASTAAJ. ISSN 0003-1305 (print), 1537-2731 (electronic). URL http://www.jstor.org/stable/2681742. DOI 10.2307/2681742. {169} [Gra00] Jeremy Gray. The Hilbert Challenge. Oxford University Press, Oxford, UK, 2000. ISBN 0-19-850651-1; 978-0-19-850651-5. xii + 315 pp. LCCN QA29.H5 G739 2000. {579, 590} [Gra09] Stef Graillat. Accurate floating-point product and exponentiation. IEEE Transactions on Computers, 58(7):994–1000, July 2009. CO- DEN ITCOB4. ISSN 0018-9340 (print), 1557-9956 (electronic). URL http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber= 4711041. DOI 10.1109/TC.2008.215. {529} [GRAST16] Amparo Gil, Diego Ruiz-Antolín, Javier Segura, and Nico M. Temme. Algorithm 969: Computation of the incomplete gamma function for negative values of the argument. ACM Transactions on Mathematical Software, 43(3):26:1–26:9, November 2016. CODEN ACM- SCU. ISSN 0098-3500 (print), 1557-7295 (electronic). URL http://dl.acm.org/citation.cfm?id=2972951. DOI 10.1145/2972951. {567} [Gri90] David Gries. Binary to decimal, one more time. In Feijen et al. [FvGM90], chapter 16, pages 141–148. ISBN 0-387-97299-4; 978-0-387- 97299-2. LCCN QA76 .B326 1990. DOI 10.1007/978-1-4612-4476-9_17. This paper presents an alternate proof of Knuth’s algorithm [Knu90] for conversion between decimal and fixed-point binary numbers. {895, 1011, 1020} [GRJZ07] I. S. Gradshteyn, I. M. Ryzhik, Alan Jeffrey, and Daniel Zwillinger. Table of Integrals, Series and Products. Academic Press, New York, NY, USA, seventh edition, 2007. ISBN 0-12-373637-4 (hardcover); 978-0-12-373637-6 (hardcover). xlv + 1171 pp. LCCN QA55 .G6613 2007. {58, 619, 682, 687} [GSR+04] Torbjörn Granlund, Gunnar Sjödin, Hans Riesel, Richard Stallman, Brian Beuning, Doug Lea, John Amanatides, Paul Zimmermann, Ken Weber, Per Bothner, Joachim Hollman, Bennet Yee, Andreas Schwab, Robert Harley, David Seal, Robert Harley, Torsten Ekedahl, Paul Zimmermann, Linus Nordberg, Kent Boortz, Kevin Ryde, Steve Root, Gerardo Ballabio, and Hans Thorsen. GNU MP: The GNU Multiple Precision Arithmetic Library. Free Software Foundation, Boston, MA, USA, version 4.1.4 edition, September 21, 2004. iv + 127 pp. URL ftp://ftp.gnu.org/gnu/gmp/gmp-4.1.4.tar.gz; http://www.swox.se/gmp/. GNU MP development began in 1991. Earler versions are 1.0 (8-Aug-1991), 2.0 (24-Apr-1996), 3.0 (17-Apr-2000), and 4.0 (1-Dec-2001). {401, 407, 825} [GST02] Amparo Gil, Javier Segura, and Nico M. Temme. Evaluation of the modified Bessel function of the third kind of imaginary orders. Journal of Computational Physics, 175(2):398–411, January 20, 2002. CODEN JCTPAH. ISSN 0021-9991 (print), 1090-2716 (electronic). DOI 10.1006/jcph.2001.6894. {693} [GST04] Amparo Gil, Javier Segura, and Nico M. Temme. Computing solutions of the modified Bessel differential equation for imaginary orders and positive arguments. ACM Transactions on Mathematical Software, 30(2):145–158, June 2004. CODEN ACMSCU. ISSN 0098- 3500 (print), 1557-7295 (electronic). DOI 10.1145/992200.992203. {693} [GST07] Amparo Gil, Javier Segura, and Nico M. Temme. Numerical Methods for Special Functions. SIAM (Society for Industrial and Applied Mathematics), Philadelphia, PA, USA, 2007. ISBN 0-89871-634-9; 978-0-89871-634-4. xvi + 415 pp. LCCN QA351 .G455 2007. {13, 17, 18, 58, 644, 693, 827} [Gus98] John Gustafson. Computational verifiability and feasibility of the ASCI program. IEEE Computational Science & Engineering, 5(1):36– 45, January/March 1998. CODEN ISCEE4. ISSN 1070-9924 (print), 1558-190x (electronic). DOI 10.1109/99.660304. Discusses recent progress in interval arithmetic and its relevance to error estimation in very large computations of the type envisioned for the US ASCI (Advanced Strategic Computing Initiative) project. {960, 967} [Gut04] Peter Gutmann. Cryptographic Security Architecture: Design and Verification. Springer-Verlag, Berlin, Germany / Heidelberg, Germany / London, UK / etc., 2004. ISBN 0-387-95387-6; 978-0-387-95387-8. xviii + 320 pp. LCCN QA76.9.A25 G88 2002. DOI 10.1007/b97264. {214} [HA85] T. E. Hull and A. Abrham. Properly rounded variable precision square root. ACM Transactions on Mathematical Software, 11(3):229–237, September 1985. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). URL http://www.acm.org/pubs/citations/ journals/toms/1985-11-3/p229-hull/. DOI 10.1145/214408.214413. {216, 827} [HA86] T. E. Hull and A. Abrham. Variable precision exponential function. ACM Transactions on Mathematical Software, 12(2):79–91, June 1986. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). URL http://www.acm.org/pubs/citations/journals/toms/ 1986-12-2/p79-hull/. DOI 10.1145/6497.6498. {827} [Hac84] Ian Hacking. Trial by number: Karl Pearson’s chi-square test measured the fit between theory and reality, ushering in a new sort of decision making. Science 84, 5(9):69–70, November 1984. This issue is entitled Century of the Sciences: 20 Discoveries That Changed Our Lives. {197} 1014 Bibliography

[Ham78] Hugo C. Hamaker. Miscellanea: Approximating the cumulative normal distribution and its inverse. Applied Statistics, 27(1):76– 77, 1978. CODEN APSTAG. ISSN 0035-9254 (print), 1467-9876 (electronic). URL http://www.jstor.org/stable/2346231. DOI 10.2307/2346231. {618} [Har70] V. C. Harris. An algorithm for finding the greatest common divisor. Fibonacci Quarterly, 8(1):102–103, February 1970. CODEN FIBQAU. ISSN 0015-0517. URL http://www.fq.math.ca/Scanned/8-1/harris1.pdf. {184} [Har06] Laszlo Hars. Modular inverse algorithms without multiplications for cryptographic applications. EURASIP Journal on Embedded Systems, 2006:1–13, 2006. ISSN 1687-3955 (print), 1687-3963 (electronic). URL http://downloads.hindawi.com/journals/es/2006/ 032192.pdf. DOI 10.1155/ES/2006/32192. Article ID 32192. {184} [Har09a] John Harrison. Decimal transcendentals via binary. In Bruguera et al. [BCDH09], pages 187–194. ISBN 0-7695-3670-0; 978-0-7695- 3670-5. ISSN 1063-6889. LCCN QA76.6. URL http://www.ac.usc.es/arith19/. DOI 10.1109/ARITH.2009.31. {826} [Har09b] John Harrison. Fast and accurate Bessel function computation. In Bruguera et al. [BCDH09], pages 104–113. ISBN 0-7695-3670-0; 978-0-7695-3670-5. ISSN 1063-6889. LCCN QA76.6. URL http://www.ac.usc.es/arith19/. DOI 10.1109/ARITH.2009.32. {693, 716} [Has55] Cecil Hastings, Jr. Approximations for Digital Computers. The Rand series. Princeton University Press, Princeton, NJ, USA, 1955. viii + 201 pp. LCCN QA76 .H37. Assisted by Jeanne T. Hayward and James P. Wong, Jr. {269, 600, 643, 827} [Hav03] Julian Havil. Gamma: Exploring Euler’s Constant. Princeton University Press, Princeton, NJ, USA, 2003. ISBN 0-691-09983-9; 978-0-691- 09983-5. xxiii + 266 pp. LCCN QA41 .H23 2003. {59, 591} [Haw05] Stephen Hawking. God Created the Integers: the Mathematical Breakthroughs that Changed History. Running Press Book Publishers, Philadelphia, PA; London, UK, 2005. ISBN 0-7624-1922-9 (hardcover); 978-0-7624-1922-7 (hardcover). xiii + 1160 pp. URL http:// www.perseusbooksgroup.com/runningpress/book_detail.jsp?isbn=0762419229. {59, 299, 521} [HBF09] Victor Henner, Tatyana Belozerova, and Kyle Forinash. Mathematical Methods in Physics: Partial Differential Equations, Fourier Series, and Special Functions. A. K. Peters, Wellesley, MA, USA, 2009. ISBN 1-56881-335-X, 1-4398-6516-7 (e-book); 978-1-56881-335-6, 978-1-4398- 6516-3 (e-book). xviii + 841 pp. LCCN QC20 .H487 2009. URL http://www.crcnetbase.com/isbn/9781568813356;. {827} [HCGE17] Miguel Herrero-Collantes and Juan Carlos Garcia-Escartin. Quantum random number generators. Reviews of Modern Physics,89 (1):015004:1–015004:48, January 2017. CODEN RMPHAT. ISSN 0034-6861 (print), 1538-4527 (electronic), 1539-0756. URL http:// journals.aps.org/rmp/abstract/10.1103/RevModPhys.89.015004. DOI 10.1103/RevModPhys.89.015004. {178} [HCL+68] John F. Hart, E. W. Cheney, Charles L. Lawson, Hans J. Maehly, Charles K. Mesztenyi, John R. Rice, Henry G. Thatcher, Jr., and Christoph Witzgall. Computer Approximations. Robert E. Krieger Publishing Company, Huntington, NY, USA, 1968. ISBN 0-88275-642- 7; 978-0-88275-642-4. x + 343 pp. LCCN QA 297 C64 1978. Reprinted 1978 with corrections. {1, 270, 306, 521, 589, 593, 644, 693, 768, 827} [Hea05] Anthony C. Hearn. REDUCE: The first forty years. In Andreas Dolzmann, Andreas Seidl, and Thomas Sturm, editors, Algorithmic Algebra and Logic: Proceedings of the A3L 2005, April 3–6, Passau, Germany, Conference in Honor of the 60th Birthday of Volker Weispfenning, pages 19–24. Herstellung und Verlag: Books on Demand GmhH, Norderstedt, Germany, 2005. ISBN 3-8334-2669-1; 978-3-8334-2669-8. LCCN A155.7.E4 A39 2005. URL http://reduce-algebra.com/reduce40.pdf. {28} [Hea09] Anthony C. Hearn. REDUCE is free software as of January 2009. ACM Communications in Computer Algebra, 43(1–2):15–16, March/June 2009. ISSN 1932-2232 (print), 1932-2240 (electronic). DOI 10.1145/1610296.1610299. {28} [Hel06] Hal Hellman. Great Feuds in Mathematics: Ten of the Liveliest Disputes Ever. Wiley, New York, NY, USA, 2006. ISBN 0-471-64877-9 (cloth); 978-0-471-64877-2 (cloth). vi + 250 pp. LCCN QA21 .H45 2006. {59} [Hen06] Doug Hensley. Continued Fractions. World Scientific Publishing, Singapore, 2006. ISBN 981-256-477-2; 978-981-256-477-1. xiii + 245 pp. LCCN QA295 .H377 2006. {19} [HF98] Roger Herz-Fischler. A Mathematical History of Golden Number. Dover, New York, NY, USA,√ 1998. ISBN 0-486-40007-7; 978-0-486-40007- φ = 1 ( + ) ≈ 5. xxii + 195 pp. LCCN QA481.H47 1998. The golden number,orgolden ratio,is 2 5 1 1.618. It is the last of the big five mathematical constants: e, i, π, γ, and φ. {8, 14, 59, 577} [HF09] Frank E. Harris and J. G. Fripiat. Methods for incomplete Bessel function evaluation. International Journal of Quantum Chemistry, 109 (8):1728–1740, February 4, 2009. CODEN IJQCB2. ISSN 0020-7608 (print), 1097-461X (electronic). DOI 10.1002/qua.21972. {693} [HFT94] T. E. Hull, Thomas F. Fairgrieve, and Ping Tak Peter Tang. Implementing complex elementary functions using exception handling. ACM Transactions on Mathematical Software, 20(2):215–244, June 1994. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). URL http://www.acm.org/pubs/citations/journals/toms/1994-20-2/p215-hull/. DOI 10.1145/178365.178404. See corrigenda [Ano94]. {476, 996} [HFT97] T. E. Hull, Thomas F. Fairgrieve, and Ping Tak Peter Tang. Implementing the complex arcsine and arccosine functions using exception handling. ACM Transactions on Mathematical Software, 23(3):299–335, September 1997. CODEN ACMSCU. ISSN 0098-3500 (print), 1557- 7295 (electronic). URL http://www.acm.org/pubs/citations/journals/toms/1997-23-3/p299-hull/. DOI 10.1145/275323.275324. {476} [HH80] Velma R. Huskey and Harry D. Huskey. Lady Lovelace and Charles Babbage. Annals of the History of Computing, 2(4):299–329, October/ December 1980. CODEN AHCOE5. ISSN 0164-1239. URL http://dlib.computer.org/an/books/an1980/pdf/a4299.pdf; http: //www.computer.org/annals/an1980/a4299abs.htm. DOI 10.1109/MAHC.1980.10042. {568} [HHPM07] Andreas K. Heyne, Alice K. Heyne, Elena S. Pini, and Tahu Matheson. Leonhard Euler: a Man to be Reckoned with. Birkhäuser, Cambridge, MA, USA; Berlin, Germany; Basel, Switzerland, 2007. ISBN 3-7643-8332-1; 978-3-7643-8332-9. 45 pp. LCCN QA29.E8 H49 2007. {59, 591} Bibliography 1015

[Hil77] Geoffrey W. Hill. Algorithm 518: Incomplete Bessel function I0. The von Mises distribution [S14]. ACM Transactions on Mathematical Software, 3(3):279–284, September 1977. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/355744.355753. {693}

[Hil81] Geoffrey W. Hill. Evaluation and inversion of the ratios of modified Bessel functions, I1(x)/I0(x) and I1.5(x)/I0.5(x). ACM Transactions on Mathematical Software, 7(2):199–208, June 1981. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/ 355945.355949. {693} [HJ67a] Ian David Hill and S. A. Joyce. Algorithm 304: Normal curve integral. Communications of the Association for Computing Machinery,10 (6):374–375, June 1967. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). DOI 10.1145/363332.363411. See remarks [HJ67b, Ber68]. {618, 999, 1015} [HJ67b] Ian David Hill and S. A. Joyce. Remarks on Algorithm 123 [S15]: Real error function, ERF(x); Algorithm 180 [S15]: Error function — large X; Algorithm 181 [S15]: Complementary error function — large X; Algorithm 209 [S15]: Gauss; Algorithm 226 [S15]: Normal distribution function; Algorithm 272 [S15]: Procedure for the normal distribution functions; Algorithm 304 [S15]: Normal curve integral. Communications of the Association for Computing Machinery, 10(6):377–378, June 1967. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). DOI 10.1145/363332.365433. See [Cyv64, Mac65, HJ67a]. {618, 999, 1006, 1015, 1023} [HLB00] Yozo Hida, Xiaoye S. Li, and David H. Bailey. Quad-double arithmetic: Algorithms, implementation, and application. Technical report 46996, Lawrence Berkeley National Laboratory, 1 Cycloton Rd, Berkeley, CA 94720, October 30, 2000. 28 pp. URL http:// www.cs.berkeley.edu/~yozo/papers/LBNL-46996.ps.gz. {366, 407, 777, 781} [HLD04] Wolfgang Hörmann, Josef Leydold, and Gerhard Derflinger. Automatic Nonuniform Random Variate Generation. Statistics and computing, 1431-8784. Springer-Verlag, Berlin, Germany / Heidelberg, Germany / London, UK / etc., 2004. ISBN 3-540-40652-2; 978-3-540- 40652-5. x + 441 pp. LCCN QA273 .H777 2004. DOI 10.1007/978-3-662-05946-3. {196} [HLSZ07] Guillaume Hanrot, Vincent Lefèvre, Damien Stehlé, and Paul Zimmermann. Worst cases of a periodic function for large arguments. In Kornerup and Muller [KM07], pages 133–140. ISBN 0-7695-2854-6; 978-0-7695-2854-0. ISSN 1063-6889. LCCN QA76.9.C62. URL http://www.lirmm.fr/arith18/. DOI 10.1109/ARITH.2007.37. {28} [Hoa81] C. A. R. Hoare. The Emperor’s old clothes. Communications of the Association for Computing Machinery, 24(2):75–83, 1981. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). DOI 10.1145/358549.358561. This is the 1980 ACM Turing Award Lecture, delivered at ACM’80, Nashville, Tennessee, October 27, 1980. {963} [Hou81] David G. Hough. Applications of the proposed IEEE-754 standard for floating point arithmetic. Computer, 14(3):70–74, March 1981. CODEN CPTRB4. ISSN 0018-9162 (print), 1558-0814 (electronic). URL http://ieeexplore.ieee.org/document/1667288/. DOI 10.1109/C-M.1981.220381. See [IEEE85a]. {63, 1016} [HP90] John L. Hennessy and David A. Patterson. Computer Architecture — A Quantitative Approach. Morgan Kaufmann Publishers, Los Altos, CA 94022, USA, 1990. ISBN 1-55860-069-8; 978-1-55860-069-0. xxviii + 594 pp. LCCN QA76.9.A73 P377 1990. {103} [HP91] David G. Hough and Vern Paxson. Testbase: base conversion test program. World-Wide Web document, July 20, 1991. URL http:// www.netlib.org/fp/testbase. See [PK91]. {851} [HP94] John L. Hennessy and David A. Patterson. Computer Organization and Design — The Hardware/Software Interface. Morgan Kaufmann Publishers, San Mateo, CA, USA, 1994. ISBN 1-55860-281-X; 978-1-55860-281-6. xxiv + 648 pp. LCCN QA76.9 .C643 P37 1994. {103} [HP96] John L. Hennessy and David A. Patterson. Computer Architecture — A Quantitative Approach. Morgan Kaufmann Publishers, Los Altos, CA 94022, USA, second edition, 1996. ISBN 1-55860-329-8; 978-1-55860-329-5. xxiii + 760 + A-77 + B-47 + C-26 + D-26 + E-13 + R-16 + I-14 pp. LCCN QA76.9.A73P377 1995. {103} [HP97] John L. Hennessy and David A. Patterson. Computer Organization: The Hardware/Software Interface. Morgan Kaufmann Publishers, San Mateo, CA, USA, second edition, 1997. ISBN 1-55860-428-6 (hardcover), 1-55860-491-X (softcover); 978-1-55860-428-5 (hardcover), 978-1-55860-491-9 (softcover). 1000 pp. LCCN QA76.9.C643H46 1997. {103} [HP03] John L. Hennessy and David A. Patterson. Computer Architecture — A Quantitative Approach. Morgan Kaufmann Publishers, Los Altos, CA 94022, USA, third edition, 2003. ISBN 1-55860-596-7; 978-1-55860-596-1. xxi + 883 + A-87 + B-42 + C-1 + D-1 + E-1 + F-1 + G-1 + H-1 + I-1 + R-22 + I-44 pp. LCCN QA76.9.A73 P377 2003. URL http://www.mkp.com/books_catalog/catalog.asp?ISBN=1-55860-596-7; http://www.mkp.com/CA3. {103} [HP04] John L. Hennessy and David A. Patterson. Computer Organization: The Hardware/Software Interface. Morgan Kaufmann Publishers, San Mateo, CA, USA, third edition, 2004. ISBN 1-55860-604-1; 978-1-55860-604-3. xvii + 621 pp. LCCN QA76.9.C643 H46 2004. {103} [HP12] John L. Hennessy and David A. Patterson. Computer Architecture: a Quantitative Approach. Morgan Kaufmann/Elsevier, Waltham, MA, USA, fifth edition, 2012. ISBN 0-12-383872-X (paperback); 978-0-12-383872-8 (paperback). xxvii + 493 + 325 pp. LCCN QA76.9.A73 P377 2012. URL http://store.elsevier.com/product.jsp?isbn=9780123838728. With contributions by Krste Asanović, Jason D. Kabos, Robert P. Colwell, Thomas M. Conte, José Duato, Diana Franklin, David Goldberg, Norman P. Jouppi, Sheng Li, Naveen Muralimanohar, Gregory D. Peterson, Timothy M. Pinkston, Parthasarathy Ranganthan, David A. Wood, and Amr Zaky. {103} [HPW90] Eldon R. Hansen, Merrell L. Patrick, and Richard L. C. Wang. Polynomial evaluation with scaling. ACM Transactions on Mathematical Software, 16(1):86–93, March 1990. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). URL http://www.acm.org/ pubs/citations/journals/toms/1990-16-1/p86-hansen/. DOI 10.1145/77626.77633. {89} [HPWW94] Brad Lee Holian, Ora E. Percus, Tony T. Warnock, and Paula A. Whitlock. Pseudorandom number generator for massively parallel molecular-dynamics simulations. Physical Review E (Statistical physics, plasmas, fluids, and related interdisciplinary topics), 50(2):1607– 1615, August 1994. CODEN PLEEE8. ISSN 1539-3755 (print), 1550-2376 (electronic). URL http://link.aps.org/doi/10.1103/ PhysRevE.50.1607. DOI 10.1103/PhysRevE.50.1607. {177} 1016 Bibliography

[HSH+09] J. Alex Halderman, Seth D. Schoen, Nadia Heninger, William Clarkson, William Paul, Joseph A. Calandrino, Ariel J. Feldman, Jacob Appelbaum, and Edward W. Felten. Lest we remember: cold-boot attacks on encryption keys. Communications of the Association for Computing Machinery, 52(5):91–98, May 2009. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). DOI 10.1145/ 1506409.1506429. {208} [HTWG08] Anders Hejlsberg, Mads Togersen, Scott Wiltamuth, and Peter Golde, editors. The C# Programming Language. Addison-Wesley, Reading, MA, USA, third edition, 2008. ISBN 0-321-56299-2; 978-0-321-56299-9. xviii + 754 pp. LCCN QA76.73.C154 H45 2008. {917} [HTWG11] Anders Hejlsberg, Mads Togersen, Scott Wiltamuth, and Peter Golde, editors. The C# Programming Language. Addison-Wesley, Reading, MA, USA, fourth edition, 2011. ISBN 0-321-74176-5; 978-0-321-74176-9. xviii + 844 pp. LCCN QA76.73.C154. URL http: //www.pearsonhighered.com/program/Hejlsberg-C-Programming-Language-Covering-C-4-0-The-4th-Edition/PGM269050.html. {917} [Hub11] Raymond Hubbard. The widespread misinterpretation of p-values as error probabilities. Journal of Applied Statistics, 38(11):2617–2626, November 2011. ISSN 0266-4763 (print), 1360-0532 (electronic). DOI 10.1080/02664763.2011.567245. {196} [HW03] Peter Hellekalek and Stefan Wegenkittl. Empirical evidence concerning AES. ACM Transactions on Modeling and Computer Simulation, 13(4):322–333, October 2003. CODEN ATMCEZ. ISSN 1049-3301 (print), 1558-1195 (electronic). URL http:// random.mat.sbg.ac.at/ftp/pub/publications/peter/aes_sub.ps; http://random.mat.sbg.ac.at/~peter/slides_YACC04.pdf. DOI 10.1145/945511.945515. {178} [HWG04] Anders Hejlsberg, Scott Wiltamuth, and Peter Golde. The C# programming language. Addison-Wesley, Reading, MA, USA, 2004. ISBN 0-321-15491-6; 978-0-321-15491-0. xiv + 644 pp. LCCN QA76.76.C154 H45 2004. {vii, 80, 917} [HWG06] Anders Hejlsberg, Scott Wiltamuth, and Peter Golde. The C# programming language. Addison-Wesley, Reading, MA, USA, second edition, 2006. ISBN 0-321-33443-4 (hardback); 978-0-321-33443-5 (hardback). xiv + 704 pp. LCCN QA76.73.C154 H45 2006. {917} [IA6406] Intel Corporation, Santa Clara, CA, USA. Intel Itanium Architecture Software Developer’s Manual, Volume 1: Application Architecture, January 2006. 250 pp. URL http://download.intel.com/design/Itanium/manuals/24531705.pdf. Order number 245317-005. {241} [IBM70] IBM Corporation, San Jose, CA, USA. A Programmer’s Introduction to IBM System/360 Assembler Language, August 1970. vii + 148 pp. URL http://bitsavers.org/pdf/ibm/360/asm/SC20-1646-6_int360asm_Aug70.pdf. Form number SC20-1646-6. {928} [IBM84] IBM Corporation, Poughkeepsie, NY, USA. High Accuracy Arithmetic, January 1984. iii + 22 pp. Publication number SA22-7093-0, File number S370-01. {964} [IBM06] IBM Corporation, San Jose, CA, USA. Preliminary Decimal-Floating-Point Architecture, November 2006. viii + 52 pp. URL http:// publibz.boulder.ibm.com/epubs/pdf/a2322320.pdf. Form number SA23-2232-00. {927, 963} [IBM07] IBM Corporation, San Jose, CA, USA. Power Instruction Set Architecture: Preliminary Decimal Floating-Point Architecture, July 2007. 52 pp. URL http://www.power.org/resources/downloads/PowerDFP.pdf. {109} [IEE13] IEEE, editor. Proceedings of the 21st IEEE Symposium on Computer Arithmetic, Austin, Texas, USA, 8–10 April 2013. IEEE Computer Society Press, Silver Spring, MD, USA, 2013. ISBN 0-7695-4957-8; 978-0-7695-4957-6. ISSN 1063-6889. LCCN QA76.9.C62 S95 2013. {1017, 1019} [IEE15] IEEE. 1788-2015 — IEEE Standard for Interval Arithmetic. IEEE, New York, NY, USA, June 30, 2015. ISBN 0-7381-9721-1 (PDF), 0-7381- 9720-3 (electronic); 978-0-7381-9721-0 (PDF), 978-0-7381-9720-3 (electronic). xiv + 79 pp. URL http://ieeexplore.ieee.org/servlet/ opac?punumber=7140719. DOI 10.1109/IEEESTD.2015.7140721. Approved 11 June 2015 by IEEE-SA Standards Board. {967} [IEEE85a] ANSI/IEEE 754-1985, Standard for Binary Floating-Point Arithmetic. IEEE, New York, NY, USA, August 12, 1985. ISBN 1-55937-653-8; 978-1-55937-653-2. 20 pp. URL http://standards.ieee.org/reading/ieee/std/busarch/754-1985.pdf. Revised 1990. A preliminary draft was published in the January 1980 issue of IEEE Computer, together with several companion articles [Cod81, Coo81b, Coo80, Coo81a, Hou81, Ste81a, Ste81b]. The final version was republished in [IEEE87, IEEE85b]. See also [WF82]. Also standardized as IEC 60559 (1989-01) Binary floating-point arithmetic for microprocessor systems. {1, 63, 104, 827, 966, 1005, 1015, 1016, 1033, 1036} [IEEE85b] IEEE Standard for Binary Floating-Point Arithmetic. ANSI/IEEE Std 754-1985. IEEE Computer Society Press, Silver Spring, MD, USA, 1985. 18 pp. See [IEEE85a]. {63, 1016} [IEEE87] ANSI/IEEE Std 754-1985. an American National Standard: IEEE Standard for Binary Floating-Point Arithmetic. ACM SIGPLAN Notices, 22(2):9–25, February 1987. CODEN SINODQ. ISSN 0362-1340 (print), 1523-2867 (print), 1558-1160 (electronic). URL http:// portalparts.acm.org/30000/24686/fm/frontmatter.pdf. See [IEEE85a]. {63, 104, 1016} [IEEE01] IEEE Std 1003.1-2001 Standard for Information Technology — Portable Operating System Interface (POSIX) System Interfaces, Issue 6. IEEE, New York, NY, USA, 2001. ISBN 1-85912-247-7 (UK), 1-931624-07-0 (US), 0-7381-3094-4 (print), 0-7381-3010-9 (PDF), 0-7381-3129- 6 (CD-ROM); 978-1-85912-247-1 (UK), 978-1-931624-07-7 (US), 978-0-7381-3094-1 (print), 978-0-7381-3010-1 (PDF), 978-0-7381-3129- 0 (CD-ROM). xxx + 1690 pp. Revision of IEEE Std 1003.1-1996 and IEEE Std 1003.2-1992, Open Group Technical Standard Base Specifications, Issue 6. {441} [IEEE08] IEEE 754-2008, Standard for Floating-Point Arithmetic. IEEE, New York, NY, USA, August 29, 2008. ISBN 0-7381-5753-8 (paper), 0- 7381-5752-X (electronic); 978-0-7381-5753-5 (paper), 978-0-7381-5752-8 (electronic). 58 pp. URL http://en.wikipedia.org/wiki/ IEEE_754-2008; http://ieeexplore.ieee.org/servlet/opac?punumber=4610933. DOI 10.1109/IEEESTD.2008.4610935. {vii, 1, 104, 825, 966} [Ifr00] Georges Ifrah. The Universal History of Numbers from Prehistory to the Invention of the Computer. Wiley, New York, NY, USA, 2000. ISBN 0-471-37568-3; 978-0-471-37568-5. xxii + 633 pp. LCCN QA141.I3713 2000. Translated by David Bellos, E. F. Harding, Sophie Wood, and Ian Monk from the 1994 French original, Histoire universelle des chiffres. {59} [Int85] Intel. The iAPX 286 Programmer’s Reference Manual. Intel Corporation, Santa Clara, CA, USA, 1985. {1028} Bibliography 1017

[Inte06] Reference software implementation of the IEEE 754R decimal floating-point arithmetic. World-Wide Web document, 2006. URL http://cache-www.intel.com/cd/00/00/29/43/294339_294339.pdf. {929} [Ioa05] John P. A. Ioannidis. Why most published research findings are false. PLoS Medicine, 2(8):696–701, August 2005. CO- DEN PMLEAC. ISSN 1549-1277 (print), 1549-1676 (electronic). URL http://www.plosmedicine.org/article/info:doi/10.1371/ journal.pmed.0020124. DOI 10.1371/journal.pmed.0020124. {196} [ISO11] ISO. ISO/IEC/IEEE 60559:2011 Information technology — Microprocessor Systems — Floating-Point arithmetic. International Organization for Standardization, Geneva, Switzerland, 2011. 58 pp. URL http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_ detail.htm?csnumber=57469. {vii, 1, 104, 825, 966} [Jab94] Aleksander Jablonski. Numerical evaluation of spherical Bessel functions of the first kind. Journal of Computational Physics, 111(2): 256–259, April 1994. CODEN JCTPAH. ISSN 0021-9991 (print), 1090-2716 (electronic). DOI 10.1006/jcph.1994.1060. {693} [Jac75] John David Jackson. Classical Electrodynamics. Wiley, New York, NY, USA, second edition, 1975. ISBN 0-471-43132-X; 978-0-471-43132-9. xxii + 848 pp. LCCN QC631 .J3 1975. {627, 693} [Jac92] David Jacobson. Engineer’s toolbox: Floating point in Mathematica. Mathematica Journal, 2(3):42–46, Summer 1992. ISSN 1047- 5974 (print), 1097-1610 (electronic). URL http://www.mathematica-journal.com/issue/v2i3/tutorials/toolbox/index.html. This article describes the significance arithmetic used in Mathematica’s software arbitrary-precision floating-point arithmetic. {966} [Jam89] M. J. Jamieson. Rapidly converging iterative formulae for finding square roots and their computational efficien- cies. The Computer Journal, 32(1):93–94, February 1989. CODEN CMPJA6. ISSN 0010-4620 (print), 1460-2067 (electronic). URL http://www3.oup.co.uk/computer_journal/hdb/Volume_32/Issue_01/tiff/93.tif; http://www3.oup.co.uk/ computer_journal/hdb/Volume_32/Issue_01/tiff/94.tif. DOI 10.1093/comjnl/32.1.93. This work generalizes the Pythagorean sums in [Dub83, MM83]. {228, 1008, 1024} [Jam90] F. James. A review of pseudorandom number generators. Computer Physics Communications, 60(3):329–344, October 1990. CO- DEN CPHCBZ. ISSN 0010-4655 (print), 1879-2944 (electronic). URL http://www.sciencedirect.com/science/article/pii/ 001046559090032V. DOI 10.1016/0010-4655(90)90032-V. {177} [JD08] Alan Jeffrey and Hui-Hui Dai. Handbook of Mathematical Formulas and Integrals. Elsevier Academic Press, Amsterdam, The Netherlands, fourth edition, 2008. ISBN 0-12-374288-9; 978-0-12-374288-9. xlv + 541 pp. LCCN QA47 .J38 2008. {58, 619} [Jea16] Claude-Pierre Jeannerod. A radix-independent error analysis of the Cornea–Harrison–Tang method. ACM Transactions on Mathematical Software, 42(3):19:1–19:20, May 2016. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/2824252. {463} [JEL68] E. Jahnke, Fritz Emde, and Friedrich Lösch. Tafeln höherer Funktionen. (German) [Tables of higher functions]. B. G. Teubner, Stuttgart, Germany, seventh edition, 1968. xii + 322 pp. LCCN QA55 .J32 1966. {58} [JK77] Norman Lloyd Johnson and Samuel Kotz. Urn Models and Their Application: An Approach to Modern Discrete Probability Theory. Wiley series in probability and mathematical statistics. Wiley, New York, NY, USA, 1977. ISBN 0-471-44630-0; 978-0-471-44630-9. xiii + 402 pp. LCCN QA273 .J623. {196} [JKB94] Norman Lloyd Johnson, Samuel Kotz, and N. Balakrishnan. Continuous Univariate Distributions. Wiley series in probability and mathematical statistics. Wiley, New York, NY, USA, second edition, 1994. ISBN 0-471-58495-9 (vol. 1), 0-471-58494-0 (vol. 2); 978-0- 471-58495-7 (vol. 1), 978-0-471-58494-0 (vol. 2). 761 (vol 1., est.), 752 (vol. 2, est.) pp. LCCN QA273.6 .J6 1994. Two volumes. {196} [JKB97] Norman Lloyd Johnson, Samuel Kotz, and N. Balakrishnan. Discrete Multivariate Distributions. Wiley series in probability and statistics. Applied probability and statistics. Wiley, New York, NY, USA, 1997. ISBN 0-471-12844-9 (cloth); 978-0-471-12844-1 (cloth). xxii + 299 pp. LCCN QA273.6 .J617 1997. {196} [JKK05] Norman Lloyd Johnson, Adrienne W. Kemp, and Samuel Kotz. Univariate Discrete Distributions. Wiley, New York, NY, USA, third edition, 2005. ISBN 0-471-27246-9; 978-0-471-27246-5. xix + 646 pp. LCCN QA273.6 .J64 2005. {196} [JKLM17] Claude-Pierre Jeannerod, Peter Kornerup, Nicolas Louvet, and Jean-Michel Muller. Error bounds on complex floating-point multiplication with an FMA. Mathematics of Computation, 86(304):881–898, 2017. CODEN MCMPAF. ISSN 0025-5718 (print), 1088-6842 (electronic). DOI 10.1090/mcom/3123. {458, 463} [JL12] U. D. Jentschura and E. Lötstedt. Numerical calculation of Bessel, Hankel and Airy functions. Computer Physics Communications, 183 (3):506–519, March 2012. CODEN CPHCBZ. ISSN 0010-4655 (print), 1879-2944 (electronic). URL http://www.sciencedirect.com/ science/article/pii/S0010465511003729. DOI 10.1016/j.cpc.2011.11.010. {693} [JLM13a] Claude-Pierre Jeannerod, Nicolas Louvet, and Jean-Michel Muller. Further analysis of Kahan’s algorithm for the accurate computation of 2 × 2 determinants. Mathematics of Computation, 82(284):2245–2264, 2013. CODEN MCMPAF. ISSN 0025-5718 (print), 1088-6842 (electronic). URL http://www.ams.org/journals/mcom/2013-82-284/S0025-5718-2013-02679-8; http://www.ams.org/journals/ mcom/2013-82-284/S0025-5718-2013-02679-8/S0025-5718-2013-02679-8.pdf. DOI 10.1090/S0025-5718-2013-02679-8. {463} [JLM13b] Claude-Pierre Jeannerod, Nicolas Louvet, and Jean-Michel Muller. On the componentwise accuracy of complex floating-point division with an FMA. In IEEE [IEE13], pages 83–90. ISBN 0-7695-4957-8; 978-0-7695-4957-6. ISSN 1063-6889. LCCN QA76.9.C62 S95 2013. DOI 10.1109/ARITH.2013.8. {463} [JLMP11] Claude-Pierre Jeannerod, Nicolas Louvet, Jean-Michel Muller, and Adrien Panhaleux. Midpoints and exact points of some algebraic functions in floating-point arithmetic. IEEE Transactions on Computers, 60(2):228–241, February 2011. CODEN ITCOB4. ISSN 0018-9340 (print), 1557-9956 (electronic). DOI 10.1109/TC.2010.144. {28} [JLMP16] Claude-Pierre Jeannerod, Nicolas Louvet, Jean-Michel Muller, and Antoine Plet. Sharp error bounds for complex floating-point inversion. Numerical Algorithms, 73(3):735–760, November 2016. CODEN NUALEG. ISSN 1017-1398 (print), 1572-9265 (electronic). URL http://link.springer.com/article/10.1007/s11075-016-0115-x. DOI 10.1007/s11075-016-0115-x. {463} 1018 Bibliography

[JP89] P. Johnstone and F. E. Petry. Higher radix floating point representations. In Miloš D. Ercegovac and Earl E. Swartzlander, Jr., editors, Proceedings: 9th Symposium on Computer Arithmetic: September 6–8, 1989, Santa Monica, California, USA, pages 128–135. IEEE Computer Society Press, Silver Spring, MD, USA, 1989. ISBN 0-8186-8963-3 (case), 0-8186-5963-7 (microfiche); 978-0-8186-8963-5 (case), 978-0- 8186-5963-8 (microfiche). LCCN QA 76.9 C62 S95 1989. DOI 10.1109/ARITH.1989.72818. IEEE catalog number 89CH2757-3. {964} [JPS07] Jon Jagger, Nigel Perry, and Peter Sestoft. Annotated C# standard. Morgan Kaufmann Publishers, Los Altos, CA 94022, USA, 2007. ISBN 0-12-372511-9; 978-0-12-372511-0. xxiii + 825 pp. LCCN QA76.73.C154 J35 2007. {102, 103, 917} [JT74] William B. Jones and Wolfgang J. Thron. Numerical stability in evaluating continued fractions. Mathematics of Computation, 28(127): 795–810, July 1974. CODEN MCMPAF. ISSN 0025-5718 (print), 1088-6842 (electronic). URL http://www.jstor.org/stable/2005701. DOI 10.2307/2005701. {13} [JT84] William B. Jones and Wolfgang J. Thron. Continued Fractions: Analytic Theory and Applications, volume 11 of Encyclopedia of Mathematics and its Applications. Cambridge University Press, Cambridge, UK, 1984. ISBN 0-521-30231-5; 978-0-521-30231-9. xxviii + 428 pp. LCCN QA295 .J64 1984. {19} [JW91] Kathleen Jensen and Niklaus Wirth. Pascal User Manual and Report: ISO Pascal Standard. Springer-Verlag, Berlin, Germany / Heidel- berg, Germany / London, UK / etc., fourth edition, 1991. ISBN 0-387-97649-3, 3-540-97649-3; 978-0-387-97649-5, 978-3-540-97649-3. xvi + 266 pp. LCCN QA76.73.P2 J46 1991. DOI 10.1007/978-1-4612-4450-9. Revised by Andrew B. Mickel and James F. Miner. {vii, 989} [Kah65] William M. Kahan. Further remarks on reducing truncation errors. Communications of the Association for Computing Machinery, 8(1):40, January 1965. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). DOI 10.1145/363707.363723. {353} [Kah83] William M. Kahan. Minimizing q∗m − n. Technical report, Department of Mathematics and Department of Electrical Engineering and Computer Science, University of California, Berkeley, Berkeley, CA, USA, March 1983. URL http://www.cs.berkeley.edu/~wkahan/ testpi/nearpi.c. This important report discusses the use of continued fractions for finding worst cases for argument reduction. {251, 265} [Kah87] William M. Kahan. Branch cuts for complex elementary functions or much ado about nothing’s sign bit. In A. Iserles and M. J. D. Powell, editors, The State of the Art in Numerical Analysis: Proceedings of the Joint IMA/SIAM Conference on the State of the Art in Numerical Analysis held at the University of Birmingham, 14–18 April 1986, volume 9 of Inst. Math. Appl. Conf. Ser. New Ser., pages 165–211. Oxford University Press, Oxford, UK, 1987. ISBN 0-19-853614-3; 978-0-19-853614-7. LCCN QA297 .S781 1987. {69, 476, 482, 514} [Kah90] William M. Kahan. How Cray’s arithmetic hurts scientific computation (and what might be done about it), June 14, 1990. URL http://754r.ucbtest.org/issues/cray-hurts.pdf. Manuscript prepared for the Cray User Group meeting in Toronto, Canada, April 10, 1990. {953} [Kah04a] William M. Kahan. A logarithm too clever by half. World-Wide Web document, August 9, 2004. URL http://www.cs.berkeley.edu/ ~wkahan/LOG10HAF.TXT. {81, 259} [Kah04b] William M. Kahan. On the cost of floating-point computation without extra-precise arithmetic. World-Wide Web document, November 20, 2004. URL http://www.cs.berkeley.edu/~wkahan/Qdrtcs.pdf. See [Bol09] for a proof of this algorithm for accurate computation of the discriminant needed for the solution of quadratic equations. {472, 1000} [Kap99] Robert Kaplan. The Nothing That Is: A Natural History of Zero. Oxford University Press, Oxford, UK, 1999. ISBN 0-19-512842-7; 978-0-19-512842-0. xii + 225 pp. LCCN QA141 .K36 1999. {59} [Kar85] Richard Karpinski. Paranoia: a floating-point benchmark. Byte Magazine, 10(2):223–235, February 1985. CODEN BYTEDJ. ISSN 0360-5280 (print), 1082-7838 (electronic). {773} [Kat09] Victor J. Katz. A History of Mathematics: An Introduction. Addison-Wesley, Reading, MA, USA, third edition, 2009. ISBN 0-321-38700-7; 978-0-321-38700-4. xvi + 976 pp. LCCN QA21 .K33 2009. {59} [KB67] Donald E. Knuth and Thomas J. Buckholtz. Computation of tangent, Euler, and Bernoulli numbers. Mathematics of Computation,21 (100):663–688, October 1967. CODEN MCMPAF. ISSN 0025-5718 (print), 1088-6842 (electronic). URL http://www.jstor.org/stable/ 2005010. DOI 10.2307/2005010. {574} [KBJ00] Samuel Kotz, N. Balakrishnan, and Norman Lloyd Johnson. Continuous Multivariate Distributions: Volume 1: Models and Applications. Wiley series in probability and statistics. Wiley, New York, NY, USA, second edition, 2000. ISBN 0-471-18387-3 (cloth); 978-0-471- 18387-7 (cloth). xxii + 722 pp. LCCN QA273.6 .K68 2000. {196} [KD98] William M. Kahan and Joseph D. Darcy. How Java’s floating-point hurts everyone everywhere. Technical report, Department of Mathematics and Department of Electrical Engineering and Computer Science, University of California, Berkeley, Berkeley, CA, USA, June 18, 1998. 80 pp. URL http://www.cs.berkeley.edu/~wkahan/JAVAhurt.pdf. {4, 64, 105} [KE97] Aleksandr Yakovlevich Khinchin and Herbert Eagle. Continued Fractions. Dover, New York, NY, USA, 1997. ISBN 0-486-69630-8 (paperback); 978-0-486-69630-0 (paperback). xi + 95 pp. LCCN QA295 .K513 1997. {19} [Ker81] Brian W. Kernighan. Why Pascal is not my favorite programming language. Computer Science Report 100, AT&T Bell Laboratories, Murray Hill, NJ, USA, July 1981. URL http://cm.bell-labs.com/cm/cs/cstr/100.ps.gz. Published in [Ker84]. See also [WSH77]. {989, 1018, 1037} [Ker84] Brian W. Kernighan. Why Pascal is not my favorite programming language. In Alan R. Feuer and Narain Gehani, editors, Comparing and Assessing Programming Languages: Ada, C, and Pascal, Prentice-Hall software series, pages 170–186. Prentice-Hall, Upper Saddle River, NJ, USA, 1984. ISBN 0-13-154840-9 (paperback), 0-13-154857-3 (hardcover); 978-0-13-154840-4 (paperback), 978-0-13-154857-2 (hardcover). LCCN QA76.73.A35 C66 1984. See also [WSH77, Ker81]. {1018, 1037} Bibliography 1019

[KGD13] Edin Kadric, Paul Gurniak, and André DeHon. Accurate parallel floating-point accumulation. In IEEE [IEE13], pages 153–162. ISBN 0-7695-4957-8; 978-0-7695-4957-6. ISSN 1063-6889. LCCN QA76.9.C62 S95 2013. DOI 10.1109/ARITH.2013.19. {385} [KGD16] Edin Kadric, Paul Gurniak, and André DeHon. Accurate parallel floating-point accumulation. IEEE Transactions on Computers, 65(11): 3224–3238, November 2016. CODEN ITCOB4. ISSN 0018-9340 (print), 1557-9956 (electronic). DOI 10.1109/TC.2016.2532874. {385} [KH92] Gerry Kane and Joe Heinrich. MIPS RISC Architecture. Prentice-Hall, Upper Saddle River, NJ, USA, 1992. ISBN 0-13-590472-2; 978-0- 13-590472-5. LCCN QA76.8.M52 K37 1992. {73, 146} [Khr08] Sergey V. Khrushchev. Orthogonal Polynomials and Continued Fractions: from Euler’s Point of View, volume 122 of Encyclopedia of Math- ematics and its Applications. Cambridge University Press, Cambridge, UK, 2008. ISBN 0-521-85419-9 (hardcover); 978-0-521-85419-1 (hardcover). xvi + 478 pp. LCCN QA404.5 .K47 2008. {19, 59} [Kin21] Louis Vessot King. On some new formulae for the numerical calculation of the mutual induction of coaxial circles. Proceedings of the Royal Society of London. Series A, Containing Papers of a Mathematical and Physical Character, 100(702):60–66, October 4, 1921. ISSN 0950- 1207 (print), 2053-9150 (electronic). URL http://www.jstor.org/stable/93861. DOI 10.1098/rspa.1921.0070. This is the first known publication of the AGM method, discovered by the author in 1913, for computing Jacobian elliptic functions. See also [Kin24, Kin07]. {663} [Kin24] Louis Vessot King. On the Direct Numerical Calculation of Elliptic Functions and Integrals. Cambridge University Press, Cambridge, UK, 1924. viii + 42 pp. LCCN QA343. {663, 1019} [Kin07] Louis Vessot King. On the Direct Numerical Calculation of Elliptic Functions and Integrals. Mellon Press, 2007. ISBN 1-4067-4226-0; 978-1-4067-4226-8. 56 pp. {663, 1019} [KIR+07] Victor J. Katz, Annette Imhausen, Eleanor Robson, Joseph W. Dauben, Kim Plofker, and J. Lennart Berggren, editors. The Mathematics of Egypt, Mesopotamia, China, India, and Islam: a Sourcebook. Princeton University Press, Princeton, NJ, USA, 2007. ISBN 0-691-11485-4 (hardcover); 978-0-691-11485-9 (hardcover). xiv + 685 pp. LCCN QA22 .M3735 2007. {59} [KK67] Melvin Klerer and Granino A. Korn, editors. Digital Computer User’s Handbook. McGraw-Hill, New York, NY, USA, 1967. LCCN QA76.5 .K524. {947, 978} [KL85] William M. Kahan and E. LeBlanc. Anomalies in the IBM ACRITH package. In Kai Hwang, editor, Proceedings: 7th Symposium on Computer Arithmetic, June 4–6, 1985, University of Illinois, Urbana, Illinois, pages 322–331. IEEE Computer Society Press, Silver Spring, MD, USA, 1985. ISBN 0-8186-0632-0 (paperback), 0-8186-8632-4 (hard), 0-8186-4632-2 (microfiche); 978-0-8186-0632-8 (paperback), 978-0-8186-8632-0 (hard), 978-0-8186-4632-4 (microfiche). LCCN QA76.9.C62 S95 1985. DOI 10.1109/ARITH.1985.6158956. IEEE catalog number 85CH2146-9. IEEE Computer Society order number 632. {967} [Kla05] Robert Klarer. Decimal types for C++: Second draft. Report C22/WG21/N1839 J16/05-0099, IBM Canada, Ltd., Toronto, ON, Canada, June 24, 2005. URL http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1839.html. {109, 875, 928} [KLL+10] Peter Kornerup, Christoph Lauter, Vincent Lefèvre, Nicolas Louvet, and Jean-Michel Muller. Computing correctly rounded integer powers in floating-point arithmetic. ACM Transactions on Mathematical Software, 37(1):4:1–4:23, January 2010. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/1644001.1644005. {28, 420} [KLLM12] Peter Kornerup, Vincent Lefèvre, Nicolas Louvet, and Jean-Michel Muller. On the computation of correctly rounded sums. IEEE Transactions on Computers, 61(3):289–298, March 2012. CODEN ITCOB4. ISSN 0018-9340 (print), 1557-9956 (electronic). DOI 10.1109/ TC.2011.27. {385} [KM91] Peter Kornerup and David W. Matula, editors. Proceedings: 10th IEEE Symposium on Computer Arithmetic: June 26–28, 1991, Greno- ble, France. IEEE Computer Society Press, Silver Spring, MD, USA, 1991. ISBN 0-8186-9151-4 (case), 0-8186-6151-8 (microfiche), 0- 7803-0187-0 (library binding); 978-0-8186-9151-5 (case), 978-0-8186-6151-8 (microfiche), 978-0-7803-0187-0 (library binding). LCCN QA76.9.C62 S95 1991. IEEE catalog number 91CH3015-5. {1002, 1019, 1025, 1028} [KM95] Simon Knowles and William H. McAllister, editors. Proceedings of the 12th Symposium on Computer Arithmetic, July 19–21, 1995, Bath, England. IEEE Computer Society Press, Silver Spring, MD, USA, 1995. ISBN 0-8186-7089-4 (paperback), 0-8186-7089-4 (case), 0-8186- 7149-1 (microfiche), 0-8186-7089-4 (softbound), 0-7803-2949-X (casebound); 978-0-8186-7089-3 (paperback), 978-0-8186-7089-3 (case), 978-0-8186-7149-4 (microfiche), 978-0-8186-7089-3 (softbound), 978-0-7803-2949-2 (casebound). LCCN QA 76.9 C62 S95 1995. {1009, 1021} [KM07] Peter Kornerup and Jean-Michel Muller, editors. Proceedings of the 18th IEEE Symposium on Computer Arithmetic, June 25–27, 2007, Montpellier, France. IEEE Computer Society Press, Silver Spring, MD, USA, 2007. ISBN 0-7695-2854-6; 978-0-7695-2854-0. ISSN 1063- 6889. LCCN QA76.9.C62. URL http://www.lirmm.fr/arith18/. {1000, 1002, 1015, 1022, 1035} [KM10] Peter Kornerup and David W. Matula. Finite Precision Number Systems and Arithmetic, volume 133 of Encyclopedia of Mathematics and its Applications. Cambridge University Press, Cambridge, UK, 2010. ISBN 0-521-76135-2 (hardcover); 978-0-521-76135-2 (hardcover). xv + 699 pp. LCCN QA248 .K627 2010. {978} [KMN89] David Kahaner, Cleve B. Moler, and Stephen Nash. Numerical Methods and Software. Prentice-Hall, Upper Saddle River, NJ, USA, 1989. ISBN 0-13-627258-4; 978-0-13-627258-8. xii + 495 pp. LCCN TA345 .K341 1989. {202, 299} [Kna92] Anthony W. Knapp. Elliptic Curves, volume 40 of Mathematical notes. Princeton University Press, Princeton, NJ, USA, 1992. ISBN 0-691-08559-5 (paperback); 978-0-691-08559-3 (paperback). xv + 427 pp. LCCN QA567.2.E44 K53 1992. {222} [Knö91] A. Knöfel. Fast hardware units for the computation of accurate dot products. In Kornerup and Matula [KM91], pages 70–74. ISBN 0-8186-9151-4 (case), 0-8186-6151-8 (microfiche), 0-7803-0187-0 (library binding); 978-0-8186-9151-5 (case), 978-0-8186-6151-8 (microfiche), 978-0-7803-0187-0 (library binding). LCCN QA76.9.C62 S95 1991. DOI 10.1109/ARITH.1991.145536. IEEE catalog number 91CH3015-5. {385} 1020 Bibliography

[Knu74] Donald E. Knuth. Structured programming with go to statements. ACM Computing Surveys, 6(4):261–301, December 1974. CODEN CMSVAN. ISSN 0360-0300 (print), 1557-7341 (electronic). DOI 10.1145/356635.356640. Reprinted with revisions in Current Trends in Programming Methodology, Raymond T. Yeh, ed., 1 (Englewood Cliffs, NJ: Prentice-Hall, 1977), 140–194; Classics in Software Engineering, Edward Nash Yourdon, ed. (New York: Yourdon Press, 1979), 259–321. Reprinted with “final” revisions in [Knu92, pp. 17–89]. This paper is a response to [Dij68]. {1007} [Knu85] Donald E. Knuth. Deciphering a linear congruential encryption. IEEE Transactions on Information Theory, IT-31(1):49–52, January 1985. CODEN IETTAW. ISSN 0018-9448 (print), 1557-9654 (electronic). DOI 10.1109/TIT.1985.1056997. Russian translation, to appear. {207} [Knu90] Donald E. Knuth. A simple program whose proof isn’t. In Feijen et al. [FvGM90], chapter 27, pages 233–242. ISBN 0-387-97299-4; 978-0-387-97299-2. LCCN QA76 .B326 1990. DOI 10.1007/978-1-4612-4476-9_28. This paper discusses the algorithm used in TEX for converting between decimal and scaled fixed-point binary values, and for guaranteeing a minimum number of digits in the decimal representation. See also [Cli90, Cli04] for decimal to binary conversion, [SW90, SW04] for binary to decimal conversion, and [Gri90] for an alternate proof of Knuth’s algorithm. {895, 995, 1004, 1011, 1013, 1034} [Knu92] Donald E. Knuth. Literate Programming. CSLI Lecture Notes Number 27. Stanford University Center for the Study of Language and Information, Stanford, CA, USA, 1992. ISBN 0-937073-80-6 (paperback), 0-937073-81-4 (hardcover); 978-0-937073-80-3 (paperback), 978-0-937073-81-0 (hardcover). xiii + 368 pp. LCCN QA76.6 .K644 1992. {1020} [Knu97] Donald E. Knuth. Seminumerical Algorithms, volume 2 of The Art of Computer Programming. Addison-Wesley, Reading, MA, USA, third edition, 1997. ISBN 0-201-89684-2; 978-0-201-89684-8. xiii + 762 pp. LCCN QA76.6 .K64 1997. {89, 170, 182, 184, 186, 188, 200, 214, 366, 416} [Knu99] Donald E. Knuth. MMIXware: a RISC computer for the third millennium, volume 1750 of Lecture Notes in Computer Science. Springer-Ver- lag, Berlin, Germany / Heidelberg, Germany / London, UK / etc., 1999. ISBN 3-540-66938-8 (softcover); 978-3-540-66938-8 (softcover). ISSN 0302-9743 (print), 1611-3349 (electronic). viii + 550 pp. LCCN QA76.9.A73 K62 1999. DOI 10.1007/3-540-46611-8. {104} [Kod07] Masao Kodama. Remark on Algorithm 644. ACM Transactions on Mathematical Software, 33(4):28:1–28:3, August 2007. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/1268776.1268783. See [Amo86, Amo90, Amo95]. {693, 996} [Kod08] Masao Kodama. Algorithm 877: A subroutine package for cylindrical functions of complex order and nonnegative argument. ACM Transactions on Mathematical Software, 34(4):22:1–22:21, July 2008. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/1377596.1377602. {693} [Kor02] Israel Koren. Computer Arithmetic Algorithms. A. K. Peters, Wellesley, MA, USA, second edition, 2002. ISBN 1-56881-160-8; 978-1- 56881-160-4. xv + 281 pp. LCCN QA76.9.C62 K67. {68, 881, 978} [KP99] Brian W. Kernighan and Rob Pike. The Practice of Programming. Addison-Wesley, Reading, MA, USA, 1999. ISBN 0-201-61586-X; 978-0- 201-61586-9. xii + 267 pp. LCCN QA76.6 .K48 1999. URL http://cm.bell-labs.com/cm/cs/tpop/code.html; http://tpop.awl.com. {6} [Kra14] Ilia Krasikov. Approximations for the Bessel and Airy functions with an explicit error term. LMS Journal of Computation and Mathemat- ics, 17(1):209–225, 2014. ISSN 1461-1570. DOI 10.1112/S1461157013000351. {693} [Kro10] Kirk L. Kroeker. News: Celebrating the legacy of PLATO. Communications of the Association for Computing Machinery, 53(8):19–20, August 2010. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). DOI 10.1145/1787234.1787261. The PLATO system on time-shared CDC mainframes was the first major effort at developing online courseware. {949} [KSS95] Marek A. Kowalski, Krzysztof A. Sikorski, and Frank Stenger. Selected Topics in Approximation and Computation. Oxford University Press, Oxford, UK, 1995. ISBN 0-19-508059-9; 978-0-19-508059-9. xiv + 349 pp. URL http://site.ebrary.com/lib/utah/Doc?id= 10087215. {733} [KT99] Eugene Eric Kim and Betty Alexandra Toole. Ada and the first computer: The collaboration between ada, countess of lovelace, and computer pioneer Charles Babbage resulted in a landmark publication that described how to program the world’s first computer. Scientific American, 280(5):76–81, May 1999. CODEN SCAMAC. ISSN 0036-8733 (print), 1946-7087 (electronic). URL http://www.nature.com/scientificamerican/journal/v280/n5/pdf/scientificamerican0599-76.pdf. DOI 10.1038/ scientificamerican0599-76. {568} [Kul13] Ulrich Kulisch. Computer Arithmetic and Validity, volume 33 of De Gruyter studies in mathematics. Walter de Gruyter, Berlin, Germany, second edition, 2013. ISBN 3-11-030173-3, 3-11-030179-2 (e-book), 3-11-030180-6 (set); 978-3-11-030173-1, 978-3-11-030179-3 (e-book), 978-3-11-030180-9 (set). ISSN 0179-0986. xxii + 434 pp. LCCN QA76.9.C62 K853 2013. DOI 10.1515/9783110301793. {978} [KW96] Chiang Kao and J. Y. Wong. An exhaustive analysis of prime modulus multiplicative congruential random number generators with modulus smaller than 215. Journal of Statistical Computation and Simulation, 54(1–3):29–35, 1996. CODEN JSCSAJ. ISSN 0094-9655 (print), 1026-7778 (electronic), 1563-5163. URL http://www.tandfonline.com/doi/abs/10.1080/00949659608811717. DOI 10.1080/ 00949659608811717. {170} [Lan64] Cornelius Lanczos. A precision approximation of the gamma function. Journal of the Society for Industrial and Applied Mathematics: Series B, Numerical Analysis, 1(1):86–96, 1964. ISSN 0887-459X (print), 1095-7170 (electronic). URL http://www.jstor.org/stable/2949767. DOI 10.1137/0701008. {521, 536} [Lan87] Eberhard Lange. Implementation and test of the ACRITH facility in a System/370. IEEE Transactions on Computers, C-36(9):1088– 1096, September 1987. CODEN ITCOB4. ISSN 0018-9340 (print), 1557-9956 (electronic). URL http://ieeexplore.ieee.org/stamp/ stamp.jsp?tp=&arnumber=5009539. DOI 10.1109/TC.1987.5009539. {967} [Lap08] Michel L. Lapidus. In Search of the Riemann Zeros: Strings, Fractal Membranes and Noncommutative Spacetimes. American Mathematical Society, Providence, RI, USA, 2008. ISBN 0-8218-4222-6; 978-0-8218-4222-5. xxix + 558 pp. LCCN QA333 .L37 2008. {303, 521, 579} Bibliography 1021

[LAS+95] Tom Lynch, Ahmed Ahmed, Michael J. Schulte, Tom Callaway, and Robert Tisdale. The K5 transcendental functions. In Knowles and McAllister [KM95], pages 163–171. ISBN 0-8186-7089-4 (paperback), 0-8186-7089-4 (case), 0-8186-7149-1 (microfiche), 0-8186-7089- 4 (softbound), 0-7803-2949-X (casebound); 978-0-8186-7089-3 (paperback), 978-0-8186-7089-3 (case), 978-0-8186-7149-4 (microfiche), 978-0-8186-7089-3 (softbound), 978-0-7803-2949-2 (casebound). LCCN QA 76.9 C62 S95 1995. URL http://mesa.ece.wisc.edu/ publications/cp_1995-04.pdf; http://www.acsel-lab.com/arithmetic/arith12/papers/ARITH12_Lynch.pdf. DOI 10.1109/ ARITH.1995.465368. The K5 is one of AMD’s IA-32-compatible microprocessors. {293} [Lau08] Detleff Laugwitz. Bernhard Riemann 1826–1866: Turning Points in the Conception of Mathematics. Modern Birkhäuser classics. Birkhäuser Boston Inc., Cambridge, MA, USA, 2008. ISBN 0-8176-4776-7 (paperback), 0-8176-4777-5; 978-0-8176-4776-6 (paperback), 978-0-8176- 4777-3. xvi + 357 pp. LCCN QA29 R425 L3813 2008. URL http://www.gbv.de/dms/bowker/toc/9780817647766. DOI 10.1007/ 978-0-8176-4777-3. Translated by Abe Shenitzer from the 1996 German original, Bernhard Riemann 1826–1866: Wendepunkte in der Auffassung der Mathematik. {579, 590} [Law89] Derek F. Lawden. Elliptic Functions and Applications, volume 80 of Applied mathematical sciences. Springer-Verlag, Berlin, Germany / Heidelberg, Germany / London, UK / etc., 1989. ISBN 0-387-96965-9; 978-0-387-96965-7. xiv + 334 pp. LCCN QA1 .A647 vol. 80; QA343. DOI 10.1007/978-1-4757-3980-0. {619, 627, 654, 682, 688} [Law06] Averill M. Law. Simulation Modeling and Analysis. McGraw-Hill series in industrial engineering and management science. McGraw- Hill, New York, NY, USA, fourth edition, 2006. ISBN 0-07-298843-6 (hardcover), 0-07-125519-2 (paperback), 0-07-329441-1, 0-07- 110336-8, 0-07-110051-2; 978-0-07-298843-7 (hardcover), 978-0-07-125519-6 (paperback), 978-0-07-329441-4, 978-0-07-110336-7, 978-0- 07-110051-9. xix + 768 pp. LCCN QA76.9.C65 L38 2005. {196} [LB92] J. Lund and K. L. Bowers. Sinc Methods for Quadrature and Differential Equations. SIAM (Society for Industrial and Applied Mathemat- ics), Philadelphia, PA, USA, 1992. ISBN 0-89871-298-X; 978-0-89871-298-8. x + 304 pp. LCCN QA372 .L86 1992. {733} [LBC93] Pierre L’Ecuyer, François Blouin, and Raymond Couture. A search for good multiple recursive random number generators. ACM Transactions on Modeling and Computer Simulation, 3(2):87–98, April 1993. CODEN ATMCEZ. ISSN 1049-3301 (print), 1558-1195 (electronic). DOI 10.1145/169702.169698. {170} [LCM16] Cedric Lichtenau, Steven Carlough, and Silvia Melitta Mueller. Quad precision floating point on the IBM z13. In Montuschi et al. [MSH+16], pages 87–94. ISBN 1-5090-1615-5; 978-1-5090-1615-0. ISSN 1063-6889. LCCN QA76.9.C62 S95 2016. URL http://ieeexplore.ieee.org/servlet/opac?punumber=7562813. DOI 10.1109/ARITH.2016.26. {928} [LDB+00] Xiaoye S. Li, James W. Demmel, David H. Bailey, Greg Henry, Yozo Hida, J. Iskandar, William M. Kahan, Anil Kapur, M. C. Mar- tin, T. Tung, and D. J. Yoo. Design, implementation and testing of extended and mixed precision BLAS. LAPACK Working Note 149, Department of Computer Science, University of Tennessee, Knoxville, Knoxville, TN 37996, USA, October 2000. URL http://www.netlib.org/lapack/lawnspdf/lawn149.pdf. Appendix B contains an improved version of Smith’s algorithm for complex division [Smi62], using scaling to avoid premature overflow and underflow. {452, 1032} [LE80] Henry M. Levy and Richard H. Eckhouse, Jr. Computer Programming and Architecture—the VAX-11. Digital Press, Bedford, MA, USA, 1980. ISBN 0-932376-07-X; 978-0-932376-07-7. xxi + 407 pp. LCCN QA76.8 .V37 L48 1980. {956} [L’E96] Pierre L’Ecuyer. Maximally equidistributed combined Tausworthe generators. Mathematics of Computation, 65(213):203–213, January 1996. CODEN MCMPAF. ISSN 0025-5718 (print), 1088-6842 (electronic). URL http://www.ams.org/jourcgi/jour-pbprocess?fn= 110&arg1=S0025-5718-96-00696-5&u=/mcom/1996-65-213/. DOI 10.1090/S0025-5718-96-00696-5. {177} [L’E98] Pierre L’Ecuyer. Random number generation. In Banks [Ban98], chapter 4, pages 93–137. ISBN 0-471-13403-1 (hardcover); 978-0-471- 13403-9 (hardcover). LCCN T57.62 .H37 1998. DOI 10.1002/9780470172445.ch4. {196} [Lef05] Vincent Lefèvre. New results on the distance between a segment and Z2. Application to the exact rounding. In Montuschi and Schwarz [MS05], pages 68–75. ISBN 0-7695-2366-8; 978-0-7695-2366-8. LCCN QA76.9.C62 .S95 2005. URL http://arith17.polito.it/final/ paper-147.pdf. DOI 10.1109/ARITH.2005.32. {28} [Lef16] Vincent Lefèvre. Correctly rounded arbitrary-precision floating-point summation. In Montuschi et al. [MSH+16], pages 71–78. ISBN 1-5090-1615-5; 978-1-5090-1615-0. ISSN 1063-6889. LCCN QA76.9.C62 S95 2016. URL http://ieeexplore.ieee.org/servlet/opac? punumber=7562813. DOI 10.1109/ARITH.2016.9. {385} [Leh51] D. H. Lehmer. Mathematical methods in large-scale computing units. In Anonymous, editor, Proceedings of a Second Symposium on Large-Scale Digital Calculating Machinery, Harvard University Computation Laboratory, 13–16 September 1949, volume 26 of Annals of the Computation Laboratory of Harvard University, pages 141–146. Harvard University Press, Cambridge, MA, USA, 1951. LCCN QA75 .S9 1949. URL http://archive.org/stream/proceedings_of_a_second_symposium_on_large-scale_/Proceedings_of_a_Second_ Symposium_on_Large-Scale_Digital_Calculating_Machinery_Sep49_djvu.txt. {169} [Lev09] Thomas Levenson. Newton and the Counterfeiter: the Unknown Detective Career of the World’s Greatest Scientist. Houghton Mifflin Harcourt, Boston, MA, USA, 2009. ISBN 0-15-101278-4; 978-0-15-101278-7. xii + 318 pp. LCCN Q143.N495 L48 2009. {8} [Lew75] John Gregg Lewis. Certification of “Algorithm 349: Polygamma functions with arbitrary precision”. ACM Transactions on Mathematical Software, 1(4):380–381, December 1975. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/355656.355664. See [TS69]. {1035} [LHKK79] Charles L. Lawson, Richard J. Hanson, David R. Kincaid, and Fred T. Krogh. Basic Linear Algebra Subprograms for Fortran usage. ACM Transactions on Mathematical Software, 5(3):308–323, September 1979. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/355841.355847. {223} [Lia99] Sheng Liang. Java Native Interface: Programmer’s Guide and Specification. Addison-Wesley, Reading, MA, USA, 1999. ISBN 0-201-32577-2; 978-0-201-32577-5. xiv + 303 pp. LCCN QA76.38 .L53 1999. {979, 983} 1022 Bibliography

[Lin81] Seppo Linnainmaa. Software for doubled-precision floating-point computations. ACM Transactions on Mathematical Software, 7(3): 272–283, September 1981. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/355958.355960. {370} [Lin89] Jinn Tyan Lin. Approximating the normal tail probability and its inverse for use on a pocket calculator. Applied Statistics, 38(1): 69–70, 1989. CODEN APSTAG. ISSN 0035-9254 (print), 1467-9876 (electronic). URL http://www.jstor.org/stable/2347681. DOI 10.2307/2347681. {618} [Lin90] Jinn Tyan Lin. Miscellanea: A simpler logistic approximation to the normal tail probability and its inverse. Applied Statistics, 39(2): 255–257, 1990. CODEN APSTAG. ISSN 0035-9254 (print), 1467-9876 (electronic). URL http://www.jstor.org/stable/2347764. DOI 10.2307/2347764. {618} [Lio96] John Lions. Lions’ Commentary on UNIX 6th Edition, with Source Code. Computer classics revisited. Peer-to-Peer Communications, San Jose, CA 95164-0218, USA, 1996. ISBN 1-57398-013-7; 978-1-57398-013-5. 254 pp. URL http://www.peer-to-peer.com/catalog/ opsrc/lions.html. With forewords by Dennis M. Ritchie and Ken Thompson. Prefatory notes by Peter H. Salus and Michael Tilson; a historical note by Peter H. Salus; and appreciations by Greg Rose, Mike O’Dell, Berny Goodheart, Peter Collinson, and Peter Reintjes. Originally circulated as two restricted-release volumes: “UNIX Operating System Source Code Level Six”, and “A Commentary on the UNIX Operating System”. This document was the first published detailed analysis of the entire source code of an operating-system kernel. {850} [Liu87] Zhi-Shun Alex Liu. Berkeley elementary function test suite: Research project. Master of Science, Plan II, Computer Science Division, Department of Electrical Engineering and Computer Science, Univerity of California at Berkeley, Berkeley, CA, USA, December 1987. {774} [Liu88] Zhi-Shun Alex Liu. Berkeley elementary function test suite. Technical report, Computer Science Division, Department of Electrical Engineering and Computer Science, Univerity of California at Berkeley, Berkeley, CA, USA, December 30, 1988. ii + 59 pp. URL http://www.netlib.org/fp/ucbtest.tgz; http://www.ucbtest.org/zaliu-papers/zaliu-beef-doc.pdf. {774} [Liv02] Mario Livio. The Golden Ratio: The Story of Phi, the World’s Most Astonishing Number. Broadway Books,√ New York, NY, USA, 2002. ISBN φ = 1 ( + ) ≈ 0-7679-0815-5; 978-0-7679-0815-3. viii + 294 pp. LCCN QA466 .L58 2002. The golden ratio is 2 5 1 1.618. It is the last of the big five mathematical constants: e, i, π, γ, and φ. {8, 14, 59, 577} [Liv05] Mario Livio. The Equation that Couldn’t be Solved: How Mathematical Genius Discovered the Language of Symmetry. Simon and Schuster, New York, NY, USA, 2005. ISBN 0-7432-5820-7; 978-0-7432-5820-3. x + 353 pp. LCCN QA174.2 .L58 2005. {7} [LL73] G. P. Learmonth and P. A. W. Lewis. Naval Postgraduate School random number generator package LLRANDOM. Report NP555LW73061A, Naval Postgraduate School, Monterey, CA, USA, 1973. The shuffling algorithm proposed in this report does not lengthen the period, and only marginally reduces the lattice structure of linear congruential generators, despite the apparently tiny difference with the [BD76] algorithm: see [Bay90] for a comparison, both mathematical, and graphical. {179, 997, 998} [LL01] Eli Levin and Doran S. Lubinsky. Orthogonal Polynomials for Exponential Weights, volume 4 of CMS books in mathematics. Springer-Verlag, Berlin, Germany / Heidelberg, Germany / London, UK / etc., 2001. ISBN 0-387-98941-2 (hardcover); 978-0-387-98941-9 (hardcover). xi + 476 pp. LCCN QA404.5 .L48 2001. DOI 10.1007/978-1-4613-0201-8. {59} [LL07] Philippe Langlois and Nicolas Louvet. How to ensure a faithful polynomial evaluation with the compensated Horner algorithm. In Kornerup and Muller [KM07], pages 141–149. ISBN 0-7695-2854-6; 978-0-7695-2854-0. ISSN 1063-6889. LCCN QA76.9.C62. URL http://www.lirmm.fr/arith18/. DOI 10.1109/ARITH.2007.21. {89} [LM01] Vincent Lefèvre and Jean-Michel Muller. Worst cases for correct rounding of the elementary functions in double precision. In N. Burgess and L. Ciminiera, editors, 15th IEEE Symposium on Computer Arithmetic: ARITH-15 2001: proceedings: Vail, Colorado, 11–13 June, 2001, pages 111–118. IEEE Computer Society Press, Silver Spring, MD, USA, 2001. ISBN 0-7695-1150-3; 0-7695-1152-X; 978-0- 7695-1150-4; 978-0-7695-1152-8. ISSN 1063-6889. LCCN QA76.9.C62 S95 2001. DOI 10.1109/ARITH.2001.930110. IEEE order number PR01150. {28} [LM03a] Vincent Lefèvre and Jean-Michel Muller. The Table Maker’s Dilemma: our search for worst cases. World-Wide Web software project archive, October 28, 2003. URL http://perso.ens-lyon.fr/jean-michel.muller/Intro-to-TMD.htm. {28} [LM03b] Vincent Lefèvre and Jean-Michel Muller. Worst cases for correct rounding for the elementary functions in double precision. Technical report, INRIA, Projet Spaces, LORIA, Campus Scientifique, B.P. 239, 54506 Vandoeuvre-lès-Nancy Cedex, France, August 14, 2003. URL http://perso.ens-lyon.fr/jean-michel.muller/TMDworstcases.pdf. {28} [LM08] Lawrence M. Leemis and Jacquelyn T. McQueston. Univariate distribution relationships. The American Statistician, 62(1):45–53, Febru- ary 2008. CODEN ASTAAJ. ISSN 0003-1305 (print), 1537-2731 (electronic). URL http://www.ingentaconnect.com/content/asa/tas/ 2008/00000062/00000001/art00008. DOI 10.1198/000313008X270448. {196} [Loi10] Florian Loitsch. Printing floating-point numbers quickly and accurately with integers. ACM SIGPLAN Notices, 45(6):233–243, June 2010. CODEN SINODQ. ISSN 0362-1340 (print), 1523-2867 (print), 1558-1160 (electronic). DOI 10.1145/1809028.1806623. {895} [Loz03] Daniel W. Lozier. NIST Digital Library of Mathematical Functions. Annals of Mathematics and Artificial Intelligence, 38(1–3):105–119, May 2003. CODEN AMAIEC. ISSN 1012-2443 (print), 1573-7470 (electronic). URL http://math.nist.gov/acmd/Staff/DLozier/ publications/Linz01.ps. DOI 10.1023/A:1022915830921. {826} [LS02] Pierre L’Ecuyer and Richard Simard. TestU01: A software library in ANSI C for empirical testing of random number generators: Software user’s guide. Web report, Départment d’Informatique et de Recherche Opérationelle, Université de Montréal, Montréal, Québec, Canada, 2002. URL http://www.iro.umontreal.ca/~simardr/TestU01.zip. {200} [LS07] Pierre L’Ecuyer and Richard Simard. TestU01: A C library for empirical testing of random number generators. ACM Transactions on Mathematical Software, 33(4):22:1–22:40, August 2007. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/1268776.1268777. {170, 178, 200, 214} Bibliography 1023

[LS14] Pierre L’Ecuyer and Richard Simard. On the lattice structure of a special class of multiple recursive random number generators. INFORMS Journal on Computing, 26(3):449–460, 2014. ISSN 1091-9856 (print), 1526-5528 (electronic). DOI 10.1287/ijoc.2013.0576. Analysis and exposure of serious lattice structure in earlier work on fast multiple recursive generators [DX03, Den05, DLS09, DSL12a, DSL12b]. {176} [LSZ06] Vincent Lefèvre, Damien Stehlé, and Paul Zimmermann. Worst cases for the exponential function in the IEEE 754r decimal64 format. Technical report, LORIA/INRIA Lorraine, Villers-lès-Nancy Cedex, France, September 2006. 14 pp. URL http://www.loria.fr/ ~zimmerma/papers/decimalexp-lncs-final.pdf. {28} [Luk69a] Yudell L. Luke. The Special Functions and Their Approximations, volume 53-I of Mathematics in Science and Engineering. Academic Press, New York, NY, USA, 1969. ISBN 0-12-459901-X; 978-0-12-459901-7. xx + 349 pp. LCCN QA351 .L94 1969. URL http:// www.sciencedirect.com/science/book/9780124599017. DOI 10.1016/S0076-5392(08)62628-4. {521, 693, 827} [Luk69b] Yudell L. Luke. The Special Functions and Their Approximations, volume 53-II of Mathematics in Science and Engineering. Aca- demic Press, New York, NY, USA, 1969. ISBN 0-12-459902-8; 978-0-12-459902-4. xx + 485 pp. LCCN QA351 .L797. URL http://www.sciencedirect.com/science/bookseries/00765392/53/part/P2. DOI 10.1016/S0076-5392(09)60064-3. {521, 827} [Luk77] Yudell L. Luke. Algorithms for the Computation of Mathematical Functions. Academic Press, New York, NY, USA, 1977. ISBN 0-12-459940- 0; 978-0-12-459940-6. xiii + 284 pp. LCCN QA351 .L7961. {693, 827} [LW92] Lisa Lorentzen and Haakon Waadeland. Continued Fractions with Applications, volume 3 of Studies in Computational Mathematics. North- Holland, Amsterdam, The Netherlands, 1992. ISBN 0-444-89265-6; 978-0-444-89265-2. xvi + 606 pp. LCCN QA295 .L64 1992. {19} [LW08] Lisa Lorentzen and Haakon Waadeland. Continued Fractions: Convergence Theory, volume 1 of Atlantis Studies in Mathematics for Engineering and Science. Atlantis Press, Amsterdam, The Netherlands, second edition, 2008. ISBN 90-78677-07-4; 978-90-78677-07-9. ISSN 1875-7642. xii + 308 pp. LCCN QA295 .L64 2008. {19} [LY97] Tim Lindholm and Frank Yellin. The Java Virtual Machine Specification. The Java Series. Addison-Wesley, Reading, MA, USA, 1997. ISBN 0-201-63452-X; 978-0-201-63452-5. xvi + 475 pp. LCCN QA76.73.J38L56 1997. URL http://www.aw.com/cp/javaseries.html. {viii, 80, 979} [LY99] Tim Lindholm and Frank Yellin. The Java Virtual Machine Specification. Addison-Wesley, Reading, MA, USA, second edition, 1999. ISBN 0-201-43294-3; 978-0-201-43294-7. xv + 473 pp. LCCN QA76.73.J38L56 1999. {viii, 80, 979} [LYBB13] Tim Lindholm, Frank Yellin, Gilad Bracha, and Alex Buckley. The Java Virtual Machine Specification. Addison-Wesley, Addison-Wes- ley, Java SE 7 edition, 2013. ISBN 0-13-326049-6, 0-13-326044-5; 978-0-13-326049-6, 978-0-13-326044-1. xvii + 587 (est.) pp. LCCN QA76.73.J38 L56 1999. URL http://proquest.tech.safaribooksonline.de/9780133260496. {viii, 979} [LYBB14] Tim Lindholm, Frank Yellin, Gilad Bracha, and Alex Buckley. The Java Virtual Machine Specification: Java SE 8 edition. Addison-Wesley, Addison-Wesley, 2014. ISBN 0-13-390590-X (paperback), 0-13-392274-X (e-book); 978-0-13-390590-8 (paperback), 978-0-13-392274-5 (e-book). xvi + 584 pp. LCCN QA76.73.J38 L56 2014. {viii, 979} [Mac65] M. Donald MacLaren. Algorithm 272: Procedure for the normal distribution functions [S15]. Communications of the Association for Computing Machinery, 8(12):789–790, December 1965. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). DOI 10.1145/ 365691.365957. See remarks [HJ67b, Mac68]. {618, 1015, 1023} [Mac68] M. Donald MacLaren. Remark on Algorithm 272: Procedure for the normal distribution functions. Communications of the Association for Computing Machinery, 11(7):498, July 1968. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). DOI 10.1145/ 363397.363553. See [Mac65]. {618, 1023} [Mac92] N. M. Maclaren. A limit on the usable length of a pseudorandom sequence. Journal of Statistical Computation and Simulation, 42(1–2): 47–54, 1992. CODEN JSCSAJ. ISSN 0094-9655 (print), 1026-7778 (electronic), 1563-5163. URL http://www.tandfonline.com/doi/abs/ 10.1080/00949659208811409. DOI 10.1080/00949659208811409. {180} [Mac98] I. G. Macdonald. Symmetric Functions and Orthogonal Polynomials, volume 12 of University lecture series. American Mathematical Society, Providence, RI, USA, 1998. ISBN 0-8218-0770-6 (softcover); 978-0-8218-0770-5 (softcover). ISSN 1047-3998. xv + 53 pp. LCCN QA212 .M33 1998. {59} [Mal72] M. A. Malcolm. Algorithms to reveal properties of floating-point arithmetic. Communications of the Association for Computing Machinery, 15(11):949–951, November 1972. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). DOI 10.1145/355606.361870. See also [GM74]. {103, 1012} [Mao91] Eli Maor. To Infinity and Beyond: A Cultural History of the Infinite. Princeton paperbacks. Princeton University Press, Princeton, NJ, USA, 1991. ISBN 0-691-02511-8 (paperback); 978-0-691-02511-7 (paperback). xvi + 284 pp. LCCN QA9 .M316 1991. {59} [Mao94] Eli Maor. e: The Story of a Number. Princeton University Press, Princeton, NJ, USA, 1994. ISBN 0-691-03390-0; 978-0-691-03390-7. xiv + 223 pp. LCCN QA247.5.M33 1994. URL http://www-gap.dcs.st-and.ac.uk/~history/HistTopics/e.html. The number e ≈ 2.718 is the base of the natural logarithms, and is one of the big five mathematical constants: e, i, π, γ, and φ. {59, 269} [Mao07] Eli Maor. The Pythagorean Theorem: a 4,000-year History. Princeton University Press, Princeton, NJ, USA, 2007. ISBN 0-691-12526-0; 978-0-691-12526-8. xvi + 259 pp. LCCN QA460.P8 M36 2007. {59} [Mar68] George Marsaglia. Random numbers fall mainly in the planes. Proceedings of the National Academy of Sciences of the United States of America, 61(1):25–28, September 15, 1968. CODEN PNASA6. ISSN 0027-8424 (print), 1091-6490 (electronic). URL http://www.pnas.org/content/61/1/25. This important, and frequently cited, paper was the first to point out the serious problem of correlations in random numbers produced by all congruential generators. {170} [Mar00] Peter Markstein. IA-64 and Elementary Functions: Speed and Precision. Hewlett-Packard professional books. Prentice-Hall, Upper Saddle River, NJ, USA, 2000. ISBN 0-13-018348-2; 978-0-13-018348-4. xix + 298 pp. LCCN QA76.9.A73 M365 2000. URL http:// www.markstein.org/. {86, 87, 101, 241, 242, 410, 412, 824, 827, 940, 953} 1024 Bibliography

[Mar03a] George Marsaglia. Random number generators. Journal of Modern Applied Statistical Methods, 2(1):2–13, May 2003. ISSN 1538- 9472. URL http://stat.fsu.edu/pub/diehard/; http://tbf.coe.wayne.edu/jmasm/; http://www.csis.hku.hk/~diehard/. DOI 10.22237/jmasm/1051747320. {207} [Mar03b] George Marsaglia. Xorshift RNGs. Journal of Statistical Software, 8(14):1–6, 2003. CODEN JSSOBK. ISSN 1548-7660. URL http: //www.jstatsoft.org/v08/i14; http://www.jstatsoft.org/v08/i14/xorshift.pdf. DOI 10.18637/jss.v008.i14. See [Bre04] for corrections and the equivalence of xorshift generators and the well-understood linear feedback shift register generators. See also [SMDS11, SM12, SLF14] for the failure of Marsaglia’s xorwow() generator from this paper. See [PL05, Vig16] for detailed analysis. {176, 1001, 1028} [Mat68a] David W. Matula. The base conversion theorem. Proceedings of the American Mathematical Society, 19(3):716–723, June 1968. CODEN PAMYAR. ISSN 0002-9939 (print), 1088-6826 (electronic). URL http://www.ams.org/journals/proc/1968-019-03/ S0002-9939-1968-0234908-9/S0002-9939-1968-0234908-9.pdf. DOI 10.1090/S0002-9939-1968-0234908-9. {840, 851} [Mat68b] David W. Matula. In-and-out conversions. Communications of the Association for Computing Machinery, 11(1):47–50, January 1968. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). DOI 10.1145/362851.362887. {840, 851} [MBdD+10] Jean-Michel Muller, Nicolas Brisebarre, Florent de Dinechin, Claude-Pierre Jeannerod, Vincent Lefèvre, Guillaume Melquiond, Nathalie Revol, Damien Stehlé, and Serge Torres. Handbook of Floating-Point Arithmetic. Birkhäuser Boston Inc., Cambridge, MA, USA, 2010. ISBN 0-8176-4704-X; 978-0-8176-4704-9. xxiii + 572 pp. LCCN QA76.9.C62 H36 2010. DOI 10.1007/978-0-8176-4704-9. {42, 104, 407, 881, 978} [McC81] Peter McCullagh. A rapidly convergent series for computing ψ(z) and its derivatives. Mathematics of Computation, 36(153):247–248, January 1981. CODEN MCMPAF. ISSN 0025-5718 (print), 1088-6842 (electronic). URL http://www.jstor.org/stable/2007741. DOI 10.2307/2007741. The psi function, ψ(z), is the logarithmic derivative of the gamma function, Γ(z). The higher derivatives are called polygamma functions. {543} [McL85] A. Ian McLeod. Statistical algorithms: Remark AS R58: a remark on Algorithm AS 183. an efﬁcient and portable pseudo-random number generator. Applied Statistics, 34(2):198–200, 1985. CODEN APSTAG. ISSN 0035-9254 (print), 1467-9876 (electronic). URL http://lib.stat.cmu.edu/apstat/183. DOI 10.2307/2347378. See [WH82, Zei86]. {1037} [McL91] John McLeish. The Story of Numbers: How Mathematics has Shaped Civilization. Fawcett Columbine, New York, NY, USA, 1991. ISBN 0-449-90938-7; 978-0-449-90938-6. 266 + 8 pp. LCCN QA21.M38 1991. {59} [MF53] Philip McCord Morse and Herman Feshbach. Methods of Theoretical Physics. International series in pure and applied physics. McGraw- Hill, New York, NY, USA, 1953. ISBN 0-07-043316-X (vol. 1), 0-07-043317-8 (vol. 2); 978-0-07-043316-8 (vol. 1), 978-0-07-043317-5 (vol. 2). xxii + 997 (vol. 1), xviii + 1978 (vol. 2) pp. LCCN QC20 .M6 1999. {693} [MH72] Tohru Morita and Tsuyoshi Horiguchi. Convergence of the arithmetic-geometric mean procedure for the complex variables and the calculation of the complete elliptic integrals with complex modulus. Numerische Mathematik, 20(5):425–430, October 1972. CODEN NUMMA7. ISSN 0029-599X (print), 0945-3245 (electronic). URL http://www.springerlink.com/openurl.asp?genre=article&issn= 0029-599X&volume=20&issue=5&spage=425. DOI 10.1007/BF01402565. {632} [MH80] Jerry B. Marion and Mark A. Heald. Classical Electromagnetic Radiation. Academic Press, New York, NY, USA, second edition, 1980. ISBN 0-12-472257-1; 978-0-12-472257-6. xvii + 488 pp. LCCN QC661 .M38 1980. {693} [MH03] J. C. Mason and D. C. Handscomb. Chebyshev Polynomials. Chapman and Hall/CRC, Boca Raton, FL, USA, 2003. ISBN 0-8493-0355-9; 978-0-8493-0355-5. xiii + 341 pp. LCCN QA404.5 .M37 2003. {58} [MH08] A. M. Mathai and H. J. Haubold. Special Functions for Applied Scientists. Springer Science + Business Media, New York, NY, USA, 2008. ISBN 0-387-75893-3; 978-0-387-75893-0. xxv + 464 pp. LCCN QA351.M37; QA351.M37 2008. DOI 10.1007/978-0-387-75894-7. {827} [MH16] Jamshaid Sarwar Malik and Ahmed Hemani. Gaussian random number generation: a survey on hardware architectures. ACM Computing Surveys, 49(3):53:1–53:37, November 2016. CODEN CMSVAN. ISSN 0360-0300 (print), 1557-7341 (electronic). DOI 10.1145/ 2980052. {196} [Mis10] Thomas J. Misa. An interview with Edsger W. Dijkstra. Communications of the Association for Computing Machinery, 53(8):41–47, August 2010. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). DOI 10.1145/1787234.1787249. {962} [ML15] George Michelogiannakis and Xiaoye S. Li. Extending summation precision for network reduction operations. International Journal of Parallel Programming, 43(6):1218–1243, December 2015. CODEN IJPPE5. ISSN 0885-7458 (print), 1573-7640 (electronic). URL http:// link.springer.com/article/10.1007/s10766-014-0326-5. DOI 10.1007/s10766-014-0326-5. {385} [MM65] M. Donald MacLaren and George Marsaglia. Uniform random number generators. Journal of the Association for Computing Machinery, 12(1):83–89, January 1965. CODEN JACOAH. ISSN 0004-5411 (print), 1557-735X (electronic). DOI 10.1145/321250.321257. {179} [MM83] Cleve B. Moler and Donald Morrison. Replacing square roots by Pythagorean sums. IBM Journal of Research and Development,27 (6):577–581, November 1983. CODEN IBMJAE. ISSN 0018-8646 (print), 2151-8556 (electronic). URL http://ieeexplore.ieee.org/ stamp/stamp.jsp?tp=&arnumber=5390405. DOI 10.1147/rd.276.0577. See [Dub83] and generalization [Jam89]. {227, 1008, 1017} [MN98] Makoto Matsumoto and Takuji Nishimura. Mersenne twister: a 623-dimensionally equidistributed uniform pseudo-random number generator. ACM Transactions on Modeling and Computer Simulation, 8(1):3–30, January 1998. CODEN ATMCEZ. ISSN 1049-3301 (print), 1558-1195 (electronic). DOI 10.1145/272991.272995. {177} [MNZ90] George Marsaglia, B. Narasimhan, and Arif Zaman. A random number generator for PC’s. Computer Physics Communications, 60(3): 345–349, October 1990. CODEN CPHCBZ. ISSN 0010-4655 (print), 1879-2944 (electronic). URL http://www.sciencedirect.com/ science/article/pii/001046559090033W. DOI 10.1016/0010-4655(90)90033-W. {177} Bibliography 1025

[Møl65a] Ole Møller. Note on quasi double-precision. Nordisk Tidskrift for Informationsbehandling, 5(4):251–255, December 1965. CODEN BITTEL, NBITAB. ISSN 0006-3835 (print), 1572-9125 (electronic). URL http://www.springerlink.com/openurl.asp?genre=article&issn= 0006-3835&volume=5&issue=4&spage=251. DOI 10.1007/BF01937505. See [Møl65b]. {1025} [Møl65b] Ole Møller. Quasi double-precision in floating point addition. Nordisk Tidskrift for Informationsbehandling, 5(1):37–50, March 1965. CODEN BITTEL, NBITAB. ISSN 0006-3835 (print), 1572-9125 (electronic). URL http://www.springerlink.com/openurl.asp?genre= article&issn=0006-3835&volume=5&issue=1&spage=37. DOI 10.1007/BF01975722. See also [Møl65a]. {353, 1025} [Mos89] Stephen L. B. Moshier. Methods and Programs for Mathematical Functions. Ellis Horwood, New York, NY, USA, 1989. ISBN 0-7458-0289-3; 978-0-7458-0289-3. vii + 415 pp. LCCN QA331 .M84 1989. URL http://www.netlib.org/cephes. {133, 270, 521, 556, 558, 567, 583, 593, 600, 617, 644, 657, 693, 708, 823} [MP98] Charlene Morrow and Teri Perl, editors. Notable Women in Mathematics: A Biographical Dictionary. Greenwood Press, Westport, CT, USA, 1998. ISBN 0-313-29131-4; 978-0-313-29131-9. xv + 302 pp. LCCN QA28 .N68 1998. {59} [MPFR04] MPFR: The Multiple Precision Floating-Point Reliable Library: Edition 2.1.0: November 2004, 2004. ii + 35 pp. URL http://www.mpfr.org/ mpfr-current/mpfr.pdf. {401, 407, 825} [MR90] Michael Metcalf and John Ker Reid. Fortran 90 Explained. Oxford science publications. Oxford University Press, Oxford, UK, 1990. ISBN 0-19-853772-7 (paperback); 978-0-19-853772-4 (paperback). xiv + 294 pp. LCCN QA76.73.F28 M48 1990. {106} [MR04] James S. Miller and Susann Ragsdale. The Common Language Infrastructure Annotated Standard. Addison-Wesley, Reading, MA, USA, 2004. ISBN 0-321-15493-2; 978-0-321-15493-4. xxxii + 891 pp. LCCN QA76.7 .M52 2003. {917} [MRR91] Michael Müller, Christine Rüb, and Wolfgang Rülling. Exact accumulation of floating-point numbers. In Kornerup and Matula [KM91], pages 64–69. ISBN 0-8186-9151-4 (case), 0-8186-6151-8 (microfiche), 0-7803-0187-0 (library binding); 978-0-8186-9151-5 (case), 978-0-8186-6151-8 (microfiche), 978-0-7803-0187-0 (library binding). LCCN QA76.9.C62 S95 1991. DOI 10.1109/ARITH.1991.145535. IEEE catalog number 91CH3015-5. {385} [MRR96] Michael Müller, Christine Rüb, and Wolfgang Rülling. A circuit for exact summation of floating-point numbers. Information Processing Letters, 57(3):159–163, February 12, 1996. CODEN IFPLAT. ISSN 0020-0190 (print), 1872-6119 (electronic). URL http://www.sciencedirect.com/science/article/pii/0020019095002057. DOI 10.1016/0020-0190(95)00205-7. {385} [MS00a] Michael Mascagni and Ashok Srinivasan. Algorithm 806: SPRNG: a scalable library for pseudorandom number generation. ACM Transactions on Mathematical Software, 26(3):436–461, September 2000. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/358407.358427. See correction [MS00b]. {158, 1025} [MS00b] Michael Mascagni and Ashok Srinivasan. Corrigendum: Algorithm 806: SPRNG: a scalable library for pseudorandom number generation. ACM Transactions on Mathematical Software, 26(4):618–619, December 2000. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/365723.365738. See [MS00a]. {1025} [MS05] Paolo Montuschi and Eric M. Schwarz, editors. Proceedings of the 17th IEEE Symposium on Computer Arithmetic, ARITH-17 2005, June 27–29, 2005, Cape Cod, Massachusetts, USA. IEEE Computer Society Press, Silver Spring, MD, USA, 2005. ISBN 0-7695-2366-8; 978-0- 7695-2366-8. LCCN QA76.9.C62 .S95 2005. {1000, 1021, 1034} [MSH+16] Paolo Montuschi, Michael Schulte, Javier Hormigo, Stuart Oberman, and Nathalie Revol, editors. 2016 IEEE 23nd Symposium on Computer Arithmetic (ARITH 2016), Santa Clara, California, USA, 10–13 July 2016. IEEE Computer Society Press, Silver Spring, MD, USA, 2016. ISBN 1-5090-1615-5; 978-1-5090-1615-0. ISSN 1063-6889. LCCN QA76.9.C62 S95 2016. URL http://ieeexplore.ieee.org/ servlet/opac?punumber=7562813. {104, 1021} [MT02] George Marsaglia and Wai Wan Tsang. Some difficult-to-pass tests of randomness. Journal of Statistical Software, 7(3):1– 8, 2002. CODEN JSSOBK. ISSN 1548-7660. URL http://www.jstatsoft.org/v07/i03; http://www.jstatsoft.org/v07/ i03/tuftests.c; http://www.jstatsoft.org/v07/i03/tuftests.pdf; http://www.jstatsoft.org/v07/i03/updates. DOI 10.18637/jss.v007.i03. {200} [MU49] Nicholas Metropolis and Stanisław Ulam. The Monte Carlo method. Journal of the American Statistical Association, 44(247):335–341, September 1949. CODEN JSTNAL. ISSN 0162-1459 (print), 1537-274X (electronic). URL http://www.jstor.org/stable/2280232. DOI 10.2307/2280232. This may be the earliest published article on the Monte Carlo method after the algorithm was declassified following World War II. {203} [Mul97] Jean-Michel Muller. Elementary Functions: Algorithms and Implementation. Birkhäuser, Cambridge, MA, USA; Berlin, Germany; Basel, Switzerland, 1997. ISBN 0-8176-3990-X; 978-0-8176-3990-7. xv + 204 pp. LCCN QA331.M866 1997. URL http://perso.ens-lyon.fr/ jean-michel.muller/; http://www.birkhauser.com/cgi-win/ISBN/0-8176-3990-X. {251, 827} [Mul05] Jean-Michel Muller. On the definition of ulp(x). Rapport de recherche LIP RR2005-09, INRIA RR-5504, Laboratoire de l’Informatique du Parallélisme, Lyon, France, February 2005. 19 pp. URL ftp://ftp.inria.fr/INRIA/publication/publi-pdf/RR/RR-5504.pdf. The function ulp(x) returns the unit in the last place of x. {82} [Mul06] Jean-Michel Muller. Elementary Functions: Algorithms and Implementation. Birkhäuser, Cambridge, MA, USA; Berlin, Ger- many; Basel, Switzerland, second edition, 2006. ISBN 0-8176-4372-9; 978-0-8176-4372-0. xxii + 266 pp. LCCN QA331 .M866 2006. URL http://perso.ens-lyon.fr/jean-michel.muller/SecondEdition.html; http://www.springer.com/sgw/cda/ frontpage/0,,4-40109-22-72377986-0,00.html. {55, 827} [Mul15] Jean-Michel Muller. On the error of computing ab + cd using Cornea, Harrison and Tang’s method. ACM Transactions on Mathematical Software, 41(2):7:1–7:8, January 2015. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/2629615. {463} [Mul16] Jean-Michel Muller. Elementary Functions: Algorithms and Implementation. Birkhäuser Boston Inc., Cambridge, MA, USA, third edition, 2016. ISBN 1-4899-7981-6 (print), 1-4899-7983-2 (e-book); 978-1-4899-7981-0 (print), 978-1-4899-7983-4 (e-book). xxv + 283 pp. LCCN QA331 .M866 2016. DOI 10.1007/978-1-4899-7983-4. {827} 1026 Bibliography

[MvA06] Francisco Marcellán and Walter van Assche, editors. Orthogonal Polynomials and Special Functions: Computation and Applications, volume 1883 of Lecture Notes in Mathematics. Springer-Verlag, Berlin, Germany / Heidelberg, Germany / London, UK / etc., 2006. ISBN 3- 540-31062-2; 978-3-540-31062-4. ISSN 0075-8434 (print), 1617-9692 (electronic). xiv + 418 pp. LCCN QA3 .L28 no. 1883; QA404.5 .O735 2006. DOI 10.1007/b128597. {59, 827} [MWKA07] Makoto Matsumoto, Isaku Wada, Ai Kuramoto, and Hyo Ashihara. Common defects in initialization of pseudorandom number generators. ACM Transactions on Modeling and Computer Simulation, 17(4):15:1–15:20, September 2007. CODEN ATMCEZ. ISSN 1049- 3301 (print), 1558-1195 (electronic). DOI 10.1145/1276927.1276928. {176} [MXJ04] D. N. Prabhakar Murthy, Min Xie, and Renyan Jiang. Weibull Models. Wiley series in probability and statistics. Wiley, New York, NY, USA, 2004. ISBN 0-471-36092-9 (cloth); 978-0-471-36092-6 (cloth). xvi + 383 pp. LCCN QA273.6 .M87 2004. {196} [MZ91] George Marsaglia and Arif Zaman. A new class of random number generators. Annals of Applied Probability, 1(3):462–480, August 1991. ISSN 1050-5164. URL http://projecteuclid.org/euclid.aoap/1177005878. DOI 10.1214/aoap/1177005878. See remarks in [EH95, TLC93] about the extremely bad lattice structure in high dimensions of the generators proposed in this paper. {177, 1035} [MZ93] George Marsaglia and Arif Zaman. Monkey tests for random number generators. Computers and Mathematics with Applications, 26(9): 1–10, November 1993. CODEN CMAPDK. ISSN 0898-1221 (print), 1873-7668 (electronic). DOI 10.1016/0898-1221(93)90001-C. See also [PW95]. {200, 1028} [MZM94] George Marsaglia, Arif Zaman, and John C. W. Marsaglia. Rapid evaluation of the inverse of the normal distribution function. Statistics & Probability Letters, 19(4):259–266, March 15, 1994. CODEN SPLTDC. ISSN 0167-7152 (print), 1879-2103 (electronic). DOI 10.1016/0167-7152(94)90174-0. {618} [Nah06] Paul J. Nahin. Dr. Euler’s Fabulous Formula: Cures Many Mathematical Ills. Princeton University Press, Princeton, NJ, USA, 2006. ISBN 0-691-11822-1 (hardcover); 978-0-691-11822-2 (hardcover). xx + 380 pp. LCCN QA255 .N339 2006. The Euler formula, eiπ + 1 = 0, relates ﬁve important mathematical constants, and the digits of the binary number system. {14, 59, 591, 623} [Nea73] Henry R. Neave. Miscellanea: On using the Box–Muller transformation with multiplicative congruential pseudo-random number generators. Applied Statistics, 22(1):92–97, 1973. CODEN APSTAG. ISSN 0035-9254 (print), 1467-9876 (electronic). URL http:// www.jstor.org/stable/2346308. DOI 10.2307/2346308. {193} [Nea15] Radford M. Neal. Fast exact summation using small and large superaccumulators. Report, Department of Statistical Sciences and Department of Computer Science, University of Toronto, Toronto, ON, Canada, 2015. 22 pp. URL http://www.cs.toronto.edu/ ~radford/ftp/xsum.pdf. {385} [Neh07] Markus Neher. Complex standard functions and their implementation in the CoStLy library. ACM Transactions on Mathematical Soft- ware, 33(1):2:1–2:27, March 2007. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/1206040.1206042. {476} [Nev44] Eric Harold Neville. Jacobian Elliptic Functions. Clarendon Press, Oxford, UK, 1944. xiii+2+331+1pp.LCCN QA343 .N5. {678} [Nev51] Eric Harold Neville. Jacobian Elliptic Functions. Clarendon Press, Oxford, UK, second edition, 1951. xiv + 345 pp. LCCN QA343 .N5 1951. {678} [New05] M. E. J. Newman. Power laws, Pareto distributions and Zipf’s law. Contemporary physics, 46(5):323–351, September 2005. CODEN CTPHAF. ISSN 0010-7514 (print), 1366-5812 (electronic). DOI 10.1080/00107510500052444. {196} [Ng92] K. C. Ng. Argument reduction for huge arguments: Good to the last bit. SunPro, July 13, 1992. URL http://www.validlab.com/ arg.pdf. {250} [Nie78] Harald Niederreiter. Quasi-Monte Carlo methods and pseudo-random numbers. Bulletin of the American Mathematical Society, 84(6): 957–1041, November 1978. CODEN BAMOAD. ISSN 0002-9904 (print), 1936-881X (electronic). URL http://www.ams.org/bull/ 1978-84-06/S0002-9904-1978-14532-7/S0002-9904-1978-14532-7.pdf. DOI 10.1090/S0002-9904-1978-14532-7. {203} [Nie92] Harald Niederreiter. Random Number Generation and Quasi-Monte Carlo Methods, volume 63. SIAM (Society for Industrial and Applied Mathematics), Philadelphia, PA, USA, 1992. ISBN 0-89871-295-5; 978-0-89871-295-7. vi + 241 pp. LCCN QA298 .N54 1992. {203} [Nie03] Yves Nievergelt. Scalar fused multiply-add instructions produce ﬂoating-point matrix arithmetic provably accurate to the penultimate digit. ACM Transactions on Mathematical Software, 29(1):27–48, March 2003. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/641876.641878. {87} [NIS15] NIST. SHA-3 standard: Permutation-based hash and extendable-output functions. FIPS PUB 202, National Institute for Standards and Technology, Gaithersburg, MD, USA, 2015. viii + 29 pp. DOI 10.6028/NIST.FIPS.202. {178} [NW97] Roger M. Needham and David J. Wheeler. TEA extensions. Report, Cambridge University, Cambridge, UK, October 1997. URL http://www.movable-type.co.uk/scripts/xtea.pdf. See also original TEA [WN95] and extension XXTEA [WN98]. {178, 1037} [OE74] R. E. Odeh and J. O. Evans. Statistical algorithms: Algorithm AS 70: The percentage points of the normal distribution. Applied Statistics, 23(1):96–97, March 1974. CODEN APSTAG. ISSN 0035-9254 (print), 1467-9876 (electronic). URL http://lib.stat.cmu.edu/apstat/ 70. DOI 10.2307/2347061. {618} [OLBC10] Frank W. J. Olver, Daniel W. Lozier, Ronald F. Boisvert, and Charles W. Clark, editors. NIST Handbook of Mathematical Functions. Cambridge University Press, Cambridge, UK, 2010. ISBN 0-521-19225-0; 978-0-521-19225-5. xv + 951 pp. LCCN QA331 .N57 2010. URL http://dlmf.nist.gov/; http://www.cambridge.org/catalogue/catalogue.asp?isbn=9780521192255. {6, 58, 269, 301, 303, 341, 498, 521, 560, 562, 574, 589, 593, 600, 619, 624, 627, 632, 653, 657, 661, 666, 673, 675, 678, 682, 689, 693, 826} [Olv74] Frank W. J. Olver. Asymptotics and Special Functions. Academic Press, New York, NY, USA, 1974. ISBN 0-12-525850-X; 978-0-12-525850- 0. xvi + 572 pp. LCCN QA351 .O481 1974. {19, 521, 693, 827} Bibliography 1027

[Omo94] Amos R. Omondi. Computer Arithmetic Systems: Algorithms, Architecture, and Implementation. Prentice-Hall, Upper Saddle River, NJ, USA, 1994. ISBN 0-13-334301-4; 978-0-13-334301-4. xvi + 520 pp. LCCN QA76.9.C62 O46 1994. {407, 881, 978} [OMS09] Keith B. Oldham, Jan Myland, and Jerome Spanier, editors. An Atlas of Functions. Springer-Verlag, Berlin, Germany / Heidelberg, Germany / London, UK / etc., second edition, 2009. ISBN 0-387-48807-3 (softcover), 0-387-48806-5 (hardcover); 978-0-387-48807-3 (softcover), 978-0-387-48806-6 (hardcover). xi + 748 pp. LCCN QA331 .S685 2009. DOI 10.1007/978-0-387-48807-3. {1032} [OOO16] Katsuhisa Ozaki, Takeshi Ogita, and Shin’ichi Oishi. Error-free transformation of matrix multiplication with a posteriori validation. Numerical Linear Algebra with Applications, 23(5):931–946, October 2016. CODEN NLAAEM. ISSN 1070-5325 (print), 1099-1506 (electronic). DOI 10.1002/nla.2061. {385} [ORO05] Takeshi Ogita, Siegfried M. Rump, and Shin’ichi Oishi. Accurate sum and dot product. SIAM Journal on Scientific Computing, 26(6): 1955–1988, November 2005. CODEN SJOCE3. ISSN 1064-8275 (print), 1095-7197 (electronic). URL http://epubs.siam.org/sam-bin/ dbq/article/60181. DOI 10.1137/030601818. {385} [O’S07] Donal O’Shea. The Poincaré Conjecture: in Search of the Shape of the Universe. Walker and Company, New York, NY, USA, 2007. ISBN 0-8027-1532-X; 978-0-8027-1532-6. ix + 293 pp. LCCN QA612 .O83 2007. {521, 579} [Ove01] Michael L. Overton. Numerical Computing with IEEE Floating Point Arithmetic, Including One Theorem, One Rule of Thumb, and One Hundred and One Exercises. SIAM (Society for Industrial and Applied Mathematics), Philadelphia, PA, USA, 2001. ISBN 0-89871-482-6; 978-0-89871-482-1. xiv + 104 pp. LCCN QA76.9.M35 O94 2001. URL http://www.cs.nyu.edu/cs/faculty/overton/book/; http: //www.siam.org/catalog/mcc07/ot76.htm. {67, 103} [Pag77] E. Page. Miscellanea: Approximations to the cumulative normal function and its inverse for use on a pocket calculator. Applied Statistics, 26(1):75–76, 1977. CODEN APSTAG. ISSN 0035-9254 (print), 1467-9876 (electronic). URL http://www.jstor.org/stable/ 2346872. DOI 10.2307/2346872. {618} [Pai19] Eleanor Pairman. Tables of the Digamma and Trigamma Functions, volume I of Tracts for computers. Cambridge University Press, Cam- bridge, UK, 1919. 9 + 11 pp. LCCN QA47 .T7 no.1. {537} [Par69] Ronald G. Parson. Certification of Algorithm 147 [S14]: PSIF. Communications of the Association for Computing Machinery, 12(12):691–692, December 1969. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). DOI 10.1145/363626.363651. See [Ami62, Tha63]. {996, 1035} [Par00] Behrooz Parhami. Computer Arithmetic: Algorithms and Hardware Designs. Oxford University Press, Oxford, UK, 2000. ISBN 0-19- 512583-5; 978-0-19-512583-2. xx + 490 pp. LCCN QA76.9.C62P37 1999. {68, 881, 978} [PAS82] Specification for Computer Programming Language Pascal, ISO 7185-1982. International Organization for Standardization, Geneva, Switzerland, 1982. URL http://www.iso.ch/cate/d13802.html. {70} [PAS90] Extended Pascal ISO 10206:1990. International Organization for Standardization, Geneva, Switzerland, 1990. xii + 218 pp. URL http://www.iso.ch/cate/d18237.html. Available in PostScript for personal use only at http://pascal.miningco.com/msub1.htm. {vii, 989} [Pat88] S. J. Patterson. An Introduction to the Theory of the Riemann Zeta-function, volume 14 of Cambridge studies in advanced mathematics. Cambridge University Press, Cambridge, UK, 1988. ISBN 0-521-33535-3; 978-0-521-33535-5. xiii + 156 pp. LCCN QA246 .P28 1988. {579} [Pea00] Karl Pearson. On a criterion that a given system of deviations from the probable in the case of a correlated system of variables is such that it can be reasonably supposed to have arisen in random sampling. Philosophical Magazine, 50(302):157–175, July/December 1900. CODEN PHMAA4. ISSN 0031-8086. URL http://www.tandfonline.com/doi/pdf/10.1080/14786440009463897. DOI 10.1080/ 14786440009463897. {197} [PGPB90] E. S. Pearson, William Sealy Gosset, R. L. Plackett, and George A. Barnard, editors. Student: a Statistical Biography of William Sealy Gosset. Clarendon Press, Oxford, UK, 1990. ISBN 0-19-852227-4; 978-0-19-852227-0. viii + 142 pp. LCCN QA276.157.G67 P43 1990. Gosset is the originator of the widely used Student t-test in the statistics of small sample sizes. {196} [PH83a] M. H. Payne and R. N. Hanek. Degree reduction for trigonometric functions. ACM SIGNUM Newsletter, 18(2):18–19, April 1983. CODEN SNEWD6. ISSN 0163-5778 (print), 1558-0237 (electronic). DOI 10.1145/1057605.1057606. {250, 253} [PH83b] M. H. Payne and R. N. Hanek. Radian reduction for trigonometric functions. ACM SIGNUM Newsletter, 18(1):19–24, January 1983. CODEN SNEWD6. ISSN 0163-5778 (print), 1558-0237 (electronic). DOI 10.1145/1057600.1057602. {250, 253} [PH02] David A. Patterson and John L. Hennessy. Computer Architecture — A Quantitative Approach. Morgan Kaufmann Publishers, Los Altos, CA 94022, USA, third edition, 2002. ISBN 1-55860-596-7; 978-1-55860-596-1. xxi + 883 + A-87 + B-42 + C-1 + D-1 + E-1 + F-1 + G-1 + H-1 + I-1 + R-22 + I-44 pp. LCCN QA76.9.A73 P377 2003. URL http://www.mkp.com/books_catalog/catalog.asp?ISBN=1-55860-596-7; http://www.mkp.com/CA3. {103, 1013} [PH08] David A. Patterson and John L. Hennessy. Computer Organization and Design: the Hardware/Software Interface. Elsevier/Morgan Kauf- mann, San Francisco, CA, USA, fourth edition, 2008. ISBN 0-12-374493-8; 978-0-12-374493-7. xxv + 703 + A-77 + B-83 + I-26 pp. LCCN QA76.9.C643. {103} [PH12] David A. Patterson and John L. Hennessy. Computer Organization and Design: the Hardware/Software Interface. The Morgan Kaufmann series in computer architecture and design. Morgan Kaufmann/Elsevier, Waltham, MA, USA, fourth edition, 2012. ISBN 0-12-374750- 3 (paperback); 978-0-12-374750-1 (paperback). xxv + 703 pp. LCCN QA76.9.C643 H46 2012. URL http://store.elsevier.com/ product.jsp?isbn=9780080922812. With contributions by Perry Alexander, Peter J. Ashenden, Javier Bruguera, Jichuan Chang, Matthew Farrens, David Kaeli, Nicole Kaiyan, David Kirk, James R. Larus, Jacob Leverich, Kevin Lim, John Nickolls, John Oliver, Milos Prvulovic, and Parta Ranganthan. {103} 1028 Bibliography

[Phi60] J. R. Philip. The function inverfc θ. Australian Journal of Physics, 13(1):13–20, March 1960. CODEN AUJPAS. ISSN 0004-9506 (print), 1446-5582 (electronic). DOI 10.1071/PH600013. {600} [Phi86] Jen Phillips. The NAG Library. Clarendon Press, Oxford, UK, 1986. ISBN 0-19-853263-6; 978-0-19-853263-7. viii + 245 pp. LCCN QA297.P53 1986. {826} [PK91] Vern Paxson and William M. Kahan. A program for testing IEEE binary–decimal conversion. World-Wide Web document, May 1991. URL ftp://ftp.ee.lbl.gov/testbase-report.ps.Z; ftp://ftp.ee.lbl.gov/testbase.tar.Z. {1015} [PL05] François Panneton and Pierre L’Ecuyer. On the xorshift random number generators. ACM Transactions on Modeling and Computer Simu- lation, 15(4):346–361, October 2005. CODEN ATMCEZ. ISSN 1049-3301 (print), 1558-1195 (electronic). DOI 10.1145/1113316.1113319. See [Mar03b, Bre04, Vig16]. {1001, 1024} [PL07] Alfred S. Posamentier and Ingmar Lehmann. The Fabulous Fibonacci Numbers. Prometheus Books, Amherst, NY, USA, 2007. ISBN 1-59102-475-7; 978-1-59102-475-0. 385 pp. LCCN QA241 .P665 2007. {15} [Pla92] P. J. Plauger. The Standard C Library. Prentice-Hall, Upper Saddle River, NJ, USA, 1992. ISBN 0-13-838012-0; 978-0-13-838012-0. xiv + 498 pp. LCCN QA76.73.C15 P563 1991. {133, 827} [PM75] Robert Piessens and Irene Mertens. Remark and certification on “Algorithm 446: Ten subroutines for the manipulation of Chebyshev series”. Communications of the Association for Computing Machinery, 18(5):276, 1975. CODEN CACMA2. ISSN 0001-0782 (print), 1557- 7317 (electronic). DOI 10.1145/360762.360782. See [Bro73]. {1001} [PM84] John F. Palmer and Stephen P. Morse. The 8087 Primer. Wiley, New York, NY, USA, 1984. ISBN 0-471-87569-4; 978-0-471-87569-7. viii + 182 pp. LCCN QA76.8.I2923 P34 1984. Excellent coverage of the 8087 numeric coprocessor by the chief architects of the Intel 8087 (Palmer) and 8086 (Morse). Contains many candid statements about design decisions in these processors. A must for serious assembly language coding of the 8087 and 80287 chips. See also [Int85]. {63, 104} [PM88] Stephen K. Park and Keith W. Miller. Random number generators: Good ones are hard to find. Communications of the Association for Computing Machinery, 31(10):1192–1201, October 1988. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). URL http://www.acm.org/pubs/toc/Abstracts/0001-0782/63042.html. DOI 10.1145/63039.63042. {170, 214} [Pól49] George Pólya. Remarks on computing the probability integral in one and two dimensions. In Proceedings of the [First] Berkeley Sympo- sium on Mathematical Statistics and Probability: held at the Statistical Laboratory, Department of Mathematics, University of California, August 13–18, 1945, January 27–29, 1946, pages 63–78. University of California Press, Berkeley, CA, USA, 1949. LCCN QA276 .B4. URL http://projecteuclid.org/euclid.bsmsp/1166219199. {618} [POP64] IBM Corporation, San Jose, CA, USA. IBM System/360 Principles of Operation, 1964. 168 pp. URL http://bitsavers.org/pdf/ibm/ 360/poo/A22-6821-0_360PrincOps.pdf. File number S360-01. Form A22-6821-5. {928, 963, 964} [POP67] IBM Corporation, San Jose, CA, USA. IBM System/360 Principles of Operation, seventh edition, January 13, 1967. 175 pp. URL http:// www.bitsavers.org/pdf/ibm/360/poo/A22-6821-6_360PrincOpsJan67.pdf. File number S360-01. Form A22-6821-6. {964} [POP75] IBM Corporation, San Jose, CA, USA. IBM System/370 Principles of Operation, September 1, 1975. viii + 9–326 pp. URL http:// bitsavers.org/pdf/ibm/360/poo/A22-6821-0_360PrincOps.pdf. File number S/360-01. Form GA22-7000-4. {965} [Pop00] Bogdan A. Popov. Optimal starting approximation and iterative algorithm for inverse error function. SIGSAM Bulletin (ACM Special Interest Group on Symbolic and Algebraic Manipulation), 34(1):25–26, March 2000. CODEN SIGSBZ. ISSN 0163-5824 (print), 1557-9492 (electronic). DOI 10.1145/373500.373510. {600, 604} [POP04] IBM Corporation, Department 55JA Mail Station P384, 2455 South Road Poughkeepsie, NY, 12601-5400, USA. z/Architecture Principles of Operation, fourth edition, May 2004. xxvi + 1124 pp. URL http://publibz.boulder.ibm.com/cgi-bin/bookmgr_OS390/download/ DZ9ZR003.pdf. IBM order number SA22-7832-03. {963, 965} [PP05] Wolfgang K. H. Panofsky and Melba Phillips. Classical Electricity and Magnetism. Dover books on physics. Dover, New York, NY, USA, second edition, 2005. ISBN 0-486-43924-0; 978-0-486-43924-2. xvi + 494 pp. LCCN QC518 .P337 2005. {693} [Pri91] Douglas M. Priest. Algorithms for arbitrary precision floating point arithmetic. In Kornerup and Matula [KM91], pages 132–143. ISBN 0-8186-9151-4 (case), 0-8186-6151-8 (microfiche), 0-7803-0187-0 (library binding); 978-0-8186-9151-5 (case), 978-0-8186-6151-8 (microfiche), 978-0-7803-0187-0 (library binding). LCCN QA76.9.C62 S95 1991. DOI 10.1109/ARITH.1991.145549. IEEE catalog number 91CH3015-5. {385, 407, 476} [Pri92] Douglas M. Priest. On Properties of Floating Point Arithmetics: Numerical Stability and the Cost of Accurate Computations. Thesis (Ph.D. in mathematics), Department of Computer Science, University of California, Berkeley, Berkeley, CA, USA, December 1992. iv + 136 pp. URL ftp://ftp.icsi.berkeley.edu/pub/theory/priest-thesis.ps.Z. {89} [Pri04] Douglas M. Priest. Efficient scaling for complex division. ACM Transactions on Mathematical Software, 30(4):389–401, December 2004. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/1039813.1039814. {453–455, 1033} [PSLM00] P. J. Plauger, Alexander A. Stepanov, Meng Lee, and David R. Musser. The C++ Standard Template Library. Prentice-Hall, Upper Saddle River, NJ, USA, 2000. ISBN 0-13-437633-1; 978-0-13-437633-2. xii + 485 pp. LCCN QA76.73.C153 C17 2000. {827} [PTVF07] William H. Press, Saul A. Teukolsky, William T. Vetterling, and Brian P. Flannery. Numerical Recipes — The Art of Scientific Computing. Cambridge University Press, Cambridge, UK, third edition, 2007. ISBN 0-521-88068-8 (hardcover), 0-521-88407-1 (with source code CD ROM), 0-521-70685-8 (source code CD ROM); 978-0-521-88068-8 (hardcover), 978-0-521-88407-5 (with source code CD ROM), 978- 0-521-70685-8 (source code CD ROM). xxi + 1235 pp. LCCN QA297 .N866 2007. URL http://www.cambridge.org/numericalrecipes. {19, 196, 567, 589, 657} [PW95] Ora E. Percus and Paula A. Whitlock. Theory and application of Marsaglia’s monkey test for pseudorandom number generators. ACM Transactions on Modeling and Computer Simulation, 5(2):87–100, April 1995. CODEN ATMCEZ. ISSN 1049-3301 (print), 1558-1195 (electronic). DOI 10.1145/210330.210331. See [MZ93]. {200, 1026} Bibliography 1029

[Rai60] Earl David Rainville. Special Functions. Chelsea Publishing Company, New York, NY, USA, 1960. ISBN 0-8284-0258-2; 978-0-8284- 0258-3. xii + 365 pp. LCCN QA351 .R3 1971. Reprinted in 1971. {521, 827} [Ran82] Brian Randell, editor. The Origins of Digital Computers: Selected Papers. Texts and monographs in computer science. Springer-Verlag, Berlin, Germany / Heidelberg, Germany / London, UK / etc., third edition, 1982. ISBN 0-387-11319-3, 3-540-11319-3; 978-0-387- 11319-7, 978-3-540-11319-5. xvi + 580 pp. LCCN TK7885.A5 O741 1982. DOI 10.1007/978-3-642-61812-3. This book collects many important early papers on computers from 1837 to 1949. {104} [Ray04] Eric Steven Raymond. The Art of UNIX Programming. Addison-Wesley, Reading, MA, USA, 2004. ISBN 0-13-124085-4, 0-13-142901-9; 978-0-13-124085-8, 978-0-13-142901-7. xxxii + 525 pp. LCCN QA76.76.O63 R395 2003. {956} [RB05a] Arnold Robbins and Nelson H. F. Beebe. Classic Shell Scripting. O’Reilly Media, Sebastopol, CA, USA, 2005. ISBN 0-596-00595-4; 978- 0-596-00595-5. xxii + 534 pp. LCCN QA76.76.O63 R633 2005. URL http://www.oreilly.com/catalog/shellsrptg/. Also available in Chinese [RB08], French [RB05b], German [RB06a], Japanese [RB06c], and Polish [RB06b] translations. {ix, 873, 1029} [RB05b] Arnold Robbins and Nelson H. F. Beebe. Introduction aux Scripts Shell. O’Reilly & Associates, Sebastopol, CA, USA, and Cambridge, MA, USA, 2005. ISBN 2-84177-375-2; 978-2-84177-375-6. xxii + 558 pp. URL http://www.silicon.fr/getarticle.asp?id=14015. French translation of [RB05a] by Eric Jacoboni. {1029} [RB06a] Arnold Robbins and Nelson H. F. Beebe. Klassische Shell-Programmierung: [automatisieren Sie Ihre Unix/Linux-Tasks]. O’Reilly & As- sociates, Sebastopol, CA, USA, and Cambridge, MA, USA, 2006. ISBN 3-89721-441-5; 978-3-89721-441-5. xxiii + 572 pp. LCCN QA76.76.O63 R563 2005. URL http://www.gbv.de/dms/hebis-darmstadt/toc/17645067X.pdf. German translation of [RB05a] by Kathrin Lichtenberg. {1029} [RB06b] Arnold Robbins and Nelson H. F. Beebe. Programowanie Skryptów Powłoki. Helion, Gliwice, Poland, 2006. ISBN 83-246-0131- 7; 978-83-246-0131-8. 557 + 2 pp. URL http://www.empik.com/b/o/19/f1/19f16b85e0d75ae1d3a1e7062569fbb0.jpg; http:// www.empik.com/programowanie-skryptow-powloki-ksiazka,360529,p. Polish translation of [RB05a] by Przemysław Szeremiota. {1029} [RB06c] Arnold Robbins and Nelson H. F. Beebe. Shokai¯ shieru sukuriputo. Orair¯ı Japan, Toky¯ o,¯ Japan, 2006. ISBN 4-87311-267-2; 978-4-87311- 267-1. 345 pp. Japanese translation of [RB05a] by Aoi Hyuga.¯ {1029} [RB08] Arnold Robbins and Nelson H. F. Beebe. Shell Jiao Ben Xue Xi Zhi Nan = Shell Script Study Guide. O’Reilly Media, Sebastopol, CA, USA, 2008. ISBN 7-111-25504-6; 978-7-111-25504-8. vi + 494 pp. Simplified Chinese translation of [RB05a]. {1029} [RBJ16] Siegfried M. Rump, Florian Bünger, and Claude-Pierre Jeannerod. Improved error bounds for floating-point products and Horner’s scheme. BIT Numerical Mathematics, 56(1):293–307, March 2016. CODEN BITTEL, NBITAB. ISSN 0006-3835 (print), 1572-9125 (electronic). URL http://link.springer.com/article/10.1007/s10543-015-0555-z. DOI 10.1007/s10543-015-0555-z. {89} [Ree77] James A. Reeds. “Cracking” a random number generator. Cryptologia, 1(1):20–26, January 1977. CODEN CRYPE6. ISSN 0161-1194 (print), 1558-1586 (electronic). URL http://alumni.cs.ucr.edu/~jsun/random-number.pdf; http://www.dean.usma.edu/ math/pubs/cryptologia/ClassicArticleReprints/V01N1PP20-26JamesReeds.pdf; http://www.informaworld.com/smpp/ content~content=a748865252~db=all~order=page. DOI 10.1080/0161-117791832760. Reprinted in [DKKM87, pp. 509–515]. {207} [Ree79] James A. Reeds. Cracking a multiplicative congruential encryption algorithm. In Information linkage between applied mathematics and industry (Proc. First Annual Workshop, Naval Postgraduate School, Monterey, Calif., 1978), pages 467–472. Academic Press, New York, NY, USA, 1979. DOI 10.1016/B978-0-12-734250-4.50037-0. {207} [Rei06] Constance Reid. From Zero to Infinity: What Makes Numbers Interesting. A. K. Peters, Wellesley, MA, USA, fifth edition, 2006. ISBN 1-56881-273-6; 978-1-56881-273-1. xvii + 188 pp. LCCN QA93 .R42 2006. {59} [REXX96] American National Standard for information technology: programming language REXX: ANSI X3.274-1996. American National Standards Institute, New York, NY, USA, 1996. iv + 167 pp. {viii, 968} [Rib91] Paulo Ribenboim. The Little Book of Big Primes. Springer-Verlag, Berlin, Germany / Heidelberg, Germany / London, UK / etc., 1991. ISBN 0-387-97508-X (New York), 3-540-97508-X (Berlin); 978-0-387-97508-5 (New York), 978-3-540-97508-3 (Berlin). xvii + 237 pp. LCCN QA246 .R472 1991. DOI 10.1007/978-1-4757-4330-2. {590} [Rib96] Paulo Ribenboim. The New Book of Prime Number Records. Springer-Verlag, Berlin, Germany / Heidelberg, Germany / London, UK / etc., third edition, 1996. ISBN 0-387-94457-5 (hardcover); 978-0-387-94457-9 (hardcover). xxiv + 541 pp. LCCN QA246 .R47 1996. DOI 10.1007/978-1-4612-0759-7. {590} [Rib04] Paulo Ribenboim. The Little Book of Bigger Primes. Springer-Verlag, Berlin, Germany / Heidelberg, Germany / London, UK / etc., second edition, 2004. ISBN 0-387-20169-6; 978-0-387-20169-6. xxiii + 356 pp. LCCN QA246 .R473 2004. DOI 10.1007/b97621. {590} [Ric64] John R. Rice. The Approximation of Functions, volume 1. Addison-Wesley, Reading, MA, USA, 1964. LCCN QA221 .R5 V.1-2. {31} [Rip90] B. D. Ripley. Thoughts on pseudorandom number generators. Journal of Computational and Applied Mathematics, 31(1):153–163, July 24, 1990. CODEN JCAMDI. ISSN 0377-0427 (print), 1879-1778 (electronic). URL http://www.sciencedirect.com/science/article/pii/ 0377042790903462. DOI 10.1016/0377-0427(90)90346-2. {178} [Riv74] Theodore J. Rivlin. The Chebyshev Polynomials. Pure and applied mathematics. Wiley, New York, NY, USA, 1974. ISBN 0-471-72470-X; 978-0-471-72470-4. vi + 186 pp. LCCN QA404.5 .R58 1974. {58} [Riv90] Theodore J. Rivlin. Chebyshev Polynomials: From Approximation Theory to Algebra and Number Theory. Pure and applied mathematics. Wiley, New York, NY, USA, second edition, 1990. ISBN 0-471-62896-4; 978-0-471-62896-5. xiii + 249 pp. LCCN QA404.5 .R58 1990. {58} 1030 Bibliography

[Rob82] C. S. Roberts. Implementing and testing new versions of a good, 48-bit, pseudo-random number generator. The Bell System Technical Journal, 61(8):2053–2063, October 1982. CODEN BSTJAN. ISSN 0005-8580 (print), 2376-7154 (electronic). URL http://bstj.bell-labs.com/BSTJ/images/Vol61/bstj61-8-2053.pdf; http://www.alcatel-lucent.com/bstj/ vol61-1982/articles/bstj61-8-2053.pdf. DOI 10.1002/j.1538-7305.1982.tb03099.x. {162} [Roc00] Daniel N. Rockmore. The FFT: An algorithm the whole family can use. Computing in Science and Engineer- ing, 2(1):60–64, January/February 2000. CODEN CSENFA. ISSN 1521-9615 (print), 1558-366X (electronic). URL http://dlib.computer.org/cs/books/cs2000/pdf/c1060.pdf; http://www.computer.org/cse/cs1999/c1060abs.htm; http: //www.cs.dartmouth.edu/~rockmore/cse-fft.pdf. DOI 10.1109/5992.814659. [FFT = Fast Fourier Transform]. {969} [Roc06] Daniel N. Rockmore. Stalking the Riemann Hypothesis: the Quest to Find the Hidden Law of Prime Numbers. Vintage Books, New York, NY, USA, 2006. ISBN 0-375-72772-8 (paperback); 978-0-375-72772-6 (paperback). x + 292 pp. LCCN QA246 .R63 2006. {60, 303, 521, 579} [ROO08a] Siegfried M. Rump, Takeshi Ogita, and Shin’ichi Oishi. Accurate floating-point summation. Part I: Faithful rounding. SIAM Journal on Scientific Computing, 31(1):189–224, 2008. CODEN SJOCE3. ISSN 1064-8275 (print), 1095-7197 (electronic). DOI 10.1137/050645671. {385} [ROO08b] Siegfried M. Rump, Takeshi Ogita, and Shin’ichi Oishi. Accurate floating-point summation. Part II: Sign, K-fold faithful and rounding to nearest. SIAM Journal on Scientific Computing, 31(2):1269–1302, 2008. CODEN SJOCE3. ISSN 1064-8275 (print), 1095-7197 (electronic). DOI 10.1137/07068816X. {385} [Ros11] Greg Rose. KISS: A bit too simple. Report, Qualcomm Inc., San Diego, CA, USA, April 18, 2011. URL http://eprint.iacr.org/2011/ 007.pdf. {177} [RS92] Andrew Mansfield Rockett and Peter Szüsz. Continued Fractions. World Scientific Publishing, Singapore, 1992. ISBN 981-02-1047-7; 978-981-02-1047-2. ix + 188 pp. LCCN QA295.R6 1992; QA295 .R6 1992. {19} [RSN+01] Andrew Rukhin, Juan Soto, James Nechvatal, Miles Smid, Elaine Barker, Stefan Leigh, Mark Levenson, Mark Vangel, David Banks, Alan Heckert, James Dray, and San Vo. A Statistical Test Suite For Random and Pseudorandom Number Generators for Cryptographic Applications. National Institute for Standards and Technology, Gaithersburg, MD, USA, May 15, 2001. 162 pp. URL http://csrc.nist.gov/rng/rng2.html; http://csrc.nist.gov/rng/SP800-22b.pdf; http://csrc.nist.gov/rng/ sts-1.5.tar; http://csrc.nist.gov/rng/sts.data.tar; http://csrc.nist.gov/rng/StsGui.zip. NIST Special Publication 800-22. {200} [Rud07] Peter Strom Rudman. How Mathematics Happened: the First 50,000 Years. Prometheus Books, Amherst, NY, USA, 2007. ISBN 1-59102- 477-3; 978-1-59102-477-4. 314 pp. LCCN QA22 .R86 2007. {59} [Rum09] Siegfried M. Rump. Ultimately fast accurate summation. SIAM Journal on Scientific Computing, 31(5):3466–3502, 2009. CODEN SJOCE3. ISSN 1064-8275 (print), 1095-7197 (electronic). DOI 10.1137/080738490. {385} [Rum12] Siegfried M. Rump. Error estimation of floating-point summation and dot product. BIT Numerical Mathematics, 52(1):201–220, March 2012. CODEN BITTEL, NBITAB. ISSN 0006-3835 (print), 1572-9125 (electronic). URL http://www.springerlink.com/openurl.asp? genre=article&issn=0006-3835&volume=52&issue=1&spage=201. DOI 10.1007/s10543-011-0342-4. {385} [Rus78] Richard M. Russell. The Cray-1 computer system. Communications of the Association for Computing Machinery, 21(1):63–72, January 1978. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). DOI 10.1145/359327.359336. {952} [Ryd74] Barbara G. Ryder. The PFORT verifier. Software — Practice and Experience, 4(4):359–377, October/December 1974. CODEN SPEXBL. ISSN 0038-0644 (print), 1097-024X (electronic). DOI 10.1002/spe.4380040405. {823} [Sab03] Karl Sabbagh. The Riemann Hypothesis: the Greatest Unsolved Problem in Mathematics. Farrar, Straus and Giroux, New York, NY, USA, 2003. ISBN 0-374-25007-3; 978-0-374-25007-2. viii + 340 pp. LCCN QA241 .S23 2003. Originally published in 2002 as Dr. Riemann’s zeroes by Grove Atlantic, London, UK. {60, 303, 521, 579, 590} [SAI+90] Herbert Schildt, American National Standards Institute, International Organization for Standardization, International Electrotechnical Commission, and ISO/IEC JTC 1. The Annotated ANSI C Standard: American National Standard for Programming Languages C: ANSI/ ISO 9899-1990. Osborne/McGraw-Hill, Berkeley, CA, USA, 1990. ISBN 0-07-881952-0; 978-0-07-881952-0. xvi + 219 pp. LCCN QA76.73.C15S356 1990. URL http://www.iso.ch/cate/d29237.html. {4} [Sal76] Eugene Salamin. Computation of π [pi] using arithmetic-geometric mean. Mathematics of Computation, 30(135):565–570, July 1976. CODEN MCMPAF. ISSN 0025-5718 (print), 1088-6842 (electronic). URL http://www.jstor.org/stable/2005327. DOI 10.2307/ 2005327. {623} [Sal94] Peter H. Salus. A Quarter Century of UNIX. Addison-Wesley, Reading, MA, USA, 1994. ISBN 0-201-54777-5; 978-0-201-54777-1. xii + 256 pp. LCCN QA76.76.O63 S342 1994. {956} [San07a] Charles Edward Sandifer. The Early Mathematics of Leonhard Euler, volume 1 of Spectrum series; MAA tercentenary Euler celebration. Mathematical Association of America, Washington, DC, USA, 2007. ISBN 0-88385-559-3; 978-0-88385-559-1. xix + 391 pp. LCCN QA29.E8 S26 2007. {591} [San07b] Charles Edward Sandifer. How Euler did it, volume 3 of The MAA tercentenary Euler celebration; Spectrum series. Mathematical Associa- tion of America, Washington, DC, USA, 2007. ISBN 0-88385-563-1; 978-0-88385-563-8. xiv + 237 pp. LCCN QA29.E8. {591} [SC08] Walter Schreppers and Annie Cuyt. Algorithm 871: A C/C++ precompiler for autogeneration of multiprecision programs. ACM Transactions on Mathematical Software, 34(1):5:1–5:20, January 2008. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/1322436.1322441. {410} [Sch78] J. L. Schonfelder. Chebyshev expansions for the error and related functions. Mathematics of Computation, 32(144):1232–1240, October 1978. CODEN MCMPAF. ISSN 0025-5718 (print), 1088-6842 (electronic). URL http://www.jstor.org/stable/2006347. DOI 10.2307/ 2006347. {600} Bibliography 1031

[Sch79a] Bruce W. Schmeiser. Miscellanea: Approximations to the inverse cumulative normal function for use on hand calculators. Applied Statistics, 28(2):175–176, 1979. CODEN APSTAG. ISSN 0035-9254 (print), 1467-9876 (electronic). URL http://www.jstor.org/stable/ 2346737. DOI 10.2307/2346737. {618} [Sch79b] Linus Schrage. A more portable Fortran random number generator. ACM Transactions on Mathematical Software, 5(2):132–138, June 1979. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/355826.355828. {174, 175, 214} [Sch81] Norman L. Schryer. A test of a computer’s floating-point arithmetic unit. Technical Report Computer Science Technical Report 89, AT&T Bell Laboratories, February 1981. 66 pp. URL http://plan9.bell-labs.com/cm/cs/cstr/89.ps.gz. {775} [Sch96] Bruce Schneier. Applied Cryptography: Protocols, Algorithms, and Source Code in C. Wiley, New York, NY, USA, second edition, 1996. ISBN 0-471-12845-7 (cloth), 0-471-11709-9 (paper); 978-0-471-12845-8 (cloth), 978-0-471-11709-4 (paper). xxiii + 758 pp. LCCN QA76.9.A25 S35 1996. {207, 214, 591} [Sch00] Bruce Schneier. Secrets and Lies: Digital Security in a Networked World. Wiley, New York, NY, USA, 2000. ISBN 0-471-25311-1; 978-0-471- 25311-2. xv + 412 pp. LCCN QA76.9.A25 S352 2000. {214, 591} [Sch03] Bruce Schneier. Beyond Fear: Thinking Sensibly about Security in an Uncertain World. Copernicus Books, New York, NY, USA, 2003. ISBN 0-387-02620-7; 978-0-387-02620-6. 295 pp. LCCN HV6432 .S36 2003. {591} [Sea05] Robert C. Seacord. Secure Coding in C and C++. Addison-Wesley, Reading, MA, USA, 2005. ISBN 0-321-33572-4 (paperback); 978-0- 321-33572-2 (paperback). xxiv + 341 pp. LCCN QA76.9.A25 S368 2005. URL http://www.cert.org/books/secure-coding/. {870} [Sei00] Charles Seife. Zero: The Biography of a Dangerous Idea. Viking, New York, NY, USA, 2000. ISBN 0-670-88457-X, 0-14-029647-6 (paperback); 978-0-670-88457-5, 978-0-14-029647-1 (paperback). vi + 248 pp. LCCN QA141 .S45 2000. {59} [Set13] Sachin Seth. Understanding Java Virtual Machine. Alpha Science International, Oxford, UK, 2013. ISBN 1-84265-815-8; 978-1-84265-815-4. 318 pp. LCCN QA76.73.J38 S437 2013. {viii, 979} [Sev98a] Charles Severance. An interview with the old man of floating-point. Reminiscences elicited from William Kahan. World-Wide Web document, February 1998. URL http://www.cs.berkeley.edu/~wkahan/ieee754status/754story.html. A shortened version appears in [Sev98b]. {63} [Sev98b] Charles Severance. Standards: IEEE 754: An interview with William Kahan. Computer, 31(3):114–115, March 1998. CODEN CPTRB4. ISSN 0018-9162 (print), 1558-0814 (electronic). URL http://pdf.computer.org/co/books/co1998/pdf/r3114.pdf. DOI 10.1109/ MC.1998.10038. {63, 1031} [SF16] Wafaa S. Sayed and Hossam A. H. Fahmy. What are the correct results for the special values of the operands of the power operation? ACM Transactions on Mathematical Software, 42(2):14:1–14:17, June 2016. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/2809783. {413} [Sha45] Claude E. Shannon. A mathematical theory of cryptography. Memorandum MM 45-110-02, Bell Laboratories, Murray Hill, NJ, USA, September 1, 1945. 114 + 25 pp. Classified report. Superseded by [Sha49]. {969, 1031} [Sha48a] Claude E. Shannon. A mathematical theory of communication. The Bell System Technical Journal, 27(3):379–423, July 1948. CODEN BSTJAN. ISSN 0005-8580 (print), 2376-7154 (electronic). DOI 10.1002/j.1538-7305.1948.tb01338.x. From the first page: “If the base 2 is used the resulting units may be called binary digits, or more briefly, bits, a word suggested by J. W. Tukey.”. This is the first known printed instance of the word ‘bit’ with the meaning of binary digit. {969} [Sha48b] Claude E. Shannon. A mathematical theory of communication (continued). The Bell System Technical Journal, 27(4):623–656, October 1948. CODEN BSTJAN. ISSN 0005-8580 (print), 2376-7154 (electronic). DOI 10.1002/j.1538-7305.1948.tb00917.x. {969} [Sha49] Claude E. Shannon. Communication theory of secrecy systems. The Bell System Technical Journal, 28(4):656–715, October 1949. CODEN BSTJAN. ISSN 0005-8580 (print), 2376-7154 (electronic). URL http://bstj.bell-labs.com/BSTJ/images/Vol28/bstj28-4-656.pdf; http://en.wikipedia.org/wiki/Communication_Theory_of_Secrecy_Systems; http://www.cs.ucla.edu/~jkong/research/ security/shannon1949.pdf. DOI 10.1002/j.1538-7305.1949.tb00928.x. A footnote on the initial page says: “The material in this paper appeared in a confidential report, ‘A Mathematical Theory of Cryptography’, dated Sept. 1, 1945 ([Sha45]), which has now been declassified.”. This paper is sometimes cited as the foundation of modern cryptography. {1031} [Sho82] Haim Shore. Simple approximations for the inverse cumulative function, the density function and the loss integral of the normal distribution. Applied Statistics, 31(2):108–114, 1982. CODEN APSTAG. ISSN 0035-9254 (print), 1467-9876 (electronic). URL http:// www.jstor.org/stable/2347972. DOI 10.2307/2347972. {618} [Sid03] Avram Sidi. Practical Extrapolation Methods: Theory and Applications, volume 10 of Cambridge monographs on applied and computational mathematics. Cambridge University Press, Cambridge, UK, 2003. ISBN 0-521-66159-5; 978-0-521-66159-1. xxii + 519 pp. LCCN QA281 .S555 2003. {589} [Sig02] L. E. Sigler. Fibonacci’s Liber Abaci: A Translation into Modern English of Leonardo Pisano’s Book of Calculation. Sources and studies in the history of mathematics and physical sciences. Springer-Verlag, Berlin, Germany / Heidelberg, Germany / London, UK / etc., 2002. ISBN 0-387-95419-8; 978-0-387-95419-6. viii + 636 pp. LCCN QA32 .F4713 2002. DOI 10.1007/978-1-4613-0079-3. This historically important book is the first English translation of the original Latin edition of 1202, on the 800th anniversary of the book that introduced to Europe the Hindu numerals 0 through 9, the word zero, the notion of an algorithm, and the subject of algebra. {15, 59, 575} [Sil06] Joseph H. Silverman. A Friendly Introduction to Number Theory. Pearson Prentice Hall, Upper Saddle River, NJ 07458, USA, third edition, 2006. ISBN 0-13-186137-9; 978-0-13-186137-4. vii + 434 pp. LCCN QA241 .S497 2006. {186} [Sin97] Simon Singh. Fermat’s Enigma: The Epic Quest to Solve the World’s Greatest Mathematical Problem. Walker and Company, New York, NY, USA, 1997. ISBN 0-8027-1331-9; 978-0-8027-1331-5. xiii + 315 pp. LCCN QA244.S55 1997. {60} 1032 Bibliography

[Sin99] Simon Singh. The Code Book: the Evolution of Secrecy from Mary, Queen of Scots, to Quantum Cryptography. Doubleday, New York, NY, USA, 1999. ISBN 0-385-49531-5; 978-0-385-49531-8. xiii + 402 pp. LCCN Z103 .S56 1999. {214, 591} [SK99] Eric M. Schwarz and C. A. Krygowski. The S/390 G5 floating-point unit. IBM Journal of Research and Development, 43(5/6):707–721, September/November 1999. CODEN IBMJAE. ISSN 0018-8646 (print), 2151-8556 (electronic). URL http://www.research.ibm.com/ journal/rd/435/schwarz.html. DOI 10.1147/rd.435.0707. {963} [SKC09] Eric M. Schwarz, John S. Kapernick, and Michael F. Cowlishaw. Decimal floating-point support on the IBM System z10 processor. IBM Journal of Research and Development, 53(1):4:1–4:10, January/February 2009. CODEN IBMJAE. ISSN 0018-8646 (print), 2151-8556 (electronic). URL http://www.research.ibm.com/journal/rd/531/schwarz.pdf. DOI 10.1147/JRD.2009.5388585. {927} [Sko75] Ove Skovgaard. Remark on “Algorithm 236: Bessel functions of the first kind [S17]”. ACM Transactions on Mathematical Software,1 (3):282–284, September 1975. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/355644.355653. See [Gau64]. {693, 1011} [SLF14] Guy L. Steele Jr., Doug Lea, and Christine H. Flood. Fast splittable pseudorandom number generators. ACM SIGPLAN Notices, 49(10):453–472, October 2014. CODEN SINODQ. ISSN 0362-1340 (print), 1523-2867 (print), 1558-1160 (electronic). DOI 10.1145/ 2714064.2660195. {1024} [Slo07] Neil J. A. Sloane. The on-line encyclopedia of integer sequences. Web database, 2007. URL http://oeis.org/. See also [SP95]. {627, 629, 1033} [SLZ02] Damien Stehlé, Vincent Lefèvre, and Paul Zimmermann. Worst cases and lattice reduction. Research report, LORIA/INRIA Lorraine, Villers-lès-Nancy Cedex, France, October 15, 2002. 10 pp. URL http://www.loria.fr/~zimmerma/papers/wclr.ps.gz. {28} [SLZ03] Damien Stehlé, Vincent Lefèvre, and Paul Zimmermann. Worst cases and lattice reduction. In Bajard and Schulte [BS03], pages 142– 147. ISBN 0-7695-1894-X; 978-0-7695-1894-7. ISSN 1063-6889. LCCN QA76.6 .S919 2003. URL http://www.dec.usc.es/arith16/. DOI 10.1109/ARITH.2003.1207672. {28} [SLZ05] Damien Stehlé, Vincent Lefèvre, and Paul Zimmermann. Searching worst cases of a one-variable function using lattice reduction. IEEE Transactions on Computers, 54(3):340–346, March 2005. CODEN ITCOB4. ISSN 0018-9340 (print), 1557-9956 (electronic). URL http://csdl.computer.org/dl/trans/tc/2005/03/t0340.pdf. DOI 10.1109/TC.2005.55. {28} [SM12] Mutsuo Saito and Makoto Matsumoto. A deviation of CURAND: Standard pseudorandom number generator in CUDA for GPGPU. Slides presented at the Tenth International Conference on Monte Carlo and Quasi-Monte Carlo Methods in Scientific Computing, February 2012. URL http://www.mcqmc2012.unsw.edu.au/slides/MCQMC2012_Matsumoto.pdf. {1024} [SMDS11] John K. Salmon, Mark A. Moraes, Ron O. Dror, and David E. Shaw. Parallel random numbers: as easy as 1, 2, 3. In Scott Lathrop, Jim Costa, and William Kramer, editors, SC’11: Proceedings of 2011 International Conference for High Performance Computing, Networking, Storage and Analysis, Seattle, WA, November 12–18 2011, pages 16:1–16:12. ACM Press and IEEE Computer Society Press, New York, NY 10036, USA and Silver Spring, MD, USA, 2011. ISBN 1-4503-0771-X; 978-1-4503-0771-0. LCCN QA76.5 .S96 2011. DOI 10.1145/ 2063384.2063405. {1024} [Smi58] David Eugene Smith. History of Mathematics. Dover histories, biographies and classics of mathematics and the physical sciences. Dover, New York, NY, USA, 1958. ISBN 0-486-20430-8, 0-486-20429-4; 978-0-486-20430-7, 978-0-486-20429-1. xii + 725 pp. LCCN QA21 .S62. {59} [Smi62] Robert L. Smith. Algorithm 116: Complex division. Communications of the Association for Computing Machinery, 5(8):435, August 1962. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). DOI 10.1145/368637.368661. See also an improved version-with- scaling of this algorithm [LDB+00]. {451–453, 455, 1021} [Smi75] Alan Jay Smith. Comments on a paper by T. C. Chen and I. T. Ho. Communications of the Association for Computing Machinery, 18(8):463, August 1975. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). DOI 10.1145/360933.360986. See [CH75]. {1003} [Smi91] David M. Smith. Algorithm 693: A FORTRAN package for floating-point multiple-precision arithmetic. ACM Transactions on Mathematical Software, 17(2):273–283, June 1991. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). URL http://www.acm.org/pubs/citations/journals/toms/1991-17-2/p273-smith/. DOI 10.1145/108556.108585. {827} [Smi95] Roger Alan Smith. A continued-fraction analysis of trigonometric argument reduction. IEEE Transactions on Computers, 44(11):1348– 1351, November 1995. CODEN ITCOB4. ISSN 0018-9340 (print), 1557-9956 (electronic). DOI 10.1109/12.475133. {251, 253} [Smi98] David M. Smith. Algorithm 786: Multiple-precision complex arithmetic and functions. ACM Transactions on Mathematical Software,24 (4):359–367, December 1998. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/293686.293687. See also [Bai95, Bre78b, Bre79, BHY80]. {476, 509, 827, 997, 1000, 1001} [SN05] James E. Smith and Ravi Nair. Virtual Machines: Versatile Platforms for Systems and Processes. Morgan Kaufmann Publishers, San Francisco, CA, USA, 2005. ISBN 1-55860-910-5; 978-1-55860-910-5. xxii + 638 pp. LCCN QA76.9.V5 S54 2005. URL http://www.elsevierdirect.com/product.jsp?isbn=9781558609105. {viii} [SO87] Jerome Spanier and Keith B. Oldham. An Atlas of Functions. Hemisphere Publishing Corporation, Washington, DC, USA, 1987. ISBN 0-89116-573-8, 3-540-17395-1; 978-0-89116-573-6, 978-3-540-17395-3. ix + 700 pp. LCCN QA331 .S685 1987. See also the second edition [OMS09]. {521, 556, 558, 593, 657} [Sor95] Jonathan Sorenson. An analysis of Lehmer’s Euclidean GCD algorithm. In A. H. M. Levelt, editor, ISSAC ’95: Proceedings of the 1995 International Symposium on Symbolic and Algebraic Computation: July 10–12, 1995, Montréal, Canada, ISSAC -PROCEEDINGS- 1995, pages 254–258. ACM Press, New York, NY 10036, USA, 1995. ISBN 0-89791-699-9; 978-0-89791-699-8. LCCN QA 76.95 I59 1995. URL http://www.acm.org:80/pubs/citations/proceedings/issac/220346/p254-sorenson/. DOI 10.1145/220346.220378. ACM order number 505950. {184} Bibliography 1033

[SP95] Neil J. A. Sloane and Simon Plouffe. The Encyclopedia of Integer Sequences. Academic Press, New York, NY, USA, 1995. ISBN 0- 12-558630-2; 978-0-12-558630-6. xiii + 587 pp. LCCN QA246.5 .S66 1995. URL http://oeis.org/. See also the more-recent online resource [Slo07]. {524, 568, 572, 576, 1032} [SR05] W. Richard Stevens and Stephen A. Rago. Advanced Programming in the Unix Environment. Addison-Wesley, Reading, MA, USA, second edition, 2005. ISBN 0-201-43307-9 (hardcover); 978-0-201-43307-4 (hardcover). xxviii + 927 pp. LCCN QA76.76.O63 S754 2005. {91} [SS66] A. H. Stroud and Don Secrest. Gaussian Quadrature Formulas. Prentice-Hall, Upper Saddle River, NJ, USA, 1966. ix + 374 pp. LCCN QA299.4.G3 S7 1966. {560} [SS94] Jeffrey Shallit and Jonathan Sorenson. Analysis of a left-shift binary GCD algorithm. Journal of Symbolic Computation, 17(6):473–486, June 1994. CODEN JSYCEH. ISSN 0747-7171 (print), 1095-855X (electronic). URL http://www.sciencedirect.com/science/article/ pii/S0747717184710303. DOI 10.1006/jsco.1994.1030. {184} [SSB01] Robert F. Stärk, Joachim Schmid, and Egon Börger. Java and the Java Virtual Machine: definition, verification, validation. Springer-Ver- lag, Berlin, Germany / Heidelberg, Germany / London, UK / etc., 2001. ISBN 3-540-42088-6; 978-3-540-42088-0. x + 381 pp. LCCN QA76.73.J38 S785 2001. DOI 10.1007/978-3-642-59495-3. Includes CD-ROM with the entire text of the book and numerous examples and exercises. {viii, 979} [Ste67] Josef Stein. Computational problems associated with Racah algebra. Journal of Computational Physics, 1(3):397–405, February 1967. CODEN JCTPAH. ISSN 0021-9991 (print), 1090-2716 (electronic). URL http://www.sciencedirect.com/science/article/pii/ 0021999167900472. DOI 10.1016/0021-9991(67)90047-2. {184} [Ste74] Pat H. Sterbenz. Floating Point Computation. Prentice-Hall Series in Automatic Computation. Prentice-Hall, Upper Saddle River, NJ, USA, 1974. ISBN 0-13-322495-3; 978-0-13-322495-5. xiv + 316 pp. LCCN QA76.8.I12 S771 1974. {948} [Ste81a] David Stevenson. A proposed standard for binary floating-point arithmetic. Computer, 14(3):51–62, March 1981. CODEN CP- TRB4. ISSN 0018-9162 (print), 1558-0814 (electronic). URL http://ieeexplore.ieee.org/document/1667284/. DOI 10.1109/ C-M.1981.220377. See [IEEE85a]. {63, 1016} [Ste81b] David Stevenson. A Proposed Standard for Binary Floating-Point Arithmetic: Draft 8.0 of IEEE Task P754. IEEE Computer Society Press, Silver Spring, MD, USA, 1981. 36 pp. See [IEEE85a]. {63, 1016} [Ste84] R. G. Stewart. P854 working group completes radix-independent floating-point draft. IEEE Micro, 4(1):82–83, February 1984. CODEN IEMIDZ. ISSN 0272-1732 (print), 1937-4143 (electronic). DOI 10.1109/MM.1984.291326. {104} [Ste85] G. W. Stewart. A note on complex division. ACM Transactions on Mathematical Software, 11(3):238–241, September 1985. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). URL http://www.acm.org/pubs/citations/journals/toms/1985-11-3/ p238-stewart/. DOI 10.1145/214408.214414. See corrigendum [Ste86] and the faster and more robust algorithm in [Pri04]. {452, 453, 455, 476, 1033} [Ste86] G. W. Stewart. Corrigendum: “A note on complex division”. ACM Transactions on Mathematical Software, 12(3):285, September 1986. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/7921.356182. See [Ste85]. {1033} [Ste90] Guy L. Steele Jr. Common Lisp — The Language. Digital Press, Bedford, MA, USA, second edition, 1990. ISBN 1-55558-041-6 (paperback), 1-55558-042-4 (hardcover), 0-13-152414-3 (Prentice-Hall); 978-1-55558-041-4 (paperback), 978-1-55558-042-1 (hardcover), 978-0- 13-152414-9 (Prentice-Hall). xxiii + 1029 pp. LCCN QA76.73.L23 S73 1990. URL http://www.cs.cmu.edu/Groups/AI/html/cltl/ cltl2.html. {341, 476} [Ste93] Frank Stenger. Numerical Methods Based on Sinc and Analytic Functions, volume 20 of Springer Series in Computational Mathemat- ics. Springer-Verlag, Berlin, Germany / Heidelberg, Germany / London, UK / etc., 1993. ISBN 0-387-94008-1 (New York), 3- 540-94008-1 (Berlin); 978-0-387-94008-3 (New York), 978-3-540-94008-1 (Berlin). xv + 565 pp. LCCN QA372 .S82 1993. DOI 10.1007/978-1-4612-2706-9. {733} [Ste11] Guy L. Steele Jr. An interview with Frances E. Allen. Communications of the Association for Computing Machinery, 54(1):39–45, January 2011. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). DOI 10.1145/1866739.1866752. This article contains an important half-century retrospective on the IBM 7030 Stretch project, and its impact on subsequent computer designs. {959} [Sti80] George R. Stibitz. Early computers. In Nicholas Metropolis, Jack Howlett, and Gian-Carlo Rota, editors, A History of Computing in the Twentieth Century: A Collection of Essays, pages 479–483. Academic Press, New York, NY, USA, 1980. ISBN 0-12-491650-3; 978-0-12- 491650-0. LCCN QA75.5 .I63 1976. DOI 10.1016/B978-0-12-491650-0.50034-4. Original versions of these papers were presented at the International Research Conference on the History of Computing, held at the Los Alamos Scientific Laboratory, 10–15 June 1976. {463} [Sti02] John Stillwell. Mathematics and its History. Undergraduate texts in mathematics. Springer-Verlag, Berlin, Germany / Heidelberg, Germany / London, UK / etc., second edition, 2002. ISBN 0-387-95336-1; 978-0-387-95336-6. xviii + 542 pp. LCCN QA21 .S84 2002. DOI 10.1007/978-1-4684-9281-1. {59, 541} [Str59] C. Strachey. On taking the square root of a complex number. The Computer Journal, 2(2):89, July 1959. CODEN CMPJA6. ISSN 0010-4620 (print), 1460-2067 (electronic). URL http://www3.oup.co.uk/computer_journal/hdb/Volume_02/Issue_02/020089.sgm.abs.html; http://www3.oup.co.uk/computer_journal/hdb/Volume_02/Issue_02/tiff/89.tif. DOI 10.1093/comjnl/2.2.89. {481} [Str68] Anthony J. Strecok. On the calculation of the inverse of the error function. Mathematics of Computation, 22(101):144–158, January 1968. CODEN MCMPAF. ISSN 0025-5718 (print), 1088-6842 (electronic). URL http://www.jstor.org/stable/2004772. DOI 10.2307/ 2004772. {600, 603} 1034 Bibliography

[Stu95] Students of Prof.William M.Kahan. UCBTEST: a suite of programs for testing certain difficult cases of IEEE 754 floating-point arithmetic. World-Wide Web document, March 12, 1995. URL http://www.netlib.org/fp/ucbtest.tgz. From the source code, students and authors credited are (in alphabetical order) M. Alemi, D. Feenberg, Warren Ferguson, David G. Hough, David Gay, William J. Cody, Jr., R. Karkinski, Zhi-Shun Alex Liu, S. Ma, Stephen Moshier, M. Mueller, K. C. Ng, Douglas M. Priest, T. Quarles, T. Sumner, G. Taylor, B. Toy, William Waite, and Brian A. Wichmann. {774} [Suz02] Jeff Suzuki. A History of Mathematics. Prentice-Hall, Upper Saddle River, NJ, USA, 2002. ISBN 0-13-019074-8; 978-0-13-019074-1. xiii + 815 pp. LCCN QA21 .S975 2002. {59} [SvG12] Stefan Siegel and Jürgen Wolff von Gudenberg. A long accumulator like a carry-save adder. Computing, 94(2–4):203–213, March 2012. CODEN CMPTA2. ISSN 0010-485X (print), 1436-5057 (electronic). URL http://www.springerlink.com/openurl.asp?genre= article&issn=0010-485X&volume=94&issue=2&spage=203. DOI 10.1007/s00607-011-0164-x. {385} [SW90] Guy L. Steele Jr. and Jon L. White. How to print floating-point numbers accurately. ACM SIGPLAN Notices, 25(6):112–126, June 1990. CODEN SINODQ. ISBN 0-89791-364-7; 978-0-89791-364-5. ISSN 0362-1340 (print), 1523-2867 (print), 1558-1160 (electronic). URL http://www.acm.org:80/pubs/citations/proceedings/pldi/93542/p112-steele/. DOI 10.1145/93548.93559. See also input algorithm in [Cli90, Cli04], and a faster output algorithm in [BD96] and [Knu90], IBM S/360 algorithms in [ABC+99] for both IEEE 754 and S/360 formats, and a twenty-year retrospective in [SW04]. In electronic mail dated Wed, 27 Jun 1990 11:55:36 EDT, Guy Steele reported that an intrepid pre-SIGPLAN 90 conference implementation of what is stated in the paper revealed 3 mistakes: 1. Table 5 (page 124): insert k<-0after assertion, and also delete k<-0from Table 6. 2. Table 9 (page 125): for -1:USER!(""); substitute -1:USER!("0"); and delete the comment. 3. Table 10 (page 125): for fill(-k, "0") substitute fill(-k-1, "0") {895, 896, 995, 998, 1004, 1020, 1034} [SW95] Richard L. Sites and Richard L. Witek. Alpha AXP Architecture Reference Manual. Digital Press, Bedford, MA, USA, second edition, 1995. ISBN 1-55558-145-5; 978-1-55558-145-9. LCCN QA76.9.A73A46 1995. {107} [SW04] Guy L. Steele Jr. and Jon L. White. Retrospective: How to print floating-point numbers accurately. ACM SIGPLAN Notices, 39(4):372– 389, April 2004. CODEN SINODQ. ISSN 0362-1340 (print), 1523-2867 (print), 1558-1160 (electronic). DOI 10.1145/989393.989431. Best of PLDI 1979–1999. Reprint of, and retrospective on, [SW90]. {895, 995, 998, 1004, 1020, 1034} [SW05] Alicja Smoktunowicz and Iwona Wróbel. On improving the accuracy of Horner’s and Goertzel’s algorithms. Numerical Algorithms,38 (4):243–258, April 2005. CODEN NUALEG. ISSN 1017-1398 (print), 1572-9265 (electronic). DOI 10.1007/s11075-004-4570-4. {89} [Swa90a] Earl E. Swartzlander, Jr. Computer Arithmetic, volume 1. IEEE Computer Society Press, Silver Spring, MD, USA, 1990. ISBN 0-8186- 8931-5; 978-0-8186-8931-4. xiii + 378 pp. LCCN QA76.6 .C633 1990. This is part of a two-volume collection of influential papers on the design of computer arithmetic. See also [Swa90b]. {104, 978, 1034} [Swa90b] Earl E. Swartzlander, Jr. Computer Arithmetic, volume 2. IEEE Computer Society Press, Silver Spring, MD, USA, 1990. ISBN 0-8186- 8945-5; 978-0-8186-8945-1. ix + 396 pp. LCCN QA76.9 .C62C66 1990. This is part of a two-volume collection of influential papers on the design of computer arithmetic. See also [Swa90a]. {104, 966, 978, 1034} [Swe65] D. W. Sweeney. An analysis of floating-point addition. IBM Systems Journal, 4(1):31–42, 1965. CODEN IBMSA7. ISSN 0018-8670. URL http://www.research.ibm.com/journal/sj/041/ibmsjIVRID.pdf. DOI 10.1147/sj.41.0031. This important paper describes the analysis that led to the adoption of a hexadecimal base for floating-point arithmetic in IBM System/360, an unfortunate decision that numerical analysts later came to deplore. Reprinted in [Swa90a, pp. 317–328]. {963} [SZ49] Herbert E. Salzer and Ruth Zucker. Tables of the zeros and weight factors of the first fifteen Laguerre polynomials. Bulletin of the American Mathematical Society, 55(10):1004–1012, October 1949. CODEN BAMOAD. ISSN 0002-9904 (print), 1936-881x (electronic). URL http://projecteuclid.org/euclid.bams/1183514167. {560} [SZ04] Damien Stehlé and Paul Zimmermann. Gal’s accurate tables method revisited. World-Wide Web document, 2004. URL http://www.loria.fr/~stehle/downloads/2x-double.txt; http://www.loria.fr/~stehle/downloads/sincos-double.txt; http://www.loria.fr/~stehle/IMPROVEDGAL.html. {28} [SZ05] Damien Stehlé and Paul Zimmermann. Gal’s accurate tables method revisited. In Montuschi and Schwarz [MS05], pages 275–264. ISBN 0-7695-2366-8; 978-0-7695-2366-8. LCCN QA76.9.C62 .S95 2005. URL http://arith17.polito.it/final/paper-152.pdf. DOI 10.1109/ARITH.2005.24. {28} [Szp03] George Szpiro, editor. Kepler’s Conjecture: How Some of the Greatest Minds in History Helped Solve One of the Oldest Math Problems in the World. Wiley, New York, NY, USA, 2003. ISBN 0-471-08601-0; 978-0-471-08601-7. viii + 296 pp. LCCN QA93 .S97 2003. {60} [Szp07] George Szpiro. Poincaré’s Prize: The Hundred-Year Quest to Solve One of Math’s Greatest Puzzles. Dutton, New York, NY, USA, 2007. ISBN 0-525-95024-9; 978-0-525-95024-0. ix + 309 pp. LCCN QA43 .S985 2007. {60} [Tan89] Ping Tak Peter Tang. Table-driven implementation of the exponential function in IEEE floating-point arithmetic. ACM Transactions on Mathematical Software, 15(2):144–157, June 1989. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/ 63522.214389. {271} Bibliography 1035

[Tan06] Hui-Chin Tang. An exhaustive analysis of two-term multiple recursive random number generators with efficient multipliers. Journal of Computational and Applied Mathematics, 192(2):411–416, August 2006. CODEN JCAMDI. ISSN 0377-0427 (print), 1879-1778 (electronic). URL http://dl.acm.org/citation.cfm?id=1148032.1148047. DOI 10.1016/j.cam.2005.06.001. {170, 176} [Tau63] A. H. Taub, editor. John von Neumann: Collected Works. Volume V: Design of Computers, Theory of Automata and Numerical Analysis. Pergamon, New York, NY, USA, 1963. ix + 784 pp. {1036} [TB86] I. J. Thompson and A. R. Barnett. Coulomb and Bessel functions of complex arguments and order. Journal of Computational Physics,64 (2):490–509, June 1986. CODEN JCTPAH. ISSN 0021-9991 (print), 1090-2716 (electronic). DOI 10.1016/0021-9991(86)90046-X. {18} [TC11] Hui-Chin Tang and Hwapeng Chang. An exhaustive search for good 64-bit linear congruential random number generators with restricted multiplier. Computer Physics Communications, 182(11):2326–2330, November 2011. CODEN CPHCBZ. ISSN 0010-4655 (print), 1879-2944 (electronic). URL http://www.sciencedirect.com/science/article/pii/S0010465511002360. DOI 10.1016/j.cpc.2011.06.013. {170} [Tem96] Nico M. Temme. Special Functions: An Introduction to the Classical Functions of Mathematical Physics. Wiley, New York, NY, USA, 1996. ISBN 0-471-11313-1; 978-0-471-11313-3. xii + 374 pp. LCCN QC20.7.F87 T46 1996. {521, 627, 827} [Ten06] M. B. W. Tent. The Prince of Mathematics: Carl Friedrich Gauss. A. K. Peters, Wellesley, MA, USA, 2006. ISBN 1-56881-261-2; 978-1-56881- 261-8. xviii + 245 pp. LCCN QA29.G3 T46 2006. {59} [Ten09] M. B. W. Tent. Leonhard Euler and the Bernoullis: Mathematicians from Basel. A. K. Peters, Wellesley, MA, USA, 2009. ISBN 1-56881-464-X; 978-1-56881-464-3. xix + 276 pp. LCCN QA28 .T46 2009. {591} [TGNSC11] Charles Tsen, Sonia Gonzalez-Navarro, Michael J. Schulte, and Katherine Compton. Hardware designs for binary integer decimal- based rounding. IEEE Transactions on Computers, 60(5):614–627, May 2011. CODEN ITCOB4. ISSN 0018-9340 (print), 1557-9956 (electronic). DOI 10.1109/TC.2010.268. {929} [Tha63] Henry C. Thacher, Jr. Certification of Algorithm 147 [S14]: PSIF. Communications of the Association for Computing Machinery, 6(4):168, April 1963. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). DOI 10.1145/366349.366537. See [Ami62, Par69]. {996, 1027} [Tho70] James E. Thornton. Design of a Computer: the Control Data 6600. Scott, Foresman, Glenview, IL, USA, 1970. 181 pp. LCCN TK7889.C6 T5 1970; TK7889.C2 T5. {951} [Tho80] James E. Thornton. The CDC 6600 project. Annals of the History of Computing, 2(4):338–348, October/December 1980. CODEN AH- COE5. ISSN 0164-1239. URL http://dlib.computer.org/an/books/an1980/pdf/a4338.pdf. DOI 10.1109/MAHC.1980.10044. {949, 951} [Tho97] William J. Thompson. Atlas for Computing Mathematical Functions: an Illustrated Guide for Practitioners with Programs in Fortran 90 and Mathematica. Wiley, New York, NY, USA, 1997. ISBN 0-471-18171-4 (cloth); 978-0-471-18171-2 (cloth). xiv + 888 pp. LCCN QA331.T386 1997. Includes CD-ROM. {520, 521, 556, 558, 567, 583, 593, 595, 644, 657, 693, 827} [TLC93] Shu Tezuka, Pierre L’Ecuyer, and Raymond Couture. On the lattice structure of the add-with-carry and subtract-with-borrow random number generators. ACM Transactions on Modeling and Computer Simulation, 3(4):315–331, October 1993. CODEN ATMCEZ. ISSN 1049-3301 (print), 1558-1195 (electronic). DOI 10.1145/159737.159749. See remark in [EH95, page 248], and [MZ91] for the original work analyzed in this paper. {177, 1026} [TS69] Adilson Tadeu de Medeiros and Georges Schwachheim. Algorithm 349: Polygamma functions with arbitrary precision. Communi- cations of the Association for Computing Machinery, 12(4):213–214, April 1969. CODEN CACMA2. ISSN 0001-0782 (print), 1557-7317 (electronic). DOI 10.1145/362912.362928. See certification [Lew75]. {521, 552, 555, 558, 1021} [TSGN07] Charles Tsen, Michael J. Schulte, and Sonia Gonzalez-Navarro. Hardware design of a binary integer decimal-based IEEE P754 rounding unit. In IEEE, editor, ASAP 07: conference proceedings: IEEE 18th International Conference on Application-Specific Systems, Architectures, and Processors: Montréal, Canada: July 8–11, 2007, pages 115–121. IEEE Computer Society Press, Silver Spring, MD, USA, 2007. ISBN 1-4244-1027-4; 978-1-4244-1027-9. LCCN TK7874.6 .I57a 2007. URL http://ieeexplore.ieee.org/servlet/opac?punumber=4429947. DOI 10.1109/ASAP.2007.4429967. {929} [TSSK07] Son Dao Trong, Martin Schmookler, Eric M. Schwarz, and Michael Kroener. P6 binary floating-point unit. In Kornerup and Muller [KM07], pages 77–86. ISBN 0-7695-2854-6; 978-0-7695-2854-0. ISSN 1063-6889. LCCN QA76.9.C62. URL http://www.lirmm.fr/ arith18/. DOI 10.1109/ARITH.2007.26. The P6 processor is the sixth generation of the IBM POWER and PowerPC architecture. {927} [Tuk58] John W. Tukey. The teaching of concrete mathematics. American Mathematical Monthly, 65(1):1–9, January 1958. CODEN AMMYAE. ISSN 0002-9890 (print), 1930-0972 (electronic). DOI 10.2307/2310294. This article is believed to contain the first published instance of the word ‘software’ in the meaning of instructions to a computer: “Today the ‘software’ comprising the carefully planned interpretive routines, compilers, and other aspects of automative programming are at least as important to the modern electronic calculator as its ‘hardware’ of tubes, transistors, wires, tapes and the like.” [page 2]. {969} [Tur87] Peter R. Turner. The distribution of l.s.d. and its implications for computer design. The Mathematical Gazette, 71(455):26–31, March 1987. CODEN MAGAAS. ISSN 0025-5572 (print), 2056-6328 (electronic). DOI 10.2307/3616283. [l.s.d. = least significant digits]. The topic is variously known as Benford’s Law, the Law of Anomalous Numbers, and Zipf’s Law. {964} [TW99] K. V. Tretiakov and K. W. Wojciechowski. Efficient Monte Carlo simulations using a shuffled nested Weyl sequence random number generator. Physical Review E (Statistical physics, plasmas, fluids, and related interdisciplinary topics), 60(6):7626–7628, December 1999. CODEN PLEEE8. ISSN 1539-3755 (print), 1550-2376 (electronic). URL http://link.aps.org/doi/10.1103/PhysRevE.60.7626. DOI 10.1103/PhysRevE.60.7626. {177} 1036 Bibliography

[Ueb97] Christoph W. Ueberhuber. Numerical Computation: Methods, Software, and Analysis. Springer-Verlag, Berlin, Germany / Heidelberg, Germany / London, UK / etc., 1997. ISBN 3-540-62058-3 (vol. 1: softcover), 3-540-62057-5 (vol. 2: softcover); 978-3-540-62058-7 (vol. 1: softcover), 978-3-540-62057-0 (vol. 2: softcover). xvi + 474 (vol. 1), xvi + 495 (vol. 2) pp. LCCN QA297 .U2413 1997. DOI 10.1007/978-3-642-59118-1. {627} [vA87] Walter van Assche. Asymptotics for Orthogonal Polynomials, volume 1265 of Lecture Notes in Mathematics. Springer-Verlag, Berlin, Germany / Heidelberg, Germany / London, UK / etc., 1987. ISBN 0-387-18023-0 (paperback); 978-0-387-18023-6 (paperback). vi + 201 pp. LCCN QA3 .L28 no. 1265; QA404.5. DOI 10.1007/BFb0081880. {59} [Van92] Charles F. Van Loan. Computational Frameworks for the Fast Fourier Transform. SIAM (Society for Industrial and Applied Mathematics), Philadelphia, PA, USA, 1992. ISBN 0-89871-285-8; 978-0-89871-285-8. xiii + 273 pp. LCCN QA403.5 .V35 1992. {299} [VC06] Joris Van Deun and Ronald Cools. Algorithm 858: Computing infinite range integrals of an arbitrary product of Bessel functions. ACM Transactions on Mathematical Software, 32(4):580–596, December 2006. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/1186785.1186790. {693} [VCV01a] Brigitte Verdonk, Annie Cuyt, and Dennis Verschaeren. A precision- and range-independent tool for testing floating-point arithmetic I: Basic operations, square root, and remainder. ACM Transactions on Mathematical Software, 27(1):92–118, March 2001. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). URL http://www.win.ua.ac.be/~cant/ieeecc754.html. DOI 10.1145/382043.382404. {776, 827} [VCV01b] Brigitte Verdonk, Annie Cuyt, and Dennis Verschaeren. A precision- and range-independent tool for testing floating-point arithmetic II: Conversions. ACM Transactions on Mathematical Software, 27(1):119–140, March 2001. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). URL http://www.win.ua.ac.be/~cant/ieeecc754.html. DOI 10.1145/382043.382405. {776, 827} [Vig16] Sebastiano Vigna. An experimental exploration of Marsaglia’s xorshift generators, scrambled. ACM Transactions on Mathematical Software, 42(4):30:1–30:23, July 2016. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). URL http://dl.acm.org/ citation.cfm?id=2845077. DOI 10.1145/2845077. {1001, 1024, 1028} [vN51] John von Neumann. 13. Various techniques used in connection with random digits. In Alston S. Householder, George E. Forsythe, and Hallett-Hunt Germond, editors, Monte Carlo method. Proceedings of a Symposium Held June 29, 30 and July 1, 1949 in Los Angeles, Cal- ifornia, volume 12 of Applied Mathematics Series / National Bureau of Standards, pages 36–38. United States Government Printing Office, Washington, DC, USA, 1951. URL http://dornsifecms.usc.edu/assets/sites/520/docs/VonNeumann-ams12p36-38.pdf. Summary written by G. E. Forsythe. Reprinted in [Tau63, Paper 23, pp. 768–770]. {190} [VS04] P. W. J. Van Eetvelt and S. J. Shepherd. Accurate, computable approximations to the error function. Mathematics Today, 40(1):25–27, February 2004. ISSN 1361-2042. {600, 606} [Wal96] P. L. Walker. Elliptic Functions: a Constructive Approach. Wiley, New York, NY, USA, 1996. ISBN 0-471-96531-6; 978-0-471-96531-2. xv + 214 pp. LCCN QA343 .W3 1996. {619} [Wal00] H. S. Wall. Analytic Theory of Continued Fractions. American Mathematical Society, Providence, RI, USA, 2000. ISBN 0-8218-2106-7; 978-0-8218-2106-0. xiii + 433 pp. LCCN QA295 .W28 2000. This is a reprint of the definitive, and widely cited, treatise first published in 1948. {19} [War03] Henry S. Warren. Hacker’s Delight. Addison-Wesley, Reading, MA, USA, 2003. ISBN 0-201-91465-4; 978-0-201-91465-8. xiv + 306 pp. LCCN QA76.6 .W375 2003. URL http://www.hackersdelight.org/. While this book does not specifically address computational aspects of floating-point arithmetic (apart from the nine-page Chapter 15), it has extensive coverage of, and clever algorithms for, integer arithmetic operations that are fundamental for implementing hardware floating-arithmetic and software multiple-precision arithmetic. The book’s Web site contains supplementary material in preparation for the second edition [War13]. {166, 176, 978} [War13] Henry S. Warren. Hacker’s Delight. Addison-Wesley, Reading, MA, USA, second edition, 2013. ISBN 0-321-84268-5 (hardcover); 978- 0-321-84268-8 (hardcover). xvi + 494 pp. LCCN QA76.6 .W375 2013. URL http://www.pearsonhighered.com/educator/product/ Hackers-Delight/9780321842688.page. {166, 176, 978, 1036} [Wat95] G. N. Watson. A Treatise on the Theory of Bessel Functions. Cambridge mathematical library. Cambridge University Press, Cambridge, UK, second edition, 1995. ISBN 0-521-48391-3 (paperback), 0-521-06743-X (hardcover); 978-0-521-48391-9 (paperback), 978-0-521- 06743-0 (hardcover). vi + 804 pp. LCCN QA408 .W2 1995. {693} [WE12] Dong Wang and Miloš D. Ercegovac. A radix-16 combined complex division/square root unit with operand prescaling. IEEE Transactions on Computers, 61(9):1243–1255, September 2012. CODEN ITCOB4. ISSN 0018-9340 (print), 1557-9956 (electronic). DOI 10.1109/TC.2011.143. {463} [Web08] Charles F. Webb. IBM z10: The next-generation mainframe microprocessor. IEEE Micro, 28(2):19–29, March/April 2008. CODEN IEMIDZ. ISSN 0272-1732 (print), 1937-4143 (electronic). DOI 10.1109/MM.2008.26. {927} [Wei99] Eric W. Weisstein. The CRC Concise Encyclopedia of Mathematics. CRC Press, Boca Raton, FL, USA, 1999. ISBN 0-8493-9640-9; 978-0- 8493-9640-3. 1969 pp. LCCN QA5.W45 1999. URL http://mathworld.wolfram.com/. {619} [Wei09] Eric W. Weisstein. CRC Encyclopedia of Mathematics. CRC Press/Taylor and Francis, Boca Raton, FL, third edition, 2009. ISBN 1-4200- 7221-8; 978-1-4200-7221-1. 4307 pp. LCCN QA5 .W45 2009. Three hardcover volumes. {58, 569, 572, 576, 579, 587} [WET+10] Liang-Kai Wang, Mark A. Erle, Charles Tsen, Eric M. Schwarz, and Michael J. Schulte. A survey of hardware designs for decimal arithmetic. IBM Journal of Research and Development, 54(2):8:1–8:15, 2010. CODEN IBMJAE. ISSN 0018-8646 (print), 2151-8556 (electronic). URL http://www.research.ibm.com/journal/abstracts/rd/542/wang-schwarz.html. DOI 10.1147/JRD.2010.2040930. {927} [WF82] Shlomo Waser and Michael J. Flynn. Introduction to Arithmetic for Digital Systems Designers. Holt, Reinhart, and Winston, New York, NY, USA, 1982. ISBN 0-03-060571-7; 978-0-03-060571-0. xvii + 308 pp. LCCN TK7895 A65 W37 1982. This book went to press while the IEEE 754 Floating-Point Standard was still in development; consequently, some of the material on that system was invalidated by the final Standard (1985) [IEEE85a]. {1016} Bibliography 1037

[WG89] Z. X. Wang and D. R. Guo. Special Functions. World Scientific Publishing, Singapore, 1989. ISBN 9971-5-0659-9; 978-9971-5-0659-9. xiii + 422 pp. LCCN QA331 .W296 1989. {521, 827} [WH82] Brian A. Wichmann and Ian David Hill. Statistical algorithms: Algorithm AS 183: An efficient and portable pseudo-random number generator. Applied Statistics, 31(2):188–190, June 1982. CODEN APSTAG. ISSN 0035-9254 (print), 1467-9876 (electronic). URL http: //lib.stat.cmu.edu/apstat/183. DOI 10.2307/2347988. See correction [WH84] and remarks [McL85, Zei86]. Reprinted in [GH85, pages 238–242]. See also the extended 32-bit generator in [WH06]. {177, 1024, 1037} [WH84] Brian A. Wichmann and Ian David Hill. Statistical algorithms: Correction: Algorithm AS 183: An efficient and portable pseudorandom number generator. Applied Statistics, 33(1):123, 1984. CODEN APSTAG. ISSN 0035-9254 (print), 1467-9876 (electronic). URL http://www.jstor.org/stable/2347676. DOI 10.2307/2347676. {1037} [WH06] Brian A. Wichmann and Ian David Hill. Generating good pseudo-random numbers. Computational Statistics & Data Anal- ysis, 51(3):1614–1622, December 1, 2006. CODEN CSDADW. ISSN 0167-9473 (print), 1872-7352 (electronic). URL http:// www.sciencedirect.com/science/article/pii/S0167947306001836. DOI 10.1016/j.csda.2006.05.019. This work extends a widely used generator [WH82] developed for 16-bit arithmetic to a new four-part combination generator for 32-bit arithmetic with a period of 2121 ≈ 1036. {177, 1037} [Wic88] Michael J. Wichura. Statistical algorithms: Algorithm AS 241: The percentage points of the normal distribution. Applied Statistics, 37(3):477–484, September 1988. CODEN APSTAG. ISSN 0035-9254 (print), 1467-9876 (electronic). URL http://lib.stat.cmu.edu/ apstat/241. DOI 10.2307/2347330. {600} [Wic92] Brian A. Wichmann. Surveyor’s Forum: “What every computer scientist should know about floating-point arithmetic”. ACM Comput- ing Surveys, 24(3):319, September 1992. CODEN CMSVAN. ISSN 0360-0300 (print), 1557-7341 (electronic). See [Gol91a, Gol91b, Dun92]. {1008, 1013} [Wie99] Thomas Wieder. Algorithm 794: Numerical Hankel transform by the Fortran program HANKEL. ACM Transactions on Mathematical Software, 25(2):240–250, June 1999. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). URL http://www.netlib.org/ toms/794. DOI 10.1145/317275.317284. {693} [Wil02] Robin J. Wilson. Four Colors Suffice: How the Map Problem Was Solved. Princeton University Press, Princeton, NJ, USA, 2002. ISBN 0-691-11533-8; 978-0-691-11533-7. xii + 262 pp. LCCN QA612.19 .W56 2002. {60} [Wir71a] Niklaus Wirth. The design of a PASCAL compiler. Software — Practice and Experience, 1(4):309–333, October/December 1971. CODEN SPEXBL. ISSN 0038-0644 (print), 1097-024X (electronic). DOI 10.1002/spe.4380010403. {949} [Wir71b] Niklaus Wirth. The programming language Pascal. Acta Informatica, 1(1):35–63, January 1971. CODEN AINFA2. ISSN 0001-5903 (print), 1432-0525 (electronic). URL http://link.springer.com/article/10.1007/BF00264291. DOI 10.1007/BF00264291. {949} [Wir76] Niklaus Wirth. Algorithms + Data Structures = Programs. Prentice-Hall Series in Automatic Computation. Prentice-Hall, Upper Saddle River, NJ, USA, 1976. ISBN 0-13-022418-9; 978-0-13-022418-7. xvii + 366 pp. LCCN QA76.6 .W561. {3} [WN95] David J. Wheeler and Roger M. Needham. TEA, a tiny encryption algorithm. Lecture Notes in Computer Science, 1008:363–366, 1995. CODEN LNCSD9. ISSN 0302-9743 (print), 1611-3349 (electronic). URL http://www.springerlink.com/content/p16916lx735m2562/. DOI 10.1007/3-540-60590-8_29. {178, 1026, 1037} [WN98] David J. Wheeler and Roger M. Needham. Correction to XTEA. Report, Cambridge University, Cambridge, UK, October 1998. URL http://www.movable-type.co.uk/scripts/xxtea.pdf. See also original TEA [WN95] and first extension XTEA [NW97]. {178, 1026} [WSH77] J. Welsh, W. J. Sneeringer, and C. A. R. Hoare. Ambiguities and insecurities in Pascal. Software — Practice and Experience, 7(6):685–696, November/December 1977. CODEN SPEXBL. ISSN 0038-0644 (print), 1097-024X (electronic). DOI 10.1002/spe.4380070604. See also [Ker81, Ker84]. {989, 1018} [Wu97] Pei-Chi Wu. Multiplicative, congruential random-number generators with multiplier ±2k1 ± 2k2 and modulus 2p − 1. ACM Transactions on Mathematical Software, 23(2):255–265, June 1997. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). URL http:// www.acm.org/pubs/citations/journals/toms/1997-23-2/p255-wu/. DOI 10.1145/264029.264056. {170} [YM98] Robyn V. Young and Zoran Minderović, editors. Notable Mathematicians: From Ancient Times to the Present. Gale, Detroit, MI, USA, 1998. ISBN 0-7876-3071-3; 978-0-7876-3071-3. xxi + 612 pp. LCCN QA28 .N66 1998. {59} [Ypm95] Tjalling J. Ypma. Historical development of the Newton–Raphson method. SIAM Review, 37(4):531–551, December 1995. CODEN SIREAD. ISSN 0036-1445 (print), 1095-7200 (electronic). URL http://epubs.siam.org/23425.htm; http://link.aip.org/link/ ?SIR/37/531/1. DOI 10.1137/1037125. {8} [ZC70] D. G. Zill and Bille Chandler Carlson. Symmetric elliptic integrals of the third kind. Mathematics of Computation, 24(109):199–214, January 1970. CODEN MCMPAF. ISSN 0025-5718 (print), 1088-6842 (electronic). URL http://www.jstor.org/stable/2004890. DOI 10.2307/2004890. {646, 651} [Zei86] H. Zeisel. Statistical algorithms: Remark ASR 61: a remark on Algorithm AS 183. an efficient and portable pseudo-random number generator. Applied Statistics, 35(1):89, 1986. CODEN APSTAG. ISSN 0035-9254 (print), 1467-9876 (electronic). URL http://www.jstor.org/stable/2347876. See [WH82, McL85]. {1024, 1037} [ZH10] Yong-Kang Zhu and Wayne B. Hayes. Algorithm 908: Online exact summation of floating-point streams. ACM Transac- tions on Mathematical Software, 37(3):37:1–37:13, 2010. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). DOI 10.1145/1824801.1824815. {385} [Zim06] Paul Zimmermann. Worst cases for sin(BIG). World-Wide Web slides, November 2, 2006. URL http://www.loria.fr/~zimmerma/ talks/sinbig.pdf. {28} 1038 Bibliography

[Ziv91] Abraham Ziv. Fast evaluation of elementary mathematical functions with correctly rounded last bit. ACM Transactions on Mathematical Software, 17(3):410–423, September 1991. CODEN ACMSCU. ISSN 0098-3500 (print), 1557-7295 (electronic). URL http://www.acm.org/pubs/citations/journals/toms/1991-17-3/p410-ziv/. DOI 10.1145/114697.116813. {827} [ZJ96] Shanjie Zhang and Jianming Jin. Computation of Special Functions. Wiley, New York, NY, USA, 1996. ISBN 0-471-11963-6; 978-0-471- 11963-0. xxvi + 717 pp. LCCN QA351.C45 1996. {521, 556, 567, 593, 644, 657, 693, 827} [ZM08] Stephen Thomas Ziliak and Deirdre N. McCloskey. The Cult of Statistical Signiﬁcance: How the Standard Error Costs Us Jobs, Justice, and Lives. Economics, cognition, and society. University of Michigan Press, Ann Arbor, MI, USA, 2008. ISBN 0-472-07007-X (cloth), 0- 472-05007-9 (paperback); 978-0-472-07007-7 (cloth), 978-0-472-05007-9 (paperback). xxiii + 321 pp. LCCN HB137 .Z55 2008. This book about the use and abuse of statistics, and the historical background of the t-test, is recommended for all producers and consumers of statistical analyses. {196} [ZOHR01] Abraham Ziv, Moshe Olshansky, Ealan Henis, and Anna Reitman. Accurate portable mathematical library (IBM APMathLib). World-Wide Web document, December 20, 2001. URL ftp://www-126.ibm.com/pub/mathlib/mathlib12.20.2001.tar.gz; http: //oss.software.ibm.com/mathlib/. {827} [ZRP05] Paul Zimmermann, Nathalie Revol, and Patrick Pélissier. mpcheck: a program to test the accuracy of elementary functions. World- Wide Web software archive, 2005. URL http://www.loria.fr/~zimmerma/free/mpcheck-1.1.0.tar.gz; http://www.loria.fr/ ~zimmerma/mpcheck/. {825} [Zwi92] Daniel Zwillinger. Handbook of Integration. Jones and Bartlett, Boston, MA, USA, 1992. ISBN 0-86720-293-9; 978-0-86720-293-9. xv + 367 pp. LCCN QA299.3 .Z85 1992. {58, 560} [Zwi03] Daniel Zwillinger, editor. CRC Standard Mathematical Tables and Formulae. Chapman and Hall/CRC, Boca Raton, FL, USA, 31st edition, 2003. ISBN 1-58488-291-3, 1-4200-3534-7 (electronic); 978-1-58488-291-6, 978-1-4200-3534-6 (electronic). xiv + 910 pp. LCCN QA47 .M315 2003. {58} [Zwi12] Daniel Zwillinger, editor. CRC Standard Mathematical Tables and Formulae. CRC Press, Boca Raton, FL, USA, 32nd edition, 2012. ISBN 1-4398-3548-9; 978-1-4398-3548-7. xiii + 819 pp. LCCN QA47 C73 2012; QA47 .M315 2012. URL http://www.crcpress.com/ CRC-Standard-Mathematical-Tables-and-Formulae-32nd-Edition/Zwillinger/p/book/9781439835487. {58} Author/editor index

IF AUTHORS DID NOT WRITE, WHAT WOULD EDITORS DO?

—ANONYMOUS.

Primary authors are shown in SMALL CAPS, and secondary authors in roman. Page numbers of citations of primary authors are in bold.

A BAKER,JR., GEORGE A. 589 ABBOTT,PAUL H. 895, 998, 1004, 1034 BAKER,LOUIS 521, 556, 558, 567, 583, 589, 593, 657, 682, 827 ABRAMOWITZ,MILTON 6, 58, 59, 196, 269, 301, 303, 341, 498, 521, Balakrishnan, N. see JOHNSON,NORMAN LLOYD, see KOTZ, 560, 562, 587, 589, 593, 600, 619, 624, 632, 638, 643, 651, 657, SAMUEL, 196 661, 666, 673, 675, 678, 681–683, 689, 693, 731, 826 Ball, James S. see BEEBE,NELSON H. F., 521, 525 ABRAMS,BRAD 917 Ballabio, Gerardo see GRANLUND,TORBJÖRN, 401, 407, 825 Abrham, A. see HULL, T. E., 216, 827 BALLARD,G. 385 ADAMS,ARTHUR G. 618 Banks, David see RUKHIN,ANDREW, 200 ADAMS,JEANNE C. 106 BANKS,JERRY 1003, 1021 Adams, Jeanne C. see BRAINERD,WALTER S., 106 Barbin, E. see CHABERT,JEAN-LUC,59 AFFLERBACH,LOTHAR 193 BARDI,JASON SOCRATES 8 AGRESTI,ALAN 196 Barker, Elaine see RUKHIN,ANDREW, 200 Aharoni, M. see DUALE,A.Y.,927 Barnard, George A. see PEARSON,E.S.,196 Ahmed, Ahmed see LYNCH,TOM, 293 BARNETT,A.R. 17 AHRENS,P. 385 Barnett, A. R. see THOMPSON,I.J.,18 ALEXANDRESCU,ANDREI 830 BARROW,JOHN D. 14, 623 Amanatides, John see GRANLUND,TORBJÖRN, 401, 407, 825 Barrow-Green, June see GOWERS,TIMOTHY, 59, 60 AMDAHL,GENE M. 963 BAUDIN,MICHAEL 463 American National Standards Institute see SCHILDT,HERBERT,4 BAYS,CARTER 178, 179, 997, 998, 1022 AMIT,D. 521, 1027, 1035 BEALS,RICHARD 827 AMMANN,URS 949 BEASLEY,J.D. 618 AMOS,DONALD E. 521, 693, 995, 996, 1020 BECKMANN,PETR 14, 59, 623 Anderson, Cristina see CORNEA,MARIUS, 928 BEEBE,NELSON H. F. 15, 73, 521, 525, 952, 954, 978 ANDREWS,GEORGE E. 521, 619, 630, 827 Beebe, Nelson H. F. ix, see ROBBINS,ARNOLD, 873, 1029 ANDREWS,LARRY C. 827 BELL,C.GORDON 954 ANONYMOUS 1014 BELL,ERIC TEMPLE 59 ANSI/IEEE 1, 104, 109, 827, 928, 966 BELL,W.W.(WILLIAM WALLACE) 827 Appelbaum, Jacob see HALDERMAN,J.ALEX, 208 Belozerova, Tatyana see HENNER,VICTOR, 827 ARFKEN,GEORGE B. 8, 196, 303, 582, 627, 693 BENTLEY,JON LOUIS 168 ARMITAGE,J.V. 627 Berggren, J. Lennart see KATZ,VICTOR J., 59 ARNDT,JÖRG 14, 623, 632 BERGGREN,LENNART 14, 59, 623 ARNOLD,KEN vii BERGSON,A. 618, 1015 ASHENHURST,ROBERT L. 960, 966 Berlekamp, Elwyn see GOLOMB,SOLOMON W., 969 Ashihara, Hyo see MATSUMOTO,MAKOTO, 176 Beuning, Brian see GRANLUND,TORBJÖRN, 401, 407, 825 Askey, Richard see ANDREWS,GEORGE E., 521, 619, 630, 827 BIANCOLIN,DAVID 385 ASSCHE,WALTER VAN 59 BLAAUW,GERRIT A. 104, 947, 978 Assche, Walter van see MARCELLÁN,FRANCISCO, 59, 827 Blaauw, Gerrit A. see AMDAHL,GENE M., see BROOKS,JR., AURENTZ,JARED L. 57 FREDERICK P., 963, 969 AYOUB,RAYMOND 579, 590 BLAIR,J.M. 600 BLANCH,G. 13 B BLATNER,DAVID 14, 59, 623 Bachelis, Boris see GAL,SHMUEL, 827 Blouin, François see L’ECUYER,PIERRE, 170 BACKELJAUW,FRANKY 776, 827 BLUE,JAMES L. 223 BAIK,J. 59 BODENSTAB,D.E. 74, 972 BAILEY,B.J.R. 618 BOGOLYUBOV,N.N. 591 BAILEY,DAVID H. 622, 623, 631, 1032 Bohizic, T. J. see DUALE,A.Y.,927 Bailey, David H. see BORWEIN,JONATHAN M., see HIDA,YOZO, BOHLENDER,GERD 366 see LI,XIAOYE S., 268, 366, 407, 452, 622, 624, 631, 632, 777, BOISVERT,RONALD F. 693, 823, 1001 781, 1032 Boisvert, Ronald F. see OLVER,FRANK W. J., 6, 58, 269, 301, 303, BAIN,LEE J. 196 341, 498, 521, 560, 562, 574, 589, 593, 600, 619, 624, 627, 632, BAJARD,JEAN CLAUDE 998, 1005, 1032 653, 657, 661, 666, 673, 675, 678, 682, 689, 693, 826 BAKER,FRANK B. 618 BOJANCZYK,ADAM W. 186

BOLDO,SYLVIE 89, 366, 397, 403, 406, 472, 1002, 1018 CHAN,PATRICK vii Boortz, Kent see GRANLUND,TORBJÖRN, 401, 407, 825 Chang, Hwapeng see TANG,HUI-CHIN, 170 Booth, Michael see GALASSI,MARK, 567, 583, 693, 694, 825 CHEN,TIEN CHI 928, 1032 Börger, Egon viii, see STÄRK,ROBERT F., 979 Cheney, E. W. see HART,JOHN F., 1, 270, 306, 521, 589, 593, 644, Borowczyk, Jacques see CHABERT,JEAN-LUC,59 693, 768, 827 BORWEIN,JONATHAN M. 268, 622–624, 631, 632 CHENG,RUSSELL C. H. 196 Borwein, Jonathan M. see BAILEY,DAVID H., see BERGGREN, CHIHARA,THEODORE SEIO 59 LENNART, 14, 59, 622, 623, 631 Clark III, Clarence W. see ABBOTT,PAUL H., 895, 998, 1004, 1034 Borwein, Peter B. see BAILEY,DAVID H., see BERGGREN, Clark, Charles W. see OLVER,FRANK W. J., 6, 58, 269, 301, 303, LENNART, see BORWEIN,JONATHAN M., 14, 59, 622, 623 341, 498, 521, 560, 562, 574, 589, 593, 600, 619, 624, 627, 632, Bothner, Per see GRANLUND,TORBJÖRN, 401, 407, 825 653, 657, 661, 666, 673, 675, 678, 682, 689, 693, 826 Bowers, K. L. see LUND, J., 733 Clarkson, William see HALDERMAN,J.ALEX, 208 BOX,G.E.P. 193 CLEGG,BRIAN 59 BOYAR,JOAN 207 CLEVELAND,MATHEW A. 385 Bracha, Gilad vii, viii, see GOSLING,JAMES, see LINDHOLM,TIM, CLINGER,WILLIAM D. 895, 896, 995, 998, 1004, 1020, 1034 978, 979 CODY,JR., WILLIAM J. viii, 1, 63, 104, 152, 270, 344, 411, 476, 521, BRADLEY,ROBERT E. 591 525, 593, 644, 693, 763, 769, 823, 939, 949, 1004, 1005, 1016 BRAINERD,WALTER S. 106 Cody, Jr., William J. see FISHERKELLER,M.A.,644 Brainerd, Walter S. see ADAMS,JEANNE C., 106 COHEN,DANNY 956, 963 BRATLEY,PAUL 203 COHEN,HENRI 589 BRENT,RICHARD P. 28, 104, 184, 407, 458, 476, 574, 623, 978, 1000, COLLANGE,SYLVAIN 385 1001, 1024, 1028, 1032 Compton, Katherine see TSEN,CHARLES, 929 Brent, Richard P. see BOJANCZYK,ADAM W., 186 COOLEY,JAMES W. 969 BREZINSKI,CLAUDE 19, 59, 589 Cools, Ronald see VAN DEUN,JORIS, 693 BRISEBARRE,NICOLAS 42, 89 COONEN,JEROME T. 63, 79, 104, 856, 1005, 1016 Brisebarre, Nicolas see MULLER,JEAN-MICHEL, 42, 104, 407, 881, Coonen, Jerome T. see CODY,JR., WILLIAM J., 104, 152 978 COQUEREAUX,R. 689 BROOKS,JR., FREDERICK P. 963, 969 CORNEA,MARIUS 299, 928 Brooks, Jr., Frederick P. see AMDAHL,GENE M., see BLAAUW, Cornea, Marius see BRUGUERA,JAVIER D., 1014 GERRIT A., 104, 947, 963, 978 Couture, Raymond see L’ECUYER,PIERRE, see TEZUKA,SHU, 170, BROUCKE,R. 48, 1028 177, 1026 BRUGUERA,JAVIER D. 1014 Cover, Thomas M. see GOLOMB,SOLOMON W., 969 Brunner, Thomas A. see CLEVELAND,MATHEW A., 385 COWELL,WAYNE R. 823, 826 Brush, David G. see ABBOTT,PAUL H., 895, 998, 1004, 1034 COWLISHAW,MICHAEL F. viii, 109, 387, 433, 897, 927, 928, 968, BRYCHKOV,YURY ALEKSANDROVICH 58, 521, 556, 827 1005 BUCHHOLZ,WERNER 959, 998 Cowlishaw, Michael F. see SCHWARZ,ERIC M., 927 Buchholz, Werner see BROOKS,JR., FREDERICK P., 969 Croarken, Mary see CAMPBELL-KELLY,MARTIN,59 Buckholtz, Thomas J. see KNUTH,DONALD E., 574 Crocker, S. see EASTLAKE,3RD, D., 214 Buckley, Alex vii, viii, see GOSLING,JAMES, see LINDHOLM,TIM, Crone, Chris J. see ABBOTT,PAUL H., 895, 998, 1004, 1034 979 CUYT,ANNIE 19, 58, 776, 827 BULTHEEL,ADHEMAR 59 Cuyt, Annie see BACKELJAUW,FRANKY, see SCHREPPERS, Bünger, Florian see RUMP,SIEGFRIED M., 89 WALTER, see VERDONK,BRIGITTE, 410, 776, 827 BURGER,ROBERT G. 895, 995, 1004, 1034 Cwalina, Krzysztof see ABRAMS,BRAD, 917 BURTON,DAVID M. 59 CYVIN,S.J. 618, 1015 BYRD,PAUL F. 58, 619, 630, 659, 664, 666, 682, 683, 686 D C D’Antonio, Lawrence A. see BRADLEY,ROBERT E., 591 CAI,LIANG-WU 693 Dai, Hui-Hui see JEFFREY,ALAN, 58, 619 CAJORI,FLORIAN 59 Daniel, S. L. see AMOS,DONALD E., 693, 996 Calandrino, Joseph A. see HALDERMAN,J.ALEX, 208 DANIELSON,GORDON C. 969 CALINGER,RONALD 7 Darcy, Joseph D. see KAHAN,WILLIAM M., 4, 64, 105 Calkin, Neil J. see BAILEY,DAVID H., 631 DasSarma, Debjit see BRUGUERA,JAVIER D., 1014 Callaway, Tom see LYNCH,TOM, 293 Dauben, Joseph W. see KATZ,VICTOR J., 59 CAMPBELL,J.B. 693 Daumas, Marc see BOLDO,SYLVIE, 89, 366, 1002 CAMPBELL-KELLY,MARTIN 59 Davies, Jim see GALASSI,MARK, 567, 583, 693, 694, 825 Cantó, Enrique see DESCHAMPS,JEAN-PIERRE, 978 DAVIS,PHILIP J. 560 CARLITZ,L. 600 DEAVOURS,CIPHER A. 1029 Carlough, Steven see LICHTENAU,CEDRIC, 928 Decker, M. H. see DUALE,A.Y.,927 CARLSON,BILLE CHANDLER 623, 644–646, 648–651, 653, 682, 827 Defour, David see COLLANGE,SYLVAIN, see DINECHIN,FLORENT Carlson, Bille Chandler see ZILL, D. G., 646, 651 DE, 28, 385 CARLSON,JAMES A. 60, 303, 521, 579, 590 DeHon, André see KADRIC,EDIN, 385 Carson, E. see BALLARD, G., 385 DEKKER,THEODORUS J. 353, 361, 365, 379 CATLIN,DON 297 Demmel, J. see AHRENS,P.,see BALLARD, G., 385 CAVAGNINO,D. 176 DEMMEL,JAMES 79, 385 CHABERT,JEAN-LUC 59 Demmel, James W. see LI,XIAOYE S., 452, 1032 CHAKRABORTY,KALYAN 827 DENG,LIH-YUAN 176, 1023 Author/editor index . . . E 1041

DERBYSHIRE,JOHN 59, 60, 303, 521, 579, 590 Feshbach, Herman see MORSE,PHILIP MCCORD, 693 Derﬂinger, Gerhard see HÖRMANN,WOLFGANG, 196 FETTIS,HENRY E. 600 DESCHAMPS,JEAN-PIERRE 978 FINCH,STEVEN R. 59 DEVLIN,KEITH J. 15, 59, 60, 303, 521 FINKEL,B.F. 591 Devlin, Keith J. see BORWEIN,JONATHAN M., 631 FISHERKELLER,M.A. 644 DEVORE,JAY L. 196, 610 FISHMAN,GEORGE S. 170, 1010 DEVROYE,LUC 196 Flannery, Brian P. see PRESS,WILLIAM H., 19, 196, 567, 589, 657 DIJKSTRA,EDSGER W. 962, 1020 Flannery, David see FLANNERY,SARAH, 208, 591 DINECHIN,FLORENT DE 28 FLANNERY,SARAH 208, 591 Dinechin, Florent de see MULLER,JEAN-MICHEL, 42, 104, 407, Flood, Christine H. see STEELE JR., GUY L., 1024 881, 978 Flood, Raymond see CAMPBELL-KELLY,MARTIN,59 Djebbar, Ahmed see CHABERT,JEAN-LUC,59 FLYNN,MICHAEL J. 17 Dohse, Fritz-Egbert see DUNNINGTON,GUY WALDO,59 Flynn, Michael J. see WASER,SHLOMO, 1016 DOLZMANN,ANDREAS 28 Forinash, Kyle see HENNER,VICTOR, 827 DOMINICI,DIEGO 600 FORSYTHE,GEORGE E. 472, 474 DONEV,ALEKSANDER 941 FOUSSE,LAURENT 401, 407 Dray, James see RUKHIN,ANDREW, 200 Fox, Bennett L. see BRATLEY,PAUL, 203 Dror, Ron O. see SALMON,JOHN K., 1024 FOX,L. 58 DUALE,A.Y. 927 FOX,PHYLLIS A. 341, 352, 823, 1009, 1010, 1012 DUBRULLE,AUGUSTIN A. 228, 1017, 1024 FRANCESCHETTI,DONALD R. 59 DUNHAM,CHARLES B. 1013, 1037 Franklin, Christine A. see AGRESTI,ALAN, 196 DUNHAM,WILLIAM 59, 541, 591 FRIEDLAND,PAUL 481 DUNNINGTON,GUY WALDO 59 Friedman, Morris D. see BYRD,PAUL F., 58, 619, 630, 659, 664, Durham, S. D. see BAYS,CARTER, 178, 997, 1022 666, 682, 683, 686 DYADKIN,IOSIF G. 170, 189 Fripiat, J. G. see HARRIS,FRANK E., 693 Dybvig, R. Kent see BURGER,ROBERT G., 895, 995, 1004, 1034 FUKUSHIMA,TOSHIO 627, 645, 690 FULLERTON,L.WAYNE 341, 352 E Fullerton, L. Wayne see CODY,JR., WILLIAM J., 693 Eagle, Herbert see KHINCHIN,ALEKSANDR YAKOVLEVICH,19 EASTLAKE,3RD,D. 214 G Eberlein, W. F. see ARMITAGE,J.V.,627 GAL,SHMUEL 827 ECKHOUSE,JR., RICHARD H. 956 GALASSI,MARK 567, 583, 693, 694, 825 Eckhouse, Jr., Richard H. see LEVY,HENRY M., 956 Gallager, Robert G. see GOLOMB,SOLOMON W., 969 ECMA vii, 830, 917, 918 GAMOW,GEORGE 59 Edwards, C. A. see BLAIR,J.M.,600 GANCARZ,MIKE 956 Ehrman, John R. see ABBOTT,PAUL H., 895, 998, 1004, 1034 Garcia-Escartin, Juan Carlos see HERRERO-COLLANTES,MIGUEL, EICHENAUER,JÜRGEN 180 178 EICHENAUER-HERRMANN,JÜRGEN 177, 180, 1026, 1035 Gast, Nicolas see DINECHIN,FLORENT DE,28 Ekedahl, Torsten see GRANLUND,TORBJÖRN, 401, 407, 825 GAUTSCHI,WALTER 58, 59, 562, 591, 693, 705, 1032 EL ATTAR,REFAAT A. 59 GAY,DAVID M. 895, 1009, 1010 ELZEN,BOELIE 952 Gay, David M. see CODY,JR., WILLIAM J., 104, 152 Emde, Fritz see JAHNKE,E.,58 Gentile, Nicholas A. see CLEVELAND,MATHEW A., 385 Enenkel, Robert F. see GUSTAVSON,FRED G., 354 GENTLE,JAMES E. 214 ENGE,ANDREAS 825 GENTLEMAN,M.W. 1023 Engelhardt, Max see BAIN,LEE J., 196 George, Kit see ABRAMS,BRAD, 917 ENTACHER,KARL 170, 172 GIL,AMPARO 13, 17, 18, 58, 567, 644, 693, 827 Ercegovac, Miloš D. see WANG,DONG, 463 GILL,S. 353 ERCEGOVAC,MILOŠ DRAGUTIN 104, 407, 881, 978 Girgensohn, Roland see BAILEY,DAVID H., see BORWEIN, Erle, Mark A. see WANG,LIANG-KAI, 927 JONATHAN M., 631 EULER,LEONHARD 591 Goldberg, Charles H. see BRAINERD,WALTER S., 106 Evans, J. O. see ODEH,R.E.,618 GOLDBERG,DAVID 103, 1008, 1013, 1037 EVES,HOWARD 59 GOLDBERG,I.BENNETT 840, 844, 851 Ewart, Graham W. see ABBOTT,PAUL H., 895, 998, 1004, 1034 Golde, Peter vii, see HEJLSBERG,ANDERS, 80, 917 EYMARD,PIERRE 14, 59, 623 Goldfarb, L. J. B. see BARNETT,A.R.,17 GOLOMB,SOLOMON W. 969 F Gonzales-Vera, Pablo see BULTHEEL,ADHEMAR,59 Fahmy, Hossam A. H. see SAYED,WAFAA S., 413 Gonzalez-Navarro, Sonia see TSEN,CHARLES, 929 Fairgrieve, Thomas F. see HULL, T. E., 476, 996 GOOD,I.J. 169 FALKOFF,A.D. 928 Goodrich, Clark A. see ABBOTT,PAUL H., 895, 998, 1004, 1034 FEIJEN,W.H.J. 1013, 1020 GORDON,ROBERT 979 Feldman, Ariel J. see HALDERMAN,J.ALEX, 208 GOSLING,JAMES vii, 978, 979 FELLMANN,EMIL ALFRED 591 Gosling, James vii, see ARNOLD,KEN Felten, Edward W. see HALDERMAN,J.ALEX, 208 Gosset, William Sealy see PEARSON,E.S.,196 Feng, D. H. see BARNETT,A.R.,17 Gough, Brian see GALASSI,MARK, 567, 583, 693, 694, 825 FERGUSON,JR., WARREN E. 271 GOWERS,TIMOTHY 59, 60 FERGUSON,NIELS 168, 206, 214, 591 Grabowski, Artur see RAADT,THEO DE, 207 1042 Author/editor index . . . J

GRADSHTEYN,I.S. 58, 619, 682, 687 HENNESSY,JOHN L. 103 GRAILLAT,STEF 89, 529 Hennessy, John L. see PATTERSON,DAVID A., 103, 1013 Graillat, Stef see COLLANGE,SYLVAIN, 385 Henry, Greg see LI,XIAOYE S., 452, 1032 GRANLUND,TORBJÖRN 401, 407, 825 HENSLEY,DOUG 19 GRATTAN-GUINNESS,I. 59 HERRERO-COLLANTES,MIGUEL 178 Graves-Morris, Peter see BAKER,JR., GEORGE A., 589 Herrmann, Eva see EICHENAUER-HERRMANN,JÜRGEN, 180 GRAY,JEREMY 579, 590 HERZ-FISCHLER,ROGER 8, 14, 59, 577 Gray, Jeremy see DUNNINGTON,GUY WALDO,59 Heyne, Alice K. see HEYNE,ANDREAS K., 59, 591 GRIES,DAVID 895, 1011, 1020 HEYNE,ANDREAS K. 59, 591 Gries, David see FEIJEN, W. H. J., 1013, 1020 HIDA,YOZO 366, 407, 777, 781 GRIFFITHS,PAUL 1037 Hida, Yozo see DEMMEL,JAMES, see LI,XIAOYE S., 385, 452, 1032 Grosse, Eric see GAY,DAVID M., 1009, 1010 HILL,GEOFFREY W. 693 Grossmann, A. see COQUEREAUX, R., 689 HILL,IAN DAVID 618, 999, 1006, 1015, 1023 Grunkemeyer, Brian see ABRAMS,BRAD, 917 Hill, Ian David see GRIFFITHS,PAUL, see WICHMANN,BRIAN A., Gudenberg, Jürgen Wolff von see SIEGEL,STEFAN, 385 177, 1024, 1037 Guillemot, Michel see CHABERT,JEAN-LUC,59 Hillstrom, K. E. see CODY,JR., WILLIAM J., 521 Guo, D. R. see WANG, Z. X., 521, 827 Ho, Irving T. see CHEN,TIEN CHI, 928, 1032 Gurniak, Paul see KADRIC,EDIN, 385 HOARE,C.A.R. 963 GUSTAFSON,JOHN 960, 967 Hoare, C. A. R. see WELSH, J., 989, 1018 GUSTAVSON,FRED G. 354 Hoemmen, M. see BALLARD, G., 385 GUTMANN,PETER 214 HOLIAN,BRAD LEE 177 Hollman, Joachim see GRANLUND,TORBJÖRN, 401, 407, 825 H Holmes, David vii, see ARNOLD,KEN Hack, Michel see ABBOTT,PAUL H., 895, 998, 1004, 1034 Hooper, Judith A. see BRENT,RICHARD P., 1001, 1032 HACKING,IAN 197 Horiguchi, Tsuyoshi see MORITA,TOHRU, 632 Haenel, Christoph see ARNDT,JÖRG, 14, 623, 632 HÖRMANN,WOLFGANG 196 HALDERMAN,J.ALEX 208 Hormigo, Javier see MONTUSCHI,PAOLO, 104, 1021 Hall, A. D. see FOX,PHYLLIS A., 341, 352, 823, 1010, 1012 HOUGH,DAVID G. 63, 851, 1016 Hallqvist, Niklas see RAADT,THEO DE, 207 Hough, David G. see CODY,JR., WILLIAM J., 104, 152 HAMAKER,HUGO C. 618 Houghton, Thomas F. see BODENSTAB, D. E., 74, 972 Hamilton, Kenneth G. see DYADKIN,IOSIF G., 170, 189 HUBBARD,RAYMOND 196 Handscomb, D. C. see MASON,J.C.,58 HULL,T.E. 216, 476, 827, 996 Hanek, R. N. see PAYNE, M. H., 250, 253 Huskey, Harry D. see HUSKEY,VELMA R., 568 HANROT,GUILLAUME 28 HUSKEY,VELMA R. 568 Hanrot, Guillaume see BRISEBARRE,NICOLAS, see FOUSSE, LAURENT, 42, 89, 401, 407 I HANSEN,ELDON R. 89 Iakymchuk, Roman see COLLANGE,SYLVAIN, 385 Hanson, K. see CODY,JR., WILLIAM J., 104, 152 IEEE 967, 1017, 1019 Hanson, Richard J. see LAWSON,CHARLES L., 223 IFRAH,GEORGES 59 Harley, Robert see GRANLUND,TORBJÖRN, 401, 407, 825 Imhausen, Annette see KATZ,VICTOR J., 59 HARRIS,FRANK E. 693 INTEL 1028 Harris, Frank E. see ARFKEN,GEORGE B., 8, 196, 303, 582, 627, 693 International Electrotechnical Commission see SCHILDT, HARRIS,V.C. 184 HERBERT,4 HARRISON,JOHN 693, 716, 826 International Organization for Standardization see SCHILDT, Harrison, John see BRUGUERA,JAVIER D., see CORNEA,MARIUS, HERBERT,4 299, 928, 1014 IOANNIDIS,JOHN P. A. 196 HARS,LASZLO 184 Ishizaki, Hideharu see FUKUSHIMA,TOSHIO, 645, 690 HART,JOHN F. 1, 270, 306, 521, 589, 593, 644, 693, 768, 827 Iskandar, J. see LI,XIAOYE S., 452, 1032 HASTINGS,JR., CECIL 269, 600, 643, 827 ISO vii, 1, 104, 825, 966 Haubold, H. J. see MATHAI,A.M.,827 ISO/IEC JTC 1 see SCHILDT,HERBERT,4 HAVIL,JULIAN 59, 591 Iverson, K. E. see FALKOFF,A.D.,928 HAWKING,STEPHEN 59, 299, 521 Hayes, Wayne B. see ZHU,YONG-KANG, 385 J Heald, Mark A. see MARION,JERRY B., 693 JABLONSKI,ALEKSANDER 693 HEARN,ANTHONY C. 28 JACKSON,JOHN DAVID 627, 693 Heckert, Alan see RUKHIN,ANDREW, 200 JACOBSON,DAVID 966 Heinrich, Joe see KANE,GERRY, 73, 146 Jaffe, Arthur see CARLSON,JAMES A., 60, 303, 521, 579, 590 HEJLSBERG,ANDERS vii, 80, 917 JAGGER,JON 102, 103, 917 Hejlsberg, Anders see ABRAMS,BRAD, 917 JAHNKE,E. 58 HELLEKALEK,PETER 178 JAMES,F. 177 HELLMAN,HAL 59 JAMIESON,M.J. 228, 1008, 1024 Hemani, Ahmed see MALIK,JAMSHAID SARWAR, 196 JEANNEROD,CLAUDE-PIERRE 28, 458, 463 Hendriksen, Erik see BULTHEEL,ADHEMAR,59 Jeannerod, Claude-Pierre see MULLER,JEAN-MICHEL, see RUMP, Heninger, Nadia see HALDERMAN,J.ALEX, 208 SIEGFRIED M., 42, 89, 104, 407, 881, 978 Henis, Ealan see ZIV,ABRAHAM, 827 JEFFREY,ALAN 58, 619 HENNER,VICTOR 827 Jeffrey, Alan see GRADSHTEYN, I. S., 58, 619, 682, 687 Author/editor index . . . K 1043

JENSEN,KATHLEEN vii, 989 KRASIKOV,ILIA 693 JENTSCHURA,U.D. 693 Kriecherbauer, T. see BAIK,J.,59 Jiang, Renyan see MURTHY,D.N.PRABHAKAR, 196 KROEKER,KIRK L. 949 Jin, Jianming see ZHANG,SHANJIE, 521, 556, 567, 593, 644, 657, Kroener, Michael see TRONG,SON DAO, 927 693, 827 Krogh, Fred T. see LAWSON,CHARLES L., 223 Johnson, J. H. see BLAIR,J.M.,600 Kruh, Louis see DEAVOURS,CIPHER A., 1029 Johnson, J. Howard see MACKAY,STEPHEN A., 354 Krygowski, C. A. see SCHWARZ,ERIC M., 963 JOHNSON,NORMAN LLOYD 196 KULISCH,ULRICH 978 Johnson, Norman Lloyd see KOTZ,SAMUEL, 196 Kuramoto, Ai see MATSUMOTO,MAKOTO, 176 JOHNSTONE,P. 964 JONES,WILLIAM B. 13, 19 L Jones, William B. see CUYT,ANNIE, 19, 58, 776, 827 L’ECUYER,PIERRE 170, 176–178, 196, 200, 214 Joy, Bill vii, see GOSLING,JAMES, 978, 979 L’Ecuyer, Pierre see PANNETON,FRANÇOIS, see TEZUKA,SHU, Joyce, S. A. see HILL,IAN DAVID, 618, 999, 1006, 1015, 1023 177, 1001, 1024, 1026 Jungman, Gerard see GALASSI,MARK, 567, 583, 693, 694, 825 Lafon, Jean-Pierre see EYMARD,PIERRE, 14, 59, 623 LANCZOS,CORNELIUS 521, 536 K Lanczos, Cornelius see DANIELSON,GORDON C., 969 KADRIC,EDIN 385 Lang, Tomás see ERCEGOVAC,MILOŠ DRAGUTIN, 104, 407, 881, KAHAN,WILLIAM M. 4, 64, 69, 81, 105, 251, 259, 265, 353, 472, 978 476, 482, 514, 953, 967, 1000 LANGE,EBERHARD 967 Kahan, William M. see COONEN,JEROME T., see LI,XIAOYE S., LANGLOIS,PHILIPPE 89 see PAXSON,VERN, see CODY,JR., WILLIAM J., 104, 152, 452, Langlois, Philippe see GRAILLAT,STEF,89 1015, 1032 LAPIDUS,MICHEL L. 303, 521, 579 KAHANER,DAVID 202, 299 LAUGWITZ,DETLEFF 579, 590 Kahn, David see DEAVOURS,CIPHER A., 1029 Lauter, Christoph see DINECHIN,FLORENT DE, see KORNERUP, KANE,GERRY 73, 146 PETER, 28, 420 Kanemitsu, Shigeru see CHAKRABORTY,KALYAN, 827 Lautrup, B. E. see COQUEREAUX, R., 689 KAO,CHIANG 170 LAW,AVERILL M. 196 Kapernick, John S. see ABBOTT,PAUL H., see SCHWARZ,ERIC M., LAWDEN,DEREK F. 619, 627, 654, 682, 688 895, 927, 998, 1004, 1034 LAWSON,CHARLES L. 223 KAPLAN,ROBERT 59 Lawson, Charles L. see HART,JOHN F., 1, 270, 306, 521, 589, 593, Kapur, Anil see LI,XIAOYE S., 452, 1032 644, 693, 768, 827 KARPINSKI,RICHARD 773 Lea, Doug see GRANLUND,TORBJÖRN, see STEELE JR., GUY L., Karpinski, Richard see CODY,JR., WILLIAM J., 104, 152 401, 407, 825, 1024 KATZ,VICTOR J. 59 Leader, Imre see GOWERS,TIMOTHY, 59, 60 Keasler, Jeffrey A. see CLEVELAND,MATHEW A., 385 LEARMONTH,G.P. 179, 997, 998 Kelleman, Keith A. see BODENSTAB, D. E., 74, 972 LeBlanc, E. see KAHAN,WILLIAM M., 967 Kemp, Adrienne W. see JOHNSON,NORMAN LLOYD, 196 Lee, Meng see PLAUGER,P.J.,827 KERNIGHAN,BRIAN W. 6, 989, 1018, 1037 Lee, Rosanna vii, see CHAN,PATRICK Keromytis, Angelos D. see RAADT,THEO DE, 207 LEEMIS,LAWRENCE M. 196 KHINCHIN,ALEKSANDR YAKOVLEVICH 19 LEFÈVRE,VINCENT 28, 385 KHRUSHCHEV,SERGEY V. 19, 59 Lefèvre, Vincent see FOUSSE,LAURENT, see HANROT, KIM,EUGENE ERIC 568 GUILLAUME, see KORNERUP,PETER, see MULLER, Kincaid, David R. see LAWSON,CHARLES L., 223 JEAN-MICHEL, see STEHLÉ,DAMIEN, 28, 42, 104, 385, 401, KING,LOUIS VESSOT 663, 1019 407, 420, 881, 978 KLARER,ROBERT 109, 875, 928 Lehmann, Ingmar see POSAMENTIER,ALFRED S., 15 KLERER,MELVIN 947, 978 LEHMER,D.H. 169 KNAPP,ANTHONY W. 222 Lehn, Jürgen see EICHENAUER,JÜRGEN, 180 Knight, N. see BALLARD, G., 385 Leigh, Stefan see RUKHIN,ANDREW, 200 KNÖFEL,A. 385 Levenson, Mark see RUKHIN,ANDREW, 200 KNOWLES,SIMON 1009, 1021 LEVENSON,THOMAS 8 KNUTH,DONALD E. 89, 104, 170, 182, 184, 186, 188, 200, 207, 214, LEVIN,ELI 59 366, 416, 574, 895, 995, 1004, 1007, 1011, 1013, 1020, 1034 LEVY,HENRY M. 956 KODAMA,MASAO 693, 996 LEWIS,JOHN GREGG 1035 Koenig, Jack see BIANCOLIN,DAVID, 385 Lewis, P. A. W. see LEARMONTH, G. P., 179, 997, 998 Kohno, Tadayoshi see FERGUSON,NIELS, 214 Leydold, Josef see HÖRMANN,WOLFGANG, 196 KOREN,ISRAEL 68, 881, 978 Li, Huajiang see DENG,LIH-YUAN, 1023 Korn, Granino A. see KLERER,MELVIN, 947, 978 LI,XIAOYE S. 452, 1032 KORNERUP,PETER 28, 385, 420, 978, 1000, 1002, 1015, 1019, 1022, Li, Xiaoye S. see HIDA,YOZO, see MICHELOGIANNAKIS, 1025, 1028, 1035 GEORGE, 366, 385, 407, 777, 781 Kornerup, Peter see BOHLENDER,GERD, see JEANNEROD, LIANG,SHENG 979, 983 CLAUDE-PIERRE, 366, 458, 463 LICHTENAU,CEDRIC 928 KOTZ,SAMUEL 196 LIN,JINN TYAN 618 Kotz, Samuel see JOHNSON,NORMAN LLOYD, 196 LINDHOLM,TIM viii, 80, 979 KOWALSKI,MAREK A. 733 LINNAINMAA,SEPPO 370 Kramer, Doug vii, see CHAN,PATRICK LIONS,JOHN 850 1044 Author/editor index . . . N

LIU,ZHI-SHUN ALEX 774 Mertens, Irene see PIESSENS,ROBERT, 1001 LIVIO,MARIO 7, 8, 14, 59, 577 Mesztenyi, Charles K. see HART,JOHN F., 1, 270, 306, 521, 589, LOITSCH,FLORIAN 895 593, 644, 693, 768, 827 LORENTZEN,LISA 19 METCALF,MICHAEL 106 Lösch, Friedrich see JAHNKE,E.,58 METROPOLIS,NICHOLAS 203 Lötstedt, E. see JENTSCHURA,U.D.,693 Metropolis, Nicholas see ASHENHURST,ROBERT L., 960, 966 Louvet, Nicolas see GRAILLAT,STEF, see JEANNEROD, Michel-Pajus, Anne see CHABERT,JEAN-LUC,59 CLAUDE-PIERRE, see KORNERUP,PETER, see LANGLOIS, MICHELOGIANNAKIS,GEORGE 385 PHILIPPE, 28, 89, 385, 420, 458, 463 Mikha˘ılov, G. K. see BOGOLYUBOV,N.N.,591 LOZIER,DANIEL W. 826 MILLER,JAMES S. 917 Lozier, Daniel W. see OLVER,FRANK W. J., 6, 58, 269, 301, 303, Miller, Keith W. see PARK,STEPHEN K., 170, 214 341, 498, 521, 560, 562, 574, 589, 593, 600, 619, 624, 627, 632, Miller, P. D. see BAIK,J.,59 653, 657, 661, 666, 673, 675, 678, 682, 689, 693, 826 Minchau, Brian J. see ABBOTT,PAUL H., 895, 998, 1004, 1034 Lu, Henry Horng-Shing see DENG,LIH-YUAN, 176, 1023 Minderovi´c, Zoran see YOUNG,ROBYN V., 59 Lubinsky, Doran S. see LEVIN,ELI,59 MISA,THOMAS J. 962 Luke, D. Russell see BAILEY,DAVID H., 631 Misra, J. see FEIJEN, W. H. J., 1013, 1020 LUKE,YUDELL L. 521, 693, 827 MOLER,CLEVE B. 227, 1008, 1017 LUND,J. 733 Moler, Cleve B. see KAHANER,DAVID, 202, 299 LYNCH,TOM 293 Moll, Victor see BAILEY,DAVID H., 631 MØLLER,OLE 353, 1025 M MONTUSCHI,PAOLO 104, 1000, 1021, 1034 MACDONALD,I.G. 59 Moore III, Louis R. see FISHMAN,GEORGE S., 170, 1010 MACKAY,STEPHEN A. 354 Moraes, Mark A. see SALMON,JOHN K., 1024 MacKenzie, Donald see ELZEN,BOELIE, 952 Moreira, José E. see GUSTAVSON,FRED G., 354 MACLAREN,M.DONALD 179, 618, 1015, 1023 MORITA,TOHRU 632 MACLAREN,N.M. 180 Morris, L. Robert see ECKHOUSE,JR., RICHARD H., 956 Maehly, Hans J. see HART,JOHN F., 1, 270, 306, 521, 589, 593, 644, Morrison, Donald see MOLER,CLEVE B., 227, 1008, 1017 693, 768, 827 MORROW,CHARLENE 59 MALCOLM,M.A. 103, 1012 MORSE,PHILIP MCCORD 693 MALIK,JAMSHAID SARWAR 196 Morse, Stephen P. see PALMER,JOHN F., 63, 104 MAOR,ELI 59, 269 MOSHIER,STEPHEN L. B. 133, 270, 521, 556, 558, 567, 583, 593, MARCELLÁN,FRANCISCO 59, 827 600, 617, 644, 657, 693, 708, 823 Marcey, Joel see ABRAMS,BRAD, 917 Motley, Rose M. see CODY,JR., WILLIAM J., 693 MARION,JERRY B. 693 Mudge, J. Craig see BELL,C.GORDON, 954 MARKSTEIN,PETER 86, 87, 101, 241, 242, 410, 412, 824, 827, 940, Mueller, Silvia Melitta see LICHTENAU,CEDRIC, 928 953 MULLER,JEAN-MICHEL 42, 55, 82, 104, 251, 407, 463, 827, 881, Marovich, S. B. see GENTLEMAN, M. W., 1023 978 MARSAGLIA,GEORGE 170, 176, 177, 200, 207, 618, 1001, 1028, Muller, Jean-Michel see BOLDO,SYLVIE, see JEANNEROD, 1035 CLAUDE-PIERRE, see KORNERUP,PETER, see LEFÈVRE, Marsaglia, George see MACLAREN,M.DONALD, 179 VINCENT, 28, 385, 397, 403, 406, 420, 458, 463, 1000, 1002, Marsaglia, John C. W. see MARSAGLIA,GEORGE, 618 1015, 1022, 1035 Martin, Jeanne T. see ADAMS,JEANNE C., 106 Muller, Mervin E. see BOX,G.E.P.,193 Martin, M. C. see LI,XIAOYE S., 452, 1032 MÜLLER,MICHAEL 385 Martzloff, Jean-Claude see CHABERT,JEAN-LUC,59 MURTHY,D.N.PRABHAKAR 196 MASCAGNI,MICHAEL 158, 1025 Musser, David R. see PLAUGER,P.J.,827 MASON,J.C. 58 Myland, Jan see OLDHAM,KEITH B., 1032 Massey, James L. see GOLOMB,SOLOMON W., 969 MATHAI,A.M. 827 N Matheson, Tahu see HEYNE,ANDREAS K., 59, 591 NAHIN,PAUL J. 14, 59, 591, 623 MATSUMOTO,MAKOTO 176, 177 Nair, Ravi viii, see SMITH,JAMES E. Matsumoto, Makoto see SAITO,MUTSUO, 1024 Narasimhan, B. see MARSAGLIA,GEORGE, 177 MATULA,DAVID W. 840, 851 Nash, Stephen see KAHANER,DAVID, 202, 299 Matula, David W. see BOHLENDER,GERD, see KORNERUP,PETER, NEAL,RADFORD M. 385 366, 978, 1002, 1019, 1025, 1028 NEAVE,HENRY R. 193 McAllister, William H. see KNOWLES,SIMON, 1009, 1021 Nechvatal, James see RUKHIN,ANDREW, 200 McClellan, Alan see GORDON,ROBERT, 979 NEEDHAM,ROGER M. 178, 1037 McCloskey, Deirdre N. see ZILIAK,STEPHEN THOMAS, 196 Needham, Roger M. see WHEELER,DAVID J., 178, 1026, 1037 MCCULLAGH,PETER 543 NEHER,MARKUS 476 McLaughlin, K. T.-R. see BAIK,J.,59 NEUMANN,JOHN VON 190 MCLEISH,JOHN 59 NEVILLE,ERIC HAROLD 678 MCLEOD,A.IAN 1037 NEWMAN,M.E.J. 196 McNamara, John E. see BELL,C.GORDON, 954 NG,K.C. 250 McQueston, Jacquelyn T. see LEEMIS,LAWRENCE M., 196 Nguyen, H. D. see AHRENS, P., 385 Mellen, Greg see DEAVOURS,CIPHER A., 1029 NIEDERREITER,HARALD 203 Melquiond, Guillaume see BOLDO,SYLVIE, see MULLER, Niederreiter, Harald see BRATLEY,PAUL, 203 JEAN-MICHEL, 42, 104, 403, 407, 881, 978 NIEVERGELT,YVES 87 Author/editor index . . . O 1045

Nishimura, Takuji see MATSUMOTO,MAKOTO, 177 PLAUGER,P.J. 133, 827 NIST 178 Plet, Antoine see JEANNEROD,CLAUDE-PIERRE, 463 Njastad, Olav see BULTHEEL,ADHEMAR,59 Plofker, Kim see KATZ,VICTOR J., 59 Nordberg, Linus see GRANLUND,TORBJÖRN, 401, 407, 825 Plouffe, Simon see BAILEY,DAVID H., see SLOANE,NEIL J. A., Notis, Elaine M. see CARLSON,BILLE CHANDLER, 646, 648, 650 524, 568, 572, 576, 622, 623, 1032 PÓLYA,GEORGE 618 O POPOV,BOGDAN A. 600, 604 O’SHEA,DONAL 521, 579 POSAMENTIER,ALFRED S. 15 Oberman, Stuart see MONTUSCHI,PAOLO, 104, 1021 PRESS,WILLIAM H. 19, 196, 567, 589, 657 Oberman, Stuart F. see FLYNN,MICHAEL J., 17 PRIEST,DOUGLAS M. 89, 385, 407, 453–455, 476, 1033 ODEH,R.E. 618 Provos, Niels see RAADT,THEO DE, 207 OGITA,TAKESHI 385 Ogita, Takeshi see OZAKI,KATSUHISA, see RUMP,SIEGFRIED M., R 385 RAADT,THEO DE 207 Oishi, Shin’ichi see OGITA,TAKESHI, see OZAKI,KATSUHISA, see Rabinowitz, Philip see DAVIS,PHILIP J., 560 RUMP,SIEGFRIED M., 385 Rago, Stephen A. see STEVENS,W.RICHARD,91 OLDHAM,KEITH B. 1032 Ragsdale, Susann see MILLER,JAMES S., 917 Oldham, Keith B. see SPANIER,JEROME, 521, 556, 558, 593, 657 RAINVILLE,EARL DAVID 521, 827 Olshansky, Moshe see ZIV,ABRAHAM, 827 RANDELL,BRIAN 104 OLVER,FRANK W. J. 6, 19, 58, 269, 301, 303, 341, 498, 521, 560, RAYMOND,ERIC STEVEN 956 562, 574, 589, 593, 600, 619, 624, 627, 632, 653, 657, 661, 666, Redivo Zaglia, Michela see BREZINSKI,CLAUDE, 589 673, 675, 678, 682, 689, 693, 826, 827 REEDS,JAMES A. 207 OMONDI,AMOS R. 407, 881, 978 REID,CONSTANCE 59 OVERTON,MICHAEL L. 67, 103 Reid, John Ker see METCALF,MICHAEL, 106 OZAKI,KATSUHISA 385 Reitman, Anna see ZIV,ABRAHAM, 827 Revol, Nathalie see MONTUSCHI,PAOLO, see MULLER, P JEAN-MICHEL, see ZIMMERMANN,PAUL, 42, 104, 407, 825, PAGE,E. 618 881, 978, 1021 PAIRMAN,ELEANOR 537 RIBENBOIM,PAULO 590 PALMER,JOHN F. 63, 104 RICE,JOHN R. 31 Palmer, John F. see COONEN,JEROME T., see CODY,JR., WILLIAM Rice, John R. see HART,JOHN F., 1, 270, 306, 521, 589, 593, 644, J., 104, 152 693, 768, 827 Panhaleux, Adrien see JEANNEROD,CLAUDE-PIERRE,28 Richter, Jeffrey see ABRAMS,BRAD, 917 PANNETON,FRANÇOIS 1001, 1024 Riesel, Hans see GRANLUND,TORBJÖRN, 401, 407, 825 PANOFSKY,WOLFGANG K. H. 693 RIPLEY,B.D. 178 PARHAMI,BEHROOZ 68, 881, 978 Ris, Frederic N. see CODY,JR., WILLIAM J., 104, 152 PARK,STEPHEN K. 170, 214 RIVLIN,THEODORE J. 58 Parker, I. B. see FOX,L.,58 ROBBINS,ARNOLD ix, 873, 1029 PARSON,RONALD G. 996, 1035 ROBERTS,C.S. 162 Patrick, Merrell L. see HANSEN,ELDON R., 89 Robson, Eleanor see CAMPBELL-KELLY,MARTIN, see KATZ, PATTERSON,DAVID A. 103, 1013 VICTOR J., 59 Patterson, David A. see HENNESSY,JOHN L., 103 ROCKETT,ANDREW MANSFIELD 19 PATTERSON,S.J. 579 ROCKMORE,DANIEL N. 60, 303, 521, 579, 969 Paul, William see HALDERMAN,J.ALEX, 208 Ronkin, George see BODENSTAB, D. E., 74, 972 PAXSON,VERN 1015 Root, Steve see GRANLUND,TORBJÖRN, 401, 407, 825 Paxson, Vern see HOUGH,DAVID G., 851 ROSE,GREG 177 PAYNE,M.H. 250, 253 Rossi, Fabrice see GALASSI,MARK, 567, 583, 693, 694, 825 PEARSON,E.S. 196 Roy, Ranjan see ANDREWS,GEORGE E., 521, 619, 630, 827 PEARSON,KARL 197 Rüb, Christine see MÜLLER,MICHAEL, 385 Pélissier, Patrick see FOUSSE,LAURENT, see ZIMMERMANN, RUDMAN,PETER STROM 59 PAUL, 401, 407, 825 Ruiz-Antolín, Diego see GIL,AMPARO, 567 Percival, Colin see BRENT,RICHARD P., 458, 476 RUKHIN,ANDREW 200 PERCUS,ORA E. 200, 1026 Rülling, Wolfgang see MÜLLER,MICHAEL, 385 Percus, Ora E. see HOLIAN,BRAD LEE, 177 RUMP,SIEGFRIED M. 89, 385 Perl, Teri see MORROW,CHARLENE,59 Rump, Siegfried M. see OGITA,TAKESHI, 385 Perry, Nigel see JAGGER,JON, 102, 103, 917 RUSSELL,RICHARD M. 952 Petersen, Vigdis B. see CUYT,ANNIE, 19, 58, 776, 827 Ryde, Kevin see GRANLUND,TORBJÖRN, 401, 407, 825 Petry, F. E. see JOHNSTONE, P., 964 RYDER,BARBARA G. 823 PHILIP,J.R. 600 Ryzhik, I. M. see GRADSHTEYN, I. S., 58, 619, 682, 687 PHILLIPS,JEN 826 Phillips, Melba see PANOFSKY,WOLFGANG K. H., 693 S PIESSENS,ROBERT 1001 SABBAGH,KARL 60, 303, 521, 579, 590 Pike, Rob see KERNIGHAN,BRIAN W., 6 SAITO,MUTSUO 1024 Pini, Elena S. see HEYNE,ANDREAS K., 59, 591 SALAMIN,EUGENE 623 Pittman, Tom see COONEN,JEROME T., 104 SALMON,JOHN K. 1024 Plackett, R. L. see PEARSON,E.S.,196 SALUS,PETER H. 956 1046 Author/editor index . . . T

SALZER,HERBERT E. 560 SMITH,DAVID M. 476, 509, 827, 997, 1000, 1001 SANDIFER,CHARLES EDWARD 591 SMITH,JAMES E. viii Sandifer, Charles Edward see BRADLEY,ROBERT E., 591 SMITH,ROBERT L. 451–453, 455, 1021 Saunders, Bonita V. see BOISVERT,RONALD F., 693, 823, 1001 Smith, Robert L. see BAUDIN,MICHAEL, 463 SAUTOY,MARCUS DU 60, 303, 521 SMITH,ROGER ALAN 251, 253 Saxe, James B. see BENTLEY,JON LOUIS, 168 Smith, Sr., Ronald M. see ABBOTT,PAUL H., 895, 998, 1004, 1034 SAYED,WAFAA S. 413 SMOKTUNOWICZ,ALICJA 89 Schan, Edward P. see BODENSTAB, D. E., 74, 972 Sneeringer, W. J. see WELSH, J., 989, 1018 Schell, Thomas see ENTACHER,KARL, 170 SORENSON,JONATHAN 184 SCHILDT,HERBERT 4 Sorenson, Jonathan see SHALLIT,JEFFREY, 184 Schiller, J. see EASTLAKE,3RD, D., 214 Soto, Juan see RUKHIN,ANDREW, 200 SCHMEISER,BRUCE W. 618 SPANIER,JEROME 521, 556, 558, 593, 657 Schmid, Joachim viii, see STÄRK,ROBERT F., 979 Spanier, Jerome see OLDHAM,KEITH B., 1032 Schmookler, Martin see TRONG,SON DAO, 927 Springer, S. G. see BEASLEY,J.D.,618 Schneider, Eric see CORNEA,MARIUS, 928 Srinivasan, Ashok see MASCAGNI,MICHAEL, 158, 1025 SCHNEIER,BRUCE 207, 214, 591 Stallman, Richard see GRANLUND,TORBJÖRN, 401, 407, 825 Schneier, Bruce see FERGUSON,NIELS, 168, 206, 214, 591 STÄRK,ROBERT F. viii, 979 Schoen, Seth D. see HALDERMAN,J.ALEX, 208 Steed, J. W. see BARNETT,A.R.,17 SCHONFELDER,J.L. 600 STEELE JR., GUY L. 341, 476, 895, 896, 959, 995, 998, 1004, 1020, SCHRAGE,LINUS 174, 175, 214 1024, 1034 SCHREPPERS,WALTER 410 Steele Jr., Guy L. vii, see GOSLING,JAMES, 978, 979 SCHRYER,NORMAN L. 775 Stegun, Irene A. see ABRAMOWITZ,MILTON, 6, 58, 59, 196, 269, Schryer, Norman L. see FOX,PHYLLIS A., 341, 352, 823, 1010, 1012 301, 303, 341, 498, 521, 560, 562, 587, 589, 593, 600, 619, 624, Schulte, Michael see MONTUSCHI,PAOLO, 104, 1021 632, 638, 643, 651, 657, 661, 666, 673, 675, 678, 681–683, 689, Schulte, Michael J. see BAJARD,JEAN CLAUDE, see LYNCH,TOM, 693, 731, 826 see TSEN,CHARLES, see WANG,LIANG-KAI, 293, 927, 929, STEHLÉ,DAMIEN 28 998, 1005, 1032 Stehlé, Damien see HANROT,GUILLAUME, see LEFÈVRE, Schwab, Andreas see GRANLUND,TORBJÖRN, 401, 407, 825 VINCENT, see MULLER,JEAN-MICHEL, 28, 42, 104, 407, 881, Schwachheim, Georges see TADEU DE MEDEIROS,ADILSON, 521, 978 552, 555, 558, 1021 STEIN,JOSEF 184 Schwartz, O. see BALLARD, G., 385 STENGER,FRANK 733 SCHWARZ,ERIC M. 927, 963 Stenger, Frank see KOWALSKI,MAREK A., 733 Schwarz, Eric M. see MONTUSCHI,PAOLO, see TRONG,SON DAO, Stepanov, Alexander A. see PLAUGER,P.J.,827 see WANG,LIANG-KAI, 927, 1000, 1021, 1034 STERBENZ,PAT H. 948 SEACORD,ROBERT C. 870 STEVENS,W.RICHARD 91 Seal, David see GRANLUND,TORBJÖRN, 401, 407, 825 STEVENSON,DAVID 63, 1016 Secrest, Don see STROUD,A.H.,560 Stevenson, David see COONEN,JEROME T., see CODY,JR., Segura, Javier see GIL,AMPARO, 13, 17, 18, 58, 567, 644, 693, 827 WILLIAM J., 104, 152 Seidl, Andreas see DOLZMANN,ANDREAS,28 STEWART,G.W. 452, 453, 455, 476, 1033 SEIFE,CHARLES 59 STEWART,R.G. 104 Sestoft, Peter see JAGGER,JON, 102, 103, 917 STIBITZ,GEORGE R. 463 SETH,SACHIN viii, 979 STILLWELL,JOHN 59, 541 SEVERANCE,CHARLES 63, 1031 Stoltz, L. see CODY,JR., WILLIAM J., 521, 593, 693, 769 SHALLIT,JEFFREY 184 STRACHEY,C. 481 SHANNON,CLAUDE E. 969, 1031 STRECOK,ANTHONY J. 600, 603 Shaw, David E. see SALMON,JOHN K., 1024 Strecok, Anthony J. see CODY,JR., WILLIAM J., 521 Shepard, William C. see ABBOTT,PAUL H., 895, 998, 1004, 1034 STROUD,A.H. 560 Shepherd, S. J. see VAN EETVELT, P. W. J., 600, 606 STUDENTS OF PROF.WILLIAM M.KAHAN 774 Shiau, Jyh-Jen H. see DENG,LIH-YUAN, 176, 1023 Sturm, Thomas see DOLZMANN,ANDREAS,28 Shiau, Jyh-Jen Horng see DENG,LIH-YUAN, 1023 Sussenguth, E. H. see FALKOFF,A.D.,928 SHORE,HAIM 618 Sutter, Gustavo D. see DESCHAMPS,JEAN-PIERRE, 978 SIDI,AVRAM 589 SUZUKI,JEFF 59 SIEGEL,STEFAN 385 SWARTZLANDER,JR., EARL E. 104, 966, 978, 1034 SIGLER,L.E. 15, 59, 575 SWEENEY,D.W. 963 Sikorski, Krzysztof A. see KOWALSKI,MAREK A., 733 SZPIRO,GEORGE 60 SILVERMAN,JOSEPH H. 186 Szüsz, Peter see ROCKETT,ANDREW MANSFIELD,19 Simard, Richard see L’ECUYER,PIERRE, 170, 176, 178, 200, 214 SINGH,SIMON 60, 214, 591 T SITES,RICHARD L. 107 TADEU DE MEDEIROS,ADILSON 521, 552, 555, 558, 1021 Sjödin, Gunnar see GRANLUND,TORBJÖRN, 401, 407, 825 Tallman, Richard see ABBOTT,PAUL H., 895, 998, 1004, 1034 SKOVGAARD,OVE 693, 1011 TANG,HUI-CHIN 170, 176 SLOANE,NEIL J. A. 524, 568, 572, 576, 627, 629, 1032, 1033 TANG,PING TAK PETER 271 Smid, Miles see RUKHIN,ANDREW, 200 Tang, Ping Tak Peter see CORNEA,MARIUS, see HULL, T. E., 299, SMITH,ALAN JAY 1003 476, 928, 996 Smith, Brian T. see ADAMS,JEANNE C., 106 TAUB,A.H. 1036 SMITH,DAVID EUGENE 59 TEMME,NICO M. 521, 627, 827 Author/editor index . . . U 1047

Temme, Nico M. see GIL,AMPARO, 13, 17, 18, 58, 567, 644, 693, WANG,DONG 463 827 WANG,LIANG-KAI 927 TENT,M.B.W. 59, 591 Wang, Richard L. C. see HANSEN,ELDON R., 89 Teukolsky, Saul A. see PRESS,WILLIAM H., 19, 196, 567, 589, 657 WANG,Z.X. 521, 827 TEZUKA,SHU 177, 1026 Warnock, Tony T. see HOLIAN,BRAD LEE, 177 THACHER,JR., HENRY C. 996, 1027 WARREN,HENRY S. 166, 176, 978, 1036 Thacher, Jr., Henry C. see CODY,JR., WILLIAM J., 521 WASER,SHLOMO 1016 Thatcher, Jr., Henry G. see HART,JOHN F., 1, 270, 306, 521, 589, Watanabe, Akio see ABBOTT,PAUL H., 895, 998, 1004, 1034 593, 644, 693, 768, 827 WATSON,G.N. 693 Theiler, James see GALASSI,MARK, 567, 583, 693, 694, 825 WEBB,CHARLES F. 927 Théveny, Philippe see ENGE,ANDREAS, 825 Weber, Hans-Jürgen see ARFKEN,GEORGE B., 8, 196, 303, 582, THOMPSON,I.J. 18 627, 693 THOMPSON,WILLIAM J. 520, 521, 556, 558, 567, 583, 593, 595, Weber, Ken see GRANLUND,TORBJÖRN, 401, 407, 825 644, 657, 693, 827 Wegenkittl, Stefan see EICHENAUER-HERRMANN,JÜRGEN, see THORNTON,JAMES E. 949, 951 HELLEKALEK,PETER, 178, 180 Thorsen, Hans see GRANLUND,TORBJÖRN, 401, 407, 825 WEISSTEIN,ERIC W. 58, 569, 572, 576, 579, 587, 619 Thron, Wolfgang J. see JONES,WILLIAM B., 13, 19 WELSH,J. 989, 1018 Tisdale, Robert see LYNCH,TOM, 293 Wenzel, Klaus see AFFLERBACH,LOTHAR, 193 Togersen, Mads see HEJLSBERG,ANDERS, 917 Werbrouck, A. E. see CAVAGNINO, D., 176 Toole, Betty Alexandra see KIM,EUGENE ERIC, 568 Weston, M. K. see AMOS,DONALD E., 693, 996 Torres, Serge see MULLER,JEAN-MICHEL, 42, 104, 407, 881, 978 WHEELER,DAVID J. 178, 1026, 1037 Trefethen, Lloyd N. see AURENTZ,JARED L., 57 Wheeler, David J. see NEEDHAM,ROGER M., 178, 1037 TRETIAKOV,K.V. 177 White, Jon L. see STEELE JR., GUY L., 895, 896, 995, 998, 1004, TRONG,SON DAO 927 1020, 1034 Tsang, Wai Wan see MARSAGLIA,GEORGE, 200 White, W. Romney see ABBOTT,PAUL H., 895, 998, 1004, 1034 TSEN,CHARLES 929 Whitlock, Paula A. see HOLIAN,BRAD LEE, see PERCUS,ORA E., Tsen, Charles see CORNEA,MARIUS, see WANG,LIANG-KAI, 927, 177, 200, 1026 928 WICHMANN,BRIAN A. 177, 1008, 1013, 1024, 1037 Tsukada, Haruo see CHAKRABORTY,KALYAN, 827 WICHURA,MICHAEL J. 600 TUKEY,JOHN W. 969 WIEDER,THOMAS 693 Tukey, John W. see COOLEY,JAMES W., 969 Wiles, Andrew see CARLSON,JAMES A., 60, 303, 521, 579, 590 Tung, T. see LI,XIAOYE S., 452, 1032 WILSON,ROBIN J. 60 TURNER,PETER R. 964 Wiltamuth, Scott vii, see HEJLSBERG,ANDERS, 80, 917 WIRTH,NIKLAUS 3, 949 U Wirth, Niklaus vii, see JENSEN,KATHLEEN, 989 UEBERHUBER,CHRISTOPH W. 627 Witek, Richard L. see SITES,RICHARD L., 107 Uhl, Andreas see ENTACHER,KARL, 170 Witzgall, Christoph see HART,JOHN F., 1, 270, 306, 521, 589, 593, Ulam, Stanisław see METROPOLIS,NICHOLAS, 203 644, 693, 768, 827 Wojciechowski, K. W. see TRETIAKOV,K.V.,177 V Wong, J. Y. see KAO,CHIANG, 170 Wong, R. (Roderick) see BEALS,RICHARD, 827 VAN DEUN,JORIS 693 Wróbel, Iwona see SMOKTUNOWICZ,ALICJA,89 VAN EETVELT,P.W.J. 600, 606 WU,PEI-CHI 170 van Gasteren, A. J. M. see FEIJEN, W. H. J., 1013, 1020 VAN LOAN,CHARLES F. 299 Vangel, Mark see RUKHIN,ANDREW, 200 X VERDONK,BRIGITTE 776, 827 Xie, Min see MURTHY,D.N.PRABHAKAR, 196 Verdonk, Brigitte see CUYT,ANNIE, 19, 58, 776, 827 Xu, Hongquan see DENG,LIH-YUAN, 1023 Verschaeren, Dennis see VERDONK,BRIGITTE, 776, 827 Vetterling, William T. see PRESS,WILLIAM H., 19, 196, 567, 589, Y 657 Yee, Bennet see GRANLUND,TORBJÖRN, 401, 407, 825 VIGNA,SEBASTIANO 1001, 1024, 1028 Yellin, Frank viii, see LINDHOLM,TIM, 80, 979 Villegas, Fernando Rodriguez see COHEN,HENRI, 589 Yohe, J. Michael see BRENT,RICHARD P., 1001, 1032 Viterbi, Andrew J. see GOLOMB,SOLOMON W., 969 Yoo, D. J. see LI,XIAOYE S., 452, 1032 Vo, San see RUKHIN,ANDREW, 200 YOUNG,ROBYN V. 59 YPMA,TJALLING J. 8 W Yushkevich, A. P. see BOGOLYUBOV,N.N.,591 Waadeland, Haakon see CUYT,ANNIE, see LORENTZEN,LISA, 19, 58, 776, 827 Z Wada, Isaku see MATSUMOTO,MAKOTO, 176 Zagier, Don see COHEN,HENRI, 589 Wagener, Jerrold L. see ADAMS,JEANNE C., 106 Zaman, Arif see MARSAGLIA,GEORGE, 177, 200, 618, 1028, 1035 Waite, William viii, see CODY,JR., WILLIAM J., 1, 270, 344, 411, ZEISEL,H. 1024, 1037 763, 823, 939 ZHANG,SHANJIE 521, 556, 567, 593, 644, 657, 693, 827 WALKER,P.L. 619 ZHU,YONG-KANG 385 Walkowiak, Steven see ABBOTT,PAUL H., 895, 998, 1004, 1034 ZILIAK,STEPHEN THOMAS 196 WALL,H.S. 19 ZILL,D.G. 646, 651 Walter, W. see BOHLENDER,GERD, 366 ZIMMERMANN,PAUL 28, 825 1048 Author/editor index . . . Z

Zimmermann, Paul see BRENT,RICHARD P., see ENGE,ANDREAS, see FOUSSE,LAURENT, see GRANLUND,TORBJÖRN, see HANROT,GUILLAUME, see LEFÈVRE,VINCENT, see STEHLÉ, DAMIEN, 28, 104, 401, 407, 458, 476, 574, 825, 978 Zipperer, H.-G. see DUALE,A.Y.,927 ZIV,ABRAHAM 827 Zucker, Ruth see SALZER,HERBERT E., 560 ZWILLINGER,DANIEL 58, 560 Zwillinger, Daniel see GRADSHTEYN, I. S., 58, 619, 682, 687 Function and macro index

FUNCTION:AMATHEMATICAL QUANTITY WHOSE CHANGES OF VALUE DEPEND ON THOSE OF OTHER QUANTITIES CALLED ITS VARIABLES. — New Century Dictionary (1914).

MACRO:ANAME (POSSIBLY FOLLOWED BY A FORMAL arg LIST) THAT IS EQUATED TO A TEXT OR SYMBOLIC EXPRESSION TO WHICH IT IS TO BE EXPANDED (POSSIBLY WITH THE SUBSTITUTION OF ACTUAL ARGUMENTS) BY A MACRO EXPANDER. — The New Hacker’s Dictionary (1996).

Page numbers of defining and primary entries are shown in bold. The entries for algorithm, function, macro, and mathematical function each contain a lengthy list of subentries. Uppercase macro names followed by empty parentheses are often wrappers for integer, binary floating-point, and decimal floating-point functions of all supported lengths. Greek letters are indexed by their English names.

Symbols _cvtpow( ) function 884, 890, 898 992 -FP_T_MAX macro 398 _cvtsgn( ) function 881, 886, 890, 901 acosh( ) function (mathematical) 43, 62, %REF( ) function 941 _cvtupper( ) function 847, 848 348–350, 517, 518, 624, 654 %VAL( ) function 941 _pxy( ) function 430 Acoshf( ) function 913–915, 921 _FPU_GETCW( ) macro 125, 126 _pxydl( ) function 439 acoshf( ) function 350, 913, 921, 992 _FPU_SETCW( ) macro 125, 126 _pxyl( ) function 439 Acoshl( ) function 913, 914 _IPOW( ) macro 417–419 _pxyll( ) function 430 acoshl( ) function 913, 921, 992 _Imaginary_I macro 441, 441 _reddll( ) function 307 Acosl( ) function 913, 914 _MAXRANL macro 213 _rp( ) function 308 acosl( ) function 913, 921, 925, 992 _XPG4 macro 163 _rph( ) function 308 acosp( ) function 59 _ _FILE_ _ macro 74 acospi( ) function 59 _ _FP_FAST_FMAF_ _ macro 392 A ACOSSIN( ) macro 325, 326, 331, 331 _ _FP_FAST_FMA_ _ macro 392 aam( ) function (mathematical) 665–667 acot( ) function 654–656 _ _GNUC_ _ macro 391 ab( ) function (mathematical) 678 acot( ) function (mathematical) 654 _ _INV_LOG_B macro 782 Abs( ) function 922 acoth( ) function 654–656 _ _LINE_ _ macro 74 abs( ) function 57, 191, 711, 782, 922 acoth( ) function (mathematical) 654 _ _LN_MAXNORMAL macro 782 abs( ) function (Maple) 551, 609 acs( ) function (mathematical) 665, 667 _ _LN_MINSUBNORMAL macro 782 Abs[] function (Mathematica) 41 adc( ) function (mathematical) 665, 667 _ _LOG_B macro 782 ABS( ) macro 245, 246, 444 adn( ) function (mathematical) 665–667 _ _LOG_B_HI macro 782 ABSF( ) function 961 ads( ) function (mathematical) 665, 667 _ _LOG_B_LO macro 782 absf( ) function 922 Adx( ) function 913 _ _MACHEPS_ _ macro 782 absl( ) function 922 adx( ) function 59, 913, 981 _ _STDC_IEC_559_ _ macro 219 AccSum( ) function 385 Adxf( ) function 913 _ _STDC_IEC_559_COMPLEX_ _ macro 442 AccSumK( ) function 385 adxf( ) function 913 _ _asm_ _( ) macro 293, 339, 391, 392 acd( ) function (mathematical) 665, 667 Adxl( ) function 913 _ _cplusplus macro 983, 984 acn( ) function (mathematical) 665–667 adxl( ) function 913 __acs( ) function 325 Acos( ) function 913, 914, 921 agm( ) function 59, 620, 622, 634 _controlfp_s( ) function 125 acos( ) function 43, 44, 58, 62, 323, _cvits( ) function 846 654–656, 763, 826, 827, 913, 921, 925, agm( ) function (mathematical) 620, 624, _cvtcmp( ) function 882, 886, 886, 887, 981, 983, 992 631–635, 638, 640 889, 901 acos( ) function (mathematical) 43, 62, AGM( ) macro 620, 621, 633, 636 _cvtdir( ) function 845, 848, 849, 893, 323–325, 504, 507, 624, 646, 654, 656, AGM_function( ) function 620 894 665–667, 801, 803, 804, 812 Ai( ) function (mathematical) 695 _cvtfsf( ) function 884, 892, 897 ACOS( ) macro xxv, 325, 326, 509 aint( ) function 129 _cvtgpn( ) function 863 acosdeg( ) function 59 alias( ) function (Maple) 717, 724 _cvtgrp( ) function 862 Acosf( ) function 913–915, 921 altsum( ) function 589, 589, 590 _cvtinf( ) function 887 acosf( ) function 326, 913, 921, 925, 983, am( ) function (mathematical) 657–662, _cvtisf( ) function 884, 893 992 665, 683, 691 _cvtits( ) function 846, 858, 862 Acosh( ) function 913, 914, 921 amod( ) function 129 _cvtjus( ) function 847, 858 acosh( ) function 43, 44, 58, 62, 348, 350, anc( ) function (mathematical) 665, 667 _cvtnan( ) function 889 352, 654–656, 808, 826, 913, 921, 981, and( ) function 206

© Springer International Publishing AG 2017 1049 N.H.F. Beebe, The Mathematical-Function Computation Handbook, DOI 10.1007/978-3-319-64110-2 1050 Function and macro index . . . C and( ) function (mathematical) 175, 665, atanh( ) function 44, 58, 61, 62, 96, 348, bi1( ) function xxviii, 59, 719, 725, 727 667 352, 654–656, 808, 826 BI1( ) macro 760, 761 anint( ) function 129 atanh( ) function (mathematical) 61, 62, BigMul( ) function 57 annuity( ) function 59, 294, 295–298 96–99, 348, 350, 504, 517, 518, 606, bin( ) function xxviii, 59, 62, 719, 728 ans( ) function (mathematical) 665, 667 631, 654 BIN( ) macro 761 app_ierf( ) function (Maple) 606, 606 ATANH( ) macro 350 binarySearch( ) function 976 arccos( ) function 323 atanhd( ) function 350 binfp( ) function 851 arccos( ) function (Maple) 10 atanhdf( ) function 350 binom( ) function 59 Arccosf( ) function 914 atanhf( ) function 350 BINOM( ) macro 591 Arccosf( ) macro 913 atanp( ) function 59 binsearch( ) function 425, 426, 439 arcsin( ) function 323 atanpi( ) function 59 bis0( ) function xxviii, 59, 719, 725, 729 arcsin( ) function (Maple) 10 atof( ) function 896, 899, 901 BIS0( ) macro 725 ArcSin[] function (Mathematica) 21 atoi( ) function 896 bis1( ) function xxviii, 59, 719, 725, 730 Arcsinf( ) function 914 atol( ) function 896 bisn( ) function xxviii, 59, 719, 731 Arcsinf( ) macro 913 BISN( ) macro 761 arctan( ) function (Maple) 10 B bitsof( ) macro 256, 256 bk0( ) Arctanf( ) macro 913 Bn( ) function (mathematical) 987 function xxviii, 59, 719, 728, 732 arctanh( ) function (Maple) 607 B macro 307, 308, 345, 633, 636, 640, 643, bk1( ) function xxviii, 59, 719, 728, 733 arg( ) function 826 708, 780, 791 bkn( ) function xxviii, 59, 62, 719, 729, arg( ) function (mathematical) 446, 570 B_TO_CEIL_HALF_T macro 331 734 ArithmeticGeometricMean[] function B_TO_MINUS_HALF_T macro 331 bks0( ) function xxviii, 59, 719, 726, 729, (Mathematica) 620 B_TO_T macro 250 735 array( ) function (Maple) 623 B_TO_T_MINUS_ONE macro 135, 139 bks1( ) function xxviii, 59, 719, 726, 729, asc( ) function (mathematical) 666, 667 BASE macro 155, 354 736 asd( ) function (mathematical) 666, 667 bei( ) function (mathematical) 695 bksn( ) function xxviii, 59, 719, 729, 737 asin( ) function 44, 58, 62, 323, 654–656, ber( ) function (mathematical) 695 BKSN( ) macro 730 763, 826, 827 bern( ) function 569 Block[] function (Mathematica) 39, 40 asin( ) function (mathematical) 44, 62, bernfrac( ) function 569 BM_FMA( ) macro 406, 406 323–325, 504, 517, 630, 653, 654, 661, Bernoulli( ) function 569 662, 665–667, 801, 803, 804, 812 bernoulli( ) function 569 C ASIN( ) macro xxv, 325, 327, 663 bernoulli( ) function (Maple) 569, 570 Cn( ) function (mathematical) 695 asindeg( ) function 59, 340 BernoulliB[] function (Mathematica) cabs( ) function 442, 445, 479, 495 asinh( ) function 44, 58, 62, 348, 350, 569 CABS( ) macro 445 352, 654–656, 808, 826 bernum( ) function 59, 571 cacos( ) function xxvi, 479, 506, 507, 510 asinh( ) function (mathematical) 62, BERNUM( ) macro 572, 585 CACOS( ) macro 509 348–350, 504, 517, 518, 654, 667 bessel_j( ) function 694 cacosh( ) function xxvi, 479, 516–519 asinp( ) function 59, 340 bessel_j0( ) function 694 CACOSH( ) macro 517 asinpi( ) function 59, 340 bessel_y( ) function 694 cadd( ) function 59, 445 asm( ) function 824 BesselI( ) function (Maple) 724 CADD( ) macro 445 asn( ) function (mathematical) 666, 667 BesselI[] function (Mathematica) 751 carg( ) function 446, 479, 495 asplit( ) function (Maple) 247, 247 BesselJ( ) function 694 CARG( ) macro 446 assert( ) function 181, 182, 186, 187 besselJ( ) function 694 casin( ) function xxvi, 479, 506, 510 assert macro 164, 424, 837, 839, besselj( ) function 694 CASIN( ) macro 509 844–846, 855 BesselJ[] function (Mathematica) 694 casinh( ) function xxvi, 479, 516, 518, assert( ) macro 255, 256, 259, 263, 264, BesselJZeros( ) function (Maple) 697 519 425, 437, 861 BesselK( ) function (Maple) 726 CASINH( ) macro 517 assume( ) function (Maple) 623 besseln( ) function 694 catan( ) function xxvi, 479, 506, 510 asympt( ) function (Maple) 615 BesselY( ) function 694 CATAN( ) macro 509 atan( ) function 58, 62, 331, 336, besselY( ) function 694 catanh( ) function xxvi, 479, 516, 518, 654–656, 763, 765, 824, 826, 827 BesselY[] function (Mathematica) 694 519 atan( ) function (mathematical) 62, 79, BesselYZeros( ) function (Maple) 697 CATANH( ) macro 517 331–333, 338, 340, 408, 504, 517, 539, β( ) function (mathematical) 587, 587, cbrt( ) function 44, 58, 62, 237, 237, 240, 623, 631, 654, 659, 661, 801–804, 812 588, 589 479, 485, 982 ATAN( ) macro xxv, 333, 335, 338, 338, 804 beta( ) function 59, 590 cbrt( ) function (mathematical) 62, 238, atan2( ) function 58, 70, 71, 202, 336, BETA( ) macro 590 485, 486 336, 338, 340, 445, 479, 763, 827 betam1( ) function 59, 590, 773 CBRT( ) macro 379, 487 atan2( ) function (mathematical) xxxi, 71, BETAM1( ) macro 590, 592 cbrtf( ) function 240 336, 338, 495, 812 betnm1( ) function 59, 590 cbrtl( ) function 240 ATAN2( ) macro 445, 463 BETNM1( ) macro 590, 592 CC macro xxxvi atan2deg( ) function 59 betnum( ) function 59, 590 ccbrt( ) function xxvi, 479, 485–488 atan2f( ) function 71, 336 bfpsi( ) function 548 CCBRT( ) macro 487 atan2l( ) function 71, 336 bfpsi0( ) function 537, 548 CChebyshevFit[] function (Mathematica) atan2p( ) function 59 Bi( ) function (mathematical) 695 56, 57 atan2pi( ) function 59 bi0( ) function xxviii, 59, 719, 725, 726, cconj( ) function 59 atandeg( ) function 59 729 ccopy( ) function 59, 448 atanf( ) function 333 BI0( ) macro 760, 761 CCOPY( ) macro 448 Function and macro index . . . C 1051 ccos( ) function xxvi, 479, 503, 505 compound( ) function 59, 294, 294, CRatPoly[] function (Mathematica) 40, CCOS( ) macro 504 295–298 42 ccosh( ) function xxvi, 479, 511, 513, 515 conj( ) function 446, 480, 482, 485, 486, creal( ) function 445, 446, 451, 458, 460, CCOSH( ) macro 514 488, 490, 495, 496, 507, 513, 514, 518, 461 cd( ) function (mathematical) 658, 661, 826 CREAL( ) macro 442, 446, 461, 462 665 CONJ( ) macro 446 crlwp( ) function 690 cdiv( ) function 59, 451 CONS( ) macro 944 cs( ) function (mathematical) 658, 661, CDIV( ) macro 451, 458 Console.WriteLine( ) function 90 665, 683 ceil( ) function 57, 58, 129, 136, 136, ContinuedFraction[] function csc( ) function (mathematical) 569 137, 161, 852, 864 (Mathematica) 17 csch( ) function (mathematical) 569 ceil( ) function (mathematical) 136, 360, convert( ) function (Maple) 15, 16, 53, csin( ) function xxvi, 479, 503, 505 361, 414, 415, 547 251, 277, 554, 604 CSIN( ) macro 504 CEIL( ) macro 136, 137, 837 COPY( ) macro 187, 188 csinh( ) function xxvi, 479, 511, 513, 515 ceilf( ) function 136 copySign( ) function 982 CSINH( ) macro 514 (ceiling ...) function (Lisp) 130 copysign( ) function 58, 135, 147, 150, csqrt( ) function xxvi, 479–482, 484, 485 ceiling( ) function 130 152–154, 451, 458, 460, 478, 544, 975 CSQRT( ) macro 484, 487 ceill( ) function 136 copysign( ) function (mathematical) 315 csub( ) function 59, 461 cexp( ) function xxvi, 479, 488–490, 492, COPYSIGN( ) macro 135, 147, 150, CSUB( ) macro 461 493 152–154, 331, 338, 356, 364, 366, 367, ctable( ) function (Maple) 54, 55 cexp( ) function (mathematical) 488 369, 371, 373, 375, 379, 398, 432, 433, ctan( ) function xxvi, 479, 503, 505 CEXP( ) macro 492 451, 458, 460, 484, 487, 491, 492, 494, CTAN( ) macro 504 497, 500, 509, 656, 677, 761, 841, 885 ctanh( ) cexpm1( ) function xxvi, 494 function xxvi, 479, 511, 514, 515 copysignf( ) function 154 CTANH( ) cexpm1( ) function (mathematical) 492 macro 514 copysignl( ) function 154 ctn( ) function (mathematical) 302 CEXPM1( ) macro 492, 494 cos( ) function 4, 43, 44, 58, 62, 299, 305, CTOCX( ) macro 448 cf( ) function 711, 712 306, 479, 763, 824, 826, 827 CTOCX_( ) macro 442, 445, 446, 448, 451, CFLAGS macro 5 cos( ) function (Maple) 10 458, 460, 462, 463, 484 CForm[] function (Mathematica) 37–39, COS( ) macro xxv, 311, 321, 323 CUTOFF macro 527, 528, 536, 546, 547 41 cosbritishmil( ) macro 305 CVT_FE_DOWNWARD macro 845, 849, 894 CFormat[] function (Mathematica) 39, cosd( ) function 305 CVT_FE_TONEAREST macro 845, 849, 894 40 cosdeg( ) function 59, 305, 313 CVT_FE_TOWARDZERO macro 845, 849, 894 CHAR_BIT macro 159, 250, 256, 257, 419 COSDEG( ) macro 314, 315 CVT_FE_UPWARD macro 845, 849, 894 chebsort( ) function (Maple) 47, 51, 52 cosec( ) function (mathematical) 299 cvt_precision( ) function 855, 864 chebyshev( ) function (Maple) 47, 50–52, cosh( ) function 43, 44, 58, 62, 341, 345, CVT_SUFFIX_DD macro 892 726 352, 479, 749, 763, 826, 982 CVT_SUFFIX_DF macro 892 ChebyshevApproximation[] function cosh( ) function (Maple) 10 CVT_SUFFIX_DL macro 892 (Mathematica) 56 cosnatomil( ) macro 305 CVT_SUFFIX_DLL macro 892 CHECK_FILTER macro 764 cosp( ) function 59, 304 CVT_SUFFIX_F macro 892 chisq( ) function 59, 199 cospi( ) function 59, 304, 315, 316 CVT_SUFFIX_L macro 892, 893 chisq( ) function (mathematical) 561, 562 cospi( ) function (mathematical) 315, 317 CVT_SUFFIX_LL macro 892, 893 chisq_measure( ) function 199, 199 COSPI( ) macro 318, 584 CVT_SUFFIX_NONE macro 892, 893 cimag( ) function 445, 446, 451, 456, 458, cospi4( ) function 318 CVT_SUFFIX_U macro 893 460 cospi4( ) function (mathematical) CVT_SUFFIX_UL macro 893 CIMAG( ) macro 442, 446, 456, 461, 462 316–318 CVT_SUFFIX_ULL macro 893 cis( ) function (mathematical) 443 cosusmil( ) macro 305 cvtia( ) function 59, 900, 901, 901, 905, CLAMP( ) macro 908 cot( ) function 44, 61, 62, 827 906, 910 CLEAR( ) macro 840, 840, 842 cot( ) function (Maple) 10, 11, 551 CVTIA( ) macro 900, 901 clock( ) function 158, 159 cotan( ) function 59, 763 cvtib( ) function 59, 881, 881 clog( ) function xxvi, 479, 495–497 cotan( ) function (mathematical) 302, CVTIB( ) macro 881, 881, 885, 894, 901 CLOG( ) macro 497 303, 310, 315, 340 cvtibf( ) function 881 clog1p( ) function xxvi, 500, 501, 507 COTAN( ) macro 677 cvtibl( ) function 881 CLOG1P( ) macro 497, 500, 509 cotandeg( ) function 59 cvtid( ) function 59, 895, 897, 910 clp2( ) function 59, 166, 167, 168 cotanp( ) function 59 CVTID( ) macro 895, 897, 897, 901 cmplx( ) function 443, 994 cotanpi( ) function 59, 315, 318 cvtidf( ) function 865 CMPLX( ) macro 442, 443, 446 cotanpi( ) function (mathematical) 315, cvtig( ) function 59, 899 cmul( ) function 59, 458 320 cvtih( ) function 59, 895, 895 CMUL( ) macro 458, 459 COTANPI( ) macro 557 CVTIH( ) macro 895, 895, 901 cn( ) function (mathematical) 657–665, CPoly[] function (Mathematica) 40, 40 cvtihf( ) function 895 675, 691 cpow( ) function xxvi, 479, 502 cvtihl( ) function 895 cneg( ) function 59, 460 CPOW( ) macro 502 CVTINF( ) macro 881, 887, 901 CNEG( ) macro 460 cproj( ) function 460, 460 cvtio( ) function 59, 894, 894 CodeGeneration[C]( ) function (Maple) CPROJ( ) macro 460 CVTIO( ) macro 894, 895, 901 54 CRatComment[] function (Mathematica) cvtiof( ) function 894 coeff( ) function (Maple) 54, 554 41,42 cvtiol( ) function 894 Coefficient[] function (Mathematica) CRatData[] function (Mathematica) 42, CVTNAN( ) macro 881, 889, 901 37, 40, 41 42 CVTO_E_STYLE macro 854, 855 1052 Function and macro index . . . D

CVTO_F_STYLE macro 854, 855 cxconj( ) function 59, 446 DBL_EPSILON macro 161, 852 CVTO_FILL_WITH_ZERO macro 840, 842 CXCONJ( ) macro 446 DBL_MANT_DIG macro 164, 165, 391, 397, CVTO_FLAG_EQUALS macro 840 cxcopy( ) function 59, 448 402 CVTO_FLAG_MINUS macro 840, 862 CXCOPY( ) macro 448 DBL_MAX macro 161 CVTO_FLAG_PLUS macro 840, 855 CXCOPY_( ) macro 448, 500 DBL_MAX_10_EXP macro 855 CVTO_FLAG_SHARP macro 840, 855, 857 cxcos( ) function 59 DBL_MAX_EXP macro 252, 391 CVTO_FLAG_SPACE macro 840, 855 CXCOS( ) macro 504 DBL_MIN macro 100, 123, 598 CVTO_FLAG_ZERO macro 840, 855 cxcosh( ) function 59 DBL_MIN_10_EXP macro 855 CVTO_G_STYLE macro 854, 855 CXCOSH( ) macro 514 dc( ) function (mathematical) 659, 661, CVTO_JUSTIFY_CENTER macro 840 cxdiv( ) function 59, 451, 451, 471 665 CVTO_JUSTIFY_LEFT macro 840 CXDIV( ) macro 451, 451, 452, 471, 494, DEC128_DEN macro 937 CVTO_JUSTIFY_RIGHT macro 840 500, 514 DEC128_EPSILON macro 937 CVTO_NONE macro 840, 842 cxexp( ) function 59 DEC128_MANT_DIG macro 937 CVTO_SHOW_EXACT_ZERO macro 840, 843, CXEXP( ) macro 491, 492, 492, 494 DEC128_MAX macro 937 855 cxexpm1( ) function 59 DEC128_MAX_EXP macro 937 CVTO_SHOW_MIXEDCASE macro 840 CXEXPM1( ) macro 494, 494 DEC128_MIN macro 937 CVTO_SHOW_PLUS macro 840, 841 CXFMA( ) macro 491, 491, 500 DEC128_MIN_EXP macro 937 CVTO_SHOW_PLUS_AS_SPACE macro 840, CXHALF1NORM_( ) macro 491, 500, 509 DEC256_DEN macro 937 841, 847 cximag( ) function 59, 456 DEC256_EPSILON macro 937 CVTO_SHOW_POINT macro 840, 843, 844, CXIMAG( ) macro 456 DEC256_MANT_DIG macro 937 846, 857 CXIMAG_( ) macro 443, 444–446, 451, 453, DEC256_MAX macro 937 CVTO_SHOW_SUBNORMAL macro 840, 842 454, 456, 458–464, 484, 487, 491, 492, DEC256_MAX_EXP macro 937 CVTO_SHOW_UPPERCASE macro 840, 842, 494, 497, 500, 501, 504, 509, 514, 517 DEC256_MIN macro 937 847, 855 cxipow( ) function 59 DEC256_MIN_EXP macro 937 CVTO_TRIM_TRAILING_ZEROS macro 840, CXIPOW( ) macro 502 DEC32_DEN macro 937 846, 855 cxlog( ) function 59 DEC32_EPSILON macro 937 cvtob( ) function 59, 878 CXLOG( ) macro 497, 497, 500, 517 DEC32_MANT_DIG macro 937 cvtod( ) function 59, 851, 853 cxlog1p( ) function 59 DEC32_MAX macro 937 CVTOD( ) macro 854–856, 860, 864–866 CXLOG1P( ) macro 497, 500, 500 DEC32_MAX_EXP macro 937 cxmul( ) cvtodf( ) function 865 function 59, 458, 458 DEC32_MIN macro 937 CXMUL( ) cvtog( ) function 59, 866 macro 458, 458, 491, 500 DEC32_MIN_EXP macro 937 CXMULBYI_( ) CVTOG( ) macro 866 macro 507, 517 DEC64_DEN macro 937 cxneg( ) function 59, 459 cvtoh( ) function 59, 834, 839, 839, 878 DEC64_EPSILON macro 937 CXNEG( ) macro 459, 459 CVTOH( ) macro 834, 839, 839, 840, 845, DEC64_MANT_DIG macro 937 cxpow( ) function 59 847, 848, 850 DEC64_MAX macro 937 CXPOW( ) macro 501, 502 cvtohf( ) function 839 DEC64_MAX_EXP macro 937 cxproj( ) function 59, 460, 460 cvtohl( ) function 839 DEC64_MIN macro 937 CXPROJ( ) macro 460, 460 cvtoi( ) function 59, 866 DEC64_MIN_EXP macro 937 cxreal( ) function 59, 461 CVTOI( ) macro 842, 858, 866 DEC_DBL_DEN macro 937 CXREAL( ) macro 461 cvton( ) function 59, 866, 867 DEC_DBL_EPSILON macro 937 CXREAL_( ) macro 443, 444–446, 451, 453, CVTON( ) macro 842, 858, 866, 867 DEC_DBL_MANT_DIG macro 937 454, 458–464, 484, 487, 491, 492, 494, cvtonf( ) function 867 DEC_DBL_MAX macro 937 497, 500, 501, 504, 509, 514, 517 cvtoo( ) function 59, 878 DEC_DBL_MAX_EXP macro 937 CXSCALE_( ) macro 484, 487, 491, 500 CVTOO( ) macro 850, 895 DEC_DBL_MIN macro 937 cxset( ) function 59, 451 cvtrnd( ) function 894 DEC_DBL_MIN_EXP macro 937 CXSET_( ) macro 442, 443, 443, 445, 446, CVTRND( ) macro 885, 894 DEC_EVAL_METHOD macro 936, 937 451, 453, 454, 458–461, 463, 484, 487, cxabs( ) function 59, 442, 444, 445 DEC_FLT_DEN macro 937 491, 492, 494, 497, 500, 501, 504, 509, CXABS( ) macro 444, 484, 487, 497, 500 DEC_FLT_EPSILON macro 937 514, 517 cxacos( ) function 59 DEC_FLT_MANT_DIG macro 937 cxsin( ) function 59 CXACOS( ) macro 509, 509 DEC_FLT_MAX macro 937 cxsinh( ) function 59 cxacosh( ) function 59 DEC_FLT_MAX_EXP CXSINH( ) macro 514 macro 937 CXACOSH( ) DEC_FLT_MIN macro 517 cxsqrt( ) function 59, 485 macro 937 cxadd( ) DEC_FLT_MIN_EXP function 59, 445 CXSQRT( ) macro 484, 484, 517 macro 937 CXADD( ) macro 445, 517 cxsub( ) function 59, 461 DEC_INIT_DECIMAL128 macro 403 CXADD_( ) macro 491, 494, 500 CXSUB( ) macro 461, 461 DEC_LDBL_DEN macro 937 CXADDR_( ) macro 491, 500 CXSUB_( ) macro 500 DEC_LDBL_EPSILON macro 937 cxarg( ) function 59, 445, 446 CXSUBR_( ) macro 494, 497, 500 DEC_LDBL_MANT_DIG macro 937 CXARG( ) macro 445, 446, 487, 497, 500 cxtan( ) function 59 DEC_LDBL_MAX macro 937 cxasin( ) function 59 cxtanh( ) function 59 DEC_LDBL_MAX_EXP macro 937 CXASIN( ) macro 517 CXTANH( ) macro 494, 514 DEC_LDBL_MIN macro 937 cxasinh( ) function 59 CXTOC( ) macro 448 DEC_LDBL_MIN_EXP macro 937 CXASINH( ) macro 517 CXTOC_( ) macro 443, 443, 448, 451, 458, DEC_LLDBL_DEN macro 937 cxatan( ) function 59 460, 463, 484 DEC_LLDBL_EPSILON macro 937 cxatanh( ) function 59 DEC_LLDBL_MANT_DIG macro 937 cxcbrt( ) function 59 D DEC_LLDBL_MAX macro 937 CXCBRT( ) macro 487, 487 D macro 4, 255 DEC_LLDBL_MAX_EXP macro 937 Function and macro index . . . E 1053

DEC_LLDBL_MIN macro 937 eljacn( ) function 59 elkm1( ) function 59, 672 DEC_LLDBL_MIN_EXP macro 937 eljacs( ) function 59 ELKM1( ) macro 669, 672, 673 decContextDefault( ) function 403 eljadc( ) function 59 elldi( ) function 59 decimal128FromNumber( ) function 403 eljadn( ) function 59 elldi( ) function (mathematical) 651 decimal128ToNumber( ) function 403 eljads( ) function 59 elle( ) function 59, 628, 630, 985 decNumberAdd( ) function 403 eljag( ) function 59 elle( ) function (mathematical) 628, 629, decNumberMultiply( ) function 403 ELJAG( ) macro 663, 663, 681 638 decNumberNormalize( ) function 932 eljam( ) function 59 ELLE( ) macro 640, 640, 643, 681, 691 decNumberQuantize( ) function 931 ELJAM( ) macro 659 ellec( ) function 59, 630, 985 decNumberSameQuantum( ) function 931 eljanc( ) function 59 ellec( ) function (mathematical) 629 decrypt( ) function 205, 207 eljand( ) function 59 ELLEC( ) macro 643, 643 DEG_TO_RAD macro 315 eljans( ) function 59 ellei( ) function 59, 651, 653 degcos( ) function 305 eljasc( ) function 59 ellei( ) function (mathematical) 651, 653 denom( ) function (mathematical) 627, eljasd( ) function 59 ELLEI( ) macro 681 629 eljasn( ) function 59, 667 ellfi( ) function 59, 651, 653 Denominator[] function (Mathematica) eljcd( ) function 59 ellﬁ( ) function (mathematical) 651 37, 40, 41 ELJCD( ) macro 659 ELLFI( ) macro 681 dfabs( ) function 59 eljcn( ) function 59 ellipj( ) function 659 dfact( ) function 59 ELJCN( ) macro 659, 663 elliptic_ec( ) function 628 DFACT( ) macro 591 eljcs( ) function 59 elliptic_kc( ) function 625 dfadd( ) function 59 ELJCS( ) macro 659 elliptic_pi( ) function 631 dfdiv( ) function 59 eljdc( ) function 59 EllipticCE( ) function (Maple) 628 dfmul( ) function 59 eljdn( ) function 59 EllipticCE[] function (Mathematica) dfneg( ) function 59 eljds( ) function 59 628 dfsqrt( ) function 59 eljh( ) function 59 EllipticCK( ) function (Maple) 625 dfsub( ) function 59 ELJH( ) macro 681, 688 EllipticCK[] function (Mathematica) diff( ) function (Maple) 551, 603 eljh4( ) function 59 628 digit_frequency( ) function 198, 199, ELJH4( ) macro 688, 692 EllipticE( ) function (Maple) 628, 638, 199 eljnc( ) function 59 653 DIGIT_VALUE( ) macro 834, 839, 845, 850, ELJNC( ) macro 659 EllipticE[] function (Mathematica) 883, 890, 895 eljnd( ) function 59 628, 653 dint( ) function 129 ELJND( ) macro 659 EllipticF( ) function (Maple) 653 DivRem( ) function 57 eljns( ) function 59 EllipticF[] function (Mathematica) DllImport( ) function 921 ELJNS( ) macro 659 653, 667 dn( ) function (mathematical) 658–665, eljsc( ) function 59 EllipticK( ) function 625 675, 691 ELJSC( ) macro 659, 663 EllipticK( ) function (Maple) 625, 638 dnint( ) function 129 eljsd( ) function 59 EllipticK[] function (Mathematica) dnrm2( ) function 223, 231 ELJSD( ) macro 659 625, 628 double( ) function 400 eljsn( ) function 59 EllipticModulus( ) function (Maple) ds( ) function (mathematical) 658, 661, ELJSN( ) macro 659, 663 669, 670, 672 665, 683 eljt( ) function 59 EllipticNome( ) function (Maple) 669 dtoh( ) function 772 ELJT( ) macro 681 EllipticNomeQ[] function (Mathematica) dump( ) function 205 eljt1( ) function 59 669 ELJT1( ) macro 674 EllipticPi( ) function (Maple) 631, 653 E eljt2( ) function 59 EllipticPi[] function (Mathematica) Eν( ) function (mathematical) 695 ELJT2( ) macro 674 631, 653 E( ) function 630 eljt3( ) function 59 EllipticTheta( ) function 674 E( ) function (Maple) 638 ELJT3( ) macro 674 EllipticTheta[] function (Mathematica) E’( ) function (mathematical) 628, 629 eljt4( ) function 59 674 E( ) function (mathematical) 627, 629, ELJT4( ) macro 674 ellk( ) function 59, 630, 645 638, 987 eljta( ) function 59 ellk( ) function (Maple) 626 e2norm( ) function 113, 114, 114 ELJTA( ) macro 674 ellk( ) function (mathematical) 625, 626, E2NORM( ) macro 114 eljtd1( ) function 59 628, 629, 632, 633 EC( ) function 630 ELJTD1( ) macro 676 ELLK( ) macro 633, 640, 643, 672, 681, 691 echeb( ) function 49, 49, 50, 50, 51, 52, 59 eljtd2( ) function 59 ellkc( ) function 59, 630 ECHEB( ) macro 724 ELJTD2( ) macro 676 ellkc( ) function (Maple) 626 echeb2( ) function 51, 59 eljtd3( ) function 59 ellkc( ) function (mathematical) 625, 626, EDOM macro 71, 91, 93–96, 141–143, 148, ELJTD3( ) macro 676 629, 633–635 150, 152, 155, 563, 700, 719, 758, 803 eljtd4( ) function 59 ELLKC( ) macro 636, 643, 673 egcd( ) function 186–188, 188, 189 ELJTD4( ) macro 676 ellkn( ) function 59 EILSEQ macro 91, 93 eljtda( ) function 59 ELLKN( ) macro 672 elementsof( ) macro 256, 259, 263, 396, ELJTDA( ) macro 676, 677, 677 ellpi( ) function 59, 652, 653 846, 847, 858, 860, 862, 863, 865, 893 eljz( ) function 59 ellpi( ) function (mathematical) 651 elf( ) function 645 ELJZ( ) macro 681 ELLPI( ) macro 631 eljaam( ) function 59, 667 elk( ) function 59 ellrc( ) function 59 eljacd( ) function 59 ELK( ) macro 669, 672, 674 ELLRC( ) macro 649, 650 1054 Function and macro index . . . F ellrd( ) function 59 ereduce( ) function 59, 265 Exp[] function (Mathematica) 17, 42, 56 ELLRD( ) macro 649 EREDUCE( ) macro 254, 340 EXP( ) macro xxv, 192, 272, 273, 275, 345, ellre( ) function 59 erf( ) function 44, 58, 62, 593, 593, 617, 491, 492, 528, 557, 566, 668, 725, 730, ellre( ) function (mathematical) 653 768, 768, 925 746, 749 ELLRE( ) macro 649 erf( ) function (Maple) 602, 603, 607 exp10( ) function 44, 59, 62, 267 ellrf( ) function 59 erf( ) function (mathematical) 44, 62, 100, exp10( ) function (mathematical) 62 ellrf( ) function (mathematical) 682 561, 593–598, 600, 605–609, 768, 769 EXP10( ) macro 272, 558 ELLRF( ) macro 649 erfc( ) function 44, 58, 62, 593, 593, 617, exp10m1( ) function 59, 62, 273, 279, 281 ellrg( ) function 59 768, 768, 769 exp10m1( ) function (mathematical) 62 ellrg( ) function (mathematical) 654 erfc( ) function (Maple) 602, 603 EXP10M1( ) macro 277 ELLRG( ) macro 649 Erfc[] function (Mathematica) 601 exp16( ) function 59, 267 ellrh( ) function 59 erfc( ) function (mathematical) 20, 44, 62, EXP16( ) macro 272, 558 ELLRH( ) macro 649 100, 561, 593–598, 600, 603, 609, 610, exp16m1( ) function 59, 273, 281 ellrj( ) function 59 614, 616, 768, 769 EXP16M1( ) macro 277 ELLRJ( ) macro 649 erfc_scaled( ) function 593 exp2( ) function 44, 58, 62, 267, 827 ellrk( ) function 59 erfcinv( ) function (Matlab) 601 exp2( ) function (mathematical) 62, 281 ellrk( ) function (mathematical) 654 erfcs( ) function 59 EXP2( ) macro 272, 558, 584, 586, 663 ELLRK( ) macro 649 erfcs( ) function (mathematical) 598 exp2m1( ) function 59, 62, 273, 281 ellrl( ) function 59 ERFCS( ) macro 598 exp2m1( ) function (mathematical) 62 ELLRL( ) macro 649 Erff( ) function 916 EXP2M1( ) macro 277, 587 ellrm( ) function 59 erff( ) function 993 exp8( ) function 59, 267 ELLRM( ) macro 649 erfinv( ) function (Matlab) 601 EXP8( ) macro 272, 558 ellwp( ) function 685 eriduce( ) function 59, 265, 306 exp8m1( ) function 59, 273, 281 elntc( ) function 59 ERIDUCE( ) macro 254, 255, 258, 261, 262, EXP8M1( ) macro 277 ELNTC( ) macro 678 308, 340 EXPBASE( ) macro 558 elntd( ) function 59 ERRDIV( ) macro 529 expdf( ) function 271 ELNTD( ) macro 678 errmag( ) function (mathematical) 268, expf( ) function 272 elntn( ) function 59 283, 700, 721, 732, 733 expm1( ) function 58, 62, 273, 273, 277, ELNTN( ) macro 678 ERRMUL( ) macro 527, 529, 529 290, 298, 347, 492, 772, 793, 982 elnts( ) function 59 error( ) function 74, 870, 871 expm1( ) function (mathematical) 62, ELNTS( ) macro 678 error( ) macro 74 273, 274, 295, 298, 347, 668, 747, 793, elq( ) function 59 ERRSQRT( ) macro 529 794, 804, 805 ELQ( ) macro 669 ERRSUM( ) macro 529, 529 EXPM1( ) macro xxv, 277–279, 494, 560 elq1p( ) function 59 ESUB macro 85 expm1ts( ) function 275 ELQ1P( ) macro 669 η( ) function (mathematical) 587, 587 Exponent[] function (Mathematica) 40, elqc( ) function 59 euler( ) function 573 41 ELQC( ) macro 669 euler( ) function (Maple) 573 exponent( ) function (mathematical) 832 elqc1p( ) function 59 EulerE[] function (Mathematica) 573 Export[] function (Mathematica) 37 ELQC1P( ) macro 669 eulnum( ) function 59, 574 elwdp( ) function 59 EULNUM( ) macro 573, 587, 590 F ELWDP( ) macro 685, 689 eval_cf_lentz( ) function 19 F( ) function (Maple) 33 elwe( ) function 59 eval_cf_steed( ) function 18 F( ) function (mathematical) 624 ELWE( ) macro 683, 692 evalb( ) function (Maple) 33, 51, 247, F32( ) function 31 elwg( ) function 59 551, 553 F_to_C_string( ) function 944, 945, 945 ELWG( ) macro 683 evalf( ) function (Maple) 52, 53, 247, fabs( ) function 57, 58, 82, 83, 114, 135, elwip( ) function 59 269, 316, 486, 554, 604, 606, 607, 609, 147, 150, 152–154, 224, 228, 359, 366, ELWIP( ) macro 685 638 367, 415, 451, 452, 778, 782, 785, 788, elwk( ) function 59 evch( ) function 724, 725 791, 922, 982 ELWK( ) macro 685, 688 exact( ) function (mathematical) 467, 468 FABS( ) macro 114, 147, 150, 152–154, elwo( ) function 59 exact_add( ) function 397 315, 331, 335, 338, 359, 366, 367, 451, ELWO( ) macro 685 exact_add( )( ) function 406 621, 785, 791 elwp( ) function 59 EXACT_ADD( ) macro 399, 406 fabsf( ) function 114, 154, 922 ELWP( ) macro 685, 690 exact_mul( )( ) function 405, 406 fabsl( ) function 114, 154 elws( ) function 59 EXACT_MUL( ) macro 406, 407 fact( ) function 59 ELWS( ) macro 688 ExactAdd( ) function (mathematical) 403 FACT( ) macro 557, 591 elwz( ) function 59 ExactMult( ) function (mathematical) factor( ) function 419, 419 ELWZ( ) macro 688 403 Factor[] function (Mathematica) 752 EMAX macro 83, 85, 251, 252 exit( ) function 870 factorial( ) function 571, 574 EMIN macro 83, 85, 251, 837, 846 EXIT_FAILURE macro 870 fadj( ) function 59 encrypt( ) function 205, 206–208 EXIT_SUCCESS macro 92–94, 101, 113, fast_pprosum( ) function 456, 458 envp( ) function 117 127, 905, 925, 935 FastAccSum( ) function 385 EOF macro 868, 901 exp( ) function 12, 44, 58, 62, 191, 267, (fceiling ...) function (Lisp) 130 ERANGE macro 91, 93, 96, 130, 141–143, 271, 272, 294, 479, 781, 788, 824, 826, fcoef( ) function 59 690, 758, 885, 897 827 fdim( ) function 58 ercw( ) function 59, 211, 212 exp( ) function (Maple) 10, 26, 27, 269, FE_ALL_EXCEPT macro 108, 109, 113, 114, ercw_r( ) function 59, 211 569, 603, 724, 726 117, 119 Function and macro index . . . G 1055

FE_DBLPREC macro 108, 124, 126, 127, 401 347, 350, 395, 466–468, 530, 595, 598, FP_INFINITE macro 58 FE_DEC_DOWNWARD macro 109 599, 602, 619, 635, 657, 672, 769, 775, FP_NAN macro 58 FE_DEC_TONEAREST macro 109 779, 780, 793 FP_NORMAL macro 58 FE_DEC_TONEARESTFROMZERO macro 109 Float( ) function 916 FP_PAIR_T_EPSILON macro 785 FE_DEC_TOWARDZERO macro 109 float( ) function 946 FP_SUBNORMAL macro 58 FE_DEC_UPWARD macro 109 (floor ...) function (Lisp) 130 FP_T_DIG macro 514, 672 FE_DFL_ENV macro 108, 116 floor( ) function 57, 58, 129, 130, 136, FP_T_EPSILON macro 85, 218, 227, 232, FE_DFL_ENV( ) macro 116 136, 137, 165, 166, 174, 534 235, 237, 238, 274, 292, 491, 500, 509, FE_DIVBYZERO macro 108, 121 ﬂoor( ) function (mathematical) 136, 169, 529, 621, 633, 636, 640, 643, 849 FE_DOWNWARD macro 108, 112, 116, 400, 177, 179, 473, 527, 534, 545, 798 FP_T_MANT_DIG macro 256, 397, 399, 472 405 FLOOR( ) macro 137, 258, 322, 472 FP_T_MAX macro 19, 93, 153, 225, 227, FE_FAILURE macro 112, 117–119, 126 floorf( ) function 136 232, 274, 331, 338, 364, 398, 432, 436, FE_FLTPREC macro 108, 124, 126, 127 floorl( ) function 136 492, 497, 531, 536, 566, 636, 677, 725, FE_INEXACT macro 108, 113, 121, 140 flp2( ) function 59, 166 730, 745, 761 FE_INVALID macro 108, 121 FLT_EPSILON macro 82 FP_T_MAX_10_EXP macro 527, 858, 859 FE_LDBLPREC macro 108, 124, 126 FLT_EVAL_METHOD macro 124 FP_T_MAX_EXP macro 265, 397, 432 FE_OVERFLOW macro 108, 114, 121 FLT_MANT_DIG macro 391, 397 FP_T_MIN macro 85, 93, 232, 274, 331, FE_SUBNORMAL macro 108, 121 FLT_MAX macro 265 338, 398, 399, 436, 566, 664, 669, 688, FE_SUCCESS macro 111, 112, 117, 118 FLT_MAX_EXP macro 252, 391 780, 785 FE_TONEAREST macro 108, 112, 400, 405 FLT_MIN macro 100, 598 FP_ZERO macro 58 FE_TOWARDZERO macro 108, 112, 400 FLT_RADIX macro 62, 161, 833 fpclassify( ) function 58 FE_UNDERFLOW macro 108, 114, 121 fma( ) function 58, 87, 88, 145, 218–220, fpgetprec( ) function 124 FE_UPWARD macro 108, 112, 116, 400, 405 235, 237, 240, 370, 392, 394, 399, fpgetround( ) function 111 feclearexcept( ) function 58, 109, 110, 401–403, 406, 410, 438, 455 fpgetsticky( ) function 111, 112 110, 111, 113, 114, 119, 122, 140 fma( ) function (mathematical) 86, 145, fprintf( ) function 58, 868, 870, 873 fegetenv( ) function 58, 109, 117, 117, 236, 239, 276, 289, 291, 318, 347, 426, fpsetprec( ) function 124 119, 120, 123 428, 437, 530, 700, 704, 705, 707, 713, fpsetround( ) function 112 fegetexcept( ) function 58 781 fpsetsticky( ) function 111 fegetexceptflag( ) function 58, 109, FMA( ) macro 32, 88, 218, 219, 225, 235, fputs( ) function 869 118, 118, 120, 123 237, 238, 240, 277, 278, 287, 292, 370, free( ) function 4 fegetprec( ) function 58, 109, 124, 125, 388, 391, 391, 392, 397, 397, 398, 406, freestr( ) function 983, 983, 984 125, 401 407, 418, 430, 433, 455, 527, 596, 656, frexp( ) function 57, 58, 147, 150, 152, fegetround( ) function 58, 108, 109, 111, 677, 760 155, 397, 769, 857, 937, 944, 981, 982 111, 116, 848 FMA_( ) macro 456 FREXP( ) macro 147, 148, 150, 152, 155, feholdexcept( ) function 58, 109, 117, FMA_AND_ERR( ) macro 406, 407 257, 281, 284, 287, 364, 396, 398, 404, 119, 119, 120, 122, 123 fmaf( ) function 87, 399 421, 432, 433, 656, 837 FENV_ACCESS macro 110, 110, 113, 114, fmal( ) function 87, 399 FREXPF( ) function 944 405 fmax( ) function 58, 228, 451, 982 frexpf( ) function 921, 922, 944, 992, 992 feraiseexcept( ) function 58, 109, 111, FMAX( ) macro 451 frexph( ) function 59 111, 117–120 fmin( ) function 58, 228 FREXPH( ) macro 837 ferror( ) function 868 fmod( ) function 57, 58, 143, 143, 144, frexpo( ) function 59 fesetenv( ) function 58, 109, 117, 117, 146, 146, 147, 148–150, 152, 152, 153, FREXPO( ) macro 837 118, 118, 120, 123 153, 154, 155, 173, 174, 177, 304, 305, (fround ...) function (Lisp) 130 fesetexcept( ) function 120 313, 860, 861 frsqrta( ) function (mathematical) 241 fesetexceptflag( ) function 58, 109, fmod( ) function (mathematical) 144, 153 fscanf( ) function 58, 901, 903 118, 118, 120, 123 FMOD( ) macro 147, 153, 153, 154, 155, fseek( ) function 902 fesetprec( ) function 58, 109, 124, 125, 250, 315 fsolve( ) function (Maple) 540, 541, 546, 126, 127, 400, 401 fmodf( ) function 143, 154 552, 638 fesetround( ) function 58, 108, 109, 111, fmodl( ) function 143, 154, 155 fsplit( ) function 59 111, 112, 116, 400, 405 fmul( ) function 59, 942 FSPLIT( ) macro 432, 432, 433 fetestexcept( ) function 58, 109, 112, FMUL( ) macro 407, 418, 430, 430, 433, ftell( ) function 902 112, 113, 114, 117–119, 121, 140 433, 434, 435 FTN( ) macro 944, 944 fetrapexcept( ) function 120 fmul2( ) function 435, 436, 439 ftoh( ) function 78 feupdateenv( ) function 58, 109, 119, For[] function (Mathematica) 40 ftoo( ) function 955 119, 120, 122, 123 FortranForm[] function (Mathematica) (ftruncate ...) function (Lisp) 130 fexpon( ) function 59 37, 38 Function[] function (Mathematica) 628, (ffloor ...) function (Lisp) 130 FP( ) macro 5, 102, 335 751 FFMUL( ) macro 418, 418 FP_ARCH_AMD64 macro 364 fgets( ) function 909 FP_ARCH_IA32 macro 364, 401 G fibnum( ) function 59, 578, 579 FP_ARCH_IA64 macro 364, 391 G( ) function 555 FIBNUM( ) macro 578 FP_ARCH_M68K macro 364 gami( ) function 59, 562 FILE macro 902 FP_ARCH_MIPS macro 391 gami( ) function (mathematical) 562 find_a( ) function 439 FP_ARCH_PA_RISC macro 391 gamib( ) function 59, 562 ﬂ( ) function (mathematical) 13, 13, 51, FP_ARCH_POWER macro 391 gamib( ) macro xxvii, 568 86, 161, 230, 236, 239, 276, 285, 288, FP_ARCH_POWERPC macro 391 gamibd( ) function 567 290, 291, 304, 309, 310, 318, 323, 325, FP_ARCH_S390 macro 391 gamibd( ) macro xxvii, 568 1056 Function and macro index . . . I

gamibdf( ) macro xxvii, 567 host_to_ieee_128( ) function 403 in( ) function (mathematical) 62, 695, gamibf( ) macro xxvii, 567 HP( ) macro 335 731, 743, 750 gamic( ) function 59, 562 HP_COPYSIGN( ) macro 395 I macro 441, 441, 442, 446, 451, 458, 460 gamic( ) function (mathematical) 562 HP_CXADD_( ) macro 509 i_add( ) function 116 Γ( ) function (mathematical) 44, 61, 62, HP_CXCOSH( ) macro 514 I_ADD( ) macro 116 521, 521, 522, 524, 525, 528, 530, 531, HP_CXDIV( ) macro 514 IA32_HW_EXP2( ) macro 293 534, 536, 766–768 HP_CXEXP( ) macro 501 ichisq( ) function 60 GAMMA( ) function 561 HP_CXIMAG_( ) macro 501, 509, 514 idint( ) function 129 gamma( ) function 62, 521, 521, 591, 766 HP_CXIPOW( ) macro 501 idnint( ) function 129 Gamma[] function (Mathematica) 561, 751 HP_CXLOG( ) macro 501, 509 ieee_to_host_128( ) function 403 gamma_incomplete( ) function 561 HP_CXMUL( ) macro 501, 509 IEEERemainder( ) function 57 gamma_product( ) function 529 HP_CXREAL_( ) macro 501, 509, 514 IEEEremainder( ) function 57 GaussAGM( ) function (Maple) 620 HP_CXSET_( ) macro 501, 509, 514 ierf( ) function 60–62, 600 gcd( ) function 181–184, 184, 186 HP_CXSINH( ) macro 514 ierf( ) function (Maple) 602, 602, 603, gcd_knuth_binary_new( ) function 186 HP_CXSQRT( ) macro 509 604, 606, 607 gcd_trace( ) function 182 HP_CXSUB_( ) macro 509 ierf( ) function (mathematical) 61, 62, Get[] function (Mathematica) 34 HP_ELJAM( ) macro 664 600, 602–610 get_fpc_csr( ) function 78 HP_ELK( ) macro 672 ierf2( ) function (Maple) 602 get_mpfr_rounding( ) function 402 HP_ERFC( ) macro 616 ierfc( ) function 60–62, 600 getchar( ) function 902, 905, 909 HP_ERRDIV( ) macro 672 ierfc( ) function (Maple) 602, 603, 609 getExponent( ) function 982 HP_EXP( ) macro 566, 672 ierfc( ) function (mathematical) 61, 62, GetFloatArrayElements( ) function 984 hp_fma( ) function 395, 395, 397 600, 602, 603, 605, 607–610, 614 getpid( ) function 159 HP_FMA( ) macro 616, 617, 672 ierfc2( ) function (Maple) 602 getstr( ) function 983, 983, 984 HP_FREXP( ) macro 395, 837 ierfcf( ) function 946 GetStringUTFChars( ) function 983 HP_IERFC( ) macro 617 ierff( ) function 946 gscw( ) function 211, 212 HP_ILOGB( ) macro 85 if( ) function (Maple) 54 gsl_sf_zeta( ) function 583 HP_IPOW( ) macro 837 If[] function (Mathematica) 39 gsl_sf_zeta_int( ) function 583 HP_LGAMMA_R( ) macro 566 ifix( ) function 129 gsl_sf_zetam1( ) function 583 HP_LOG( ) macro 566, 672 igamma( ) function 561 gsl_sf_zetam1_int( ) function 583 HP_LOG2( ) macro 837 ilog2( ) function 60, 184 HP_ONE_OVER_PI macro 245 ilogb( ) function 58, 471 H HP_POWPY( ) macro 430 ILOGB( ) macro 466, 471 Hν( ) function (mathematical) 695 HP_ROUND macro 245 im( ) function 994 Hν( ) function (mathematical) 695 HP_RPH( ) macro 313 imag( ) function 826 HP_SCALBN( ) hn( ) function (mathematical) 695 macro 85 imag( ) function (mathematical) 448, 500 h( ) function (Maple) 606 HP_SIGNBIT( ) macro 395, 509 imaginary macro 441, 441 h2( ) function (Maple) 607 HP_SIN( ) macro 315 imax( ) function 471 h3( ) function (Maple) 607 HP_SINCOS( ) macro 504, 514 IMAX( ) macro 471 HALF_EVEN macro 186 HP_SINHCOSH( ) macro 504, 514 incgam( ) function 561 HALF_MAXNORMAL macro 154 HP_SQRT( ) macro 672 incw_r( ) function 211, 212 HALF_PI macro 303–305 HP_STORE( ) macro 509 inf( ) function 451, 458 HAVE_BROKEN_LONG_DOUBLE macro 391 HP_T_DIG macro 514 infnorm( ) function (Maple) 48 HAVE_BROKEN_LONG_FP_T macro 397 HP_T_MANT_DIG macro 397, 399 infty( ) function 60, 120, 122, 451, 458, HAVE_COMPLEX macro 442, 444 HP_T_MAX_EXP macro 397 460, 478, 785, 791 HAVE_CORRECT_MADD_D macro 392 HP_VSUM( ) macro 309 INFTY( ) macro 275, 373, 433, 451, 458, HAVE_CORRECT_MADD_S macro 392 htod( ) function 772 460, 526, 530, 617, 633, 636, 677, 730, HAVE_FAST_HP_T macro 331 HUGE macro 91 760, 785, 791, 792, 887 HAVE_FP_T_DOUBLE macro 364, 391, 401 HUGE_VAL macro 91, 92, 95, 96 init_bits( ) function 837 HAVE_FP_T_EXTENDED macro 391 HUGE_VALF macro 92 int( ) function 129, 130, 415, 778 HAVE_FP_T_QUADRUPLE macro 391 HUGE_VALL macro 92 Int( ) function (Maple) 606 HAVE_FP_T_SINGLE macro 308, 391 hypot( ) function 44, 58, 70, 113, 202, int( ) function (Maple) 653 HAVE_GUARD_DIGIT macro 250, 331 223, 224, 231, 233, 444, 479, 495, 982 INT( ) macro 74–76 HAVE_IEEE_754 macro 338, 492, 530, 791 HYPOT( ) macro 225, 227, 231, 444, 463 INT_MAX macro 94, 130, 152, 155, 250, HAVE_LONG_DOUBLE macro 391, 924, 925, hypotf( ) function 223 262, 501, 885, 890 943 hypotl( ) function 223 INT_MIN macro 130, 184, 186, 188, 885, HAVE_LONG_LONG macro 924, 943 890 HAVE_LONG_LONG_INT macro 979, 980 I INT_T_MAX macro 75, 76 HAVE_STORE macro 365 I0( ) function (mathematical) 724 INT_T_MIN macro 75, 76 HAVE_USABLE_FMA macro 402 I1( ) function (mathematical) 724 IntegerQ[] function (Mathematica) 39 HAVE_WOBBLING_PRECISION macro 633, Iν( ) function (mathematical) 695, 823, interface( ) function (Maple) 47, 52 636, 640, 643 987 INTF( ) function 961 hexfp( ) function 87, 220, 400, 409, In( ) function (mathematical) 62, 718, intf( ) function 129 849–851 728, 755, 769, 823 intf( ) function (mathematical) 129 hexval( ) function 205 i0( ) function (mathematical) 744 intxp( ) function 59 HornerForm[] function (Mathematica) i1( ) function (mathematical) 747 INTXP( ) macro 284, 421 38 iν( ) function (mathematical) 987 INV_LN_B macro 785 Function and macro index . . . J 1057

inverse_jacobi_cd( ) function 667 ISCSUBNORMAL( ) macro 464 jn( ) function (mathematical) 62, 695, inverse_jacobi_sn( ) function 667 ISCXFINITE( ) macro 464 731, 735 InverseEllipticNomeQ[] function iscxinf( ) function 60 J0( ) function 696, 711 (Mathematica) 669, 670 ISCXINF( ) macro 462 j0( ) function xxvii, xxviii, 60, 120, 122, InverseErf[] function (Mathematica) iscxnan( ) function 60 694, 709 601 ISCXNAN( ) macro 462, 462 J1( ) function 711 InverseErfc[] function (Mathematica) ISCXNORMAL( ) macro 464 j1( ) function xxvii, 60, 120, 122, 694, 601 ISCXSUBNORMAL( ) macro 464, 464 709, 710 InverseJacobiAM( ) function (Maple) ISCXZERO( ) macro 464 jacobi_am( ) function 659 667 ISCZERO( ) macro 464 jacobi_cd( ) function 659 InverseJacobiSN( ) function (Maple) isdigit( ) function 862, 890, 901 jacobi_cn( ) function 659 667 isfinite( ) function 58, 451 jacobi_cs( ) function 659 InverseSeries[] function (Mathematica) ISFINITE( ) macro 451, 464 jacobi_dc( ) function 659 21, 601 isgreater( ) function 58 jacobi_dn( ) function 659 InverseWeierstrassP[] function isgreaterequal( ) function 58 jacobi_ds( ) function 659 (Mathematica) 685 isinf( ) function 1, 58, 135, 147, 150, jacobi_nc( ) function 659 invmodp( ) function 187, 189 152, 154, 228, 364, 366, 367, 451, 458, jacobi_nd( ) function 659 invmodpx( ) function 188 460, 471, 711, 780 jacobi_ns( ) function 659 iphi( ) function 60, 614 ISINF( ) macro 85, 96, 135, 147, 150, 152, jacobi_sc( ) function 659 IPHI( ) macro 617 154, 192, 255, 275, 315, 331, 338, 364, jacobi_sd( ) function 659 iphic( ) function 60, 614, 617 366, 367, 373, 375, 379, 393, 432, 433, jacobi_sn( ) function 659 ipow( ) function 60, 415, 416, 419, 778, 451, 458, 460, 462, 471, 484, 487, 491, JacobiAM( ) function (Maple) 659 782 494, 497, 500, 509, 616, 617, 621, 725, JacobiAmplitude[] function IPOW( ) macro 417, 502, 557, 558, 560, 760, 761, 780, 842, 846, 857, 885 (Mathematica) 659 759, 846 isinff( ) function 154 JacobiCD( ) function (Maple) 659 irandtoint( ) function 167, 167 isinfl( ) function 154 JacobiCD[] function (Mathematica) 659 irandtoint_new( ) function 168 isless( ) function 58 JacobiCN( ) function (Maple) 659 Is( ) function (mathematical) 719, 721, islessequal( ) function 58 JacobiCN[] function (Mathematica) 659 724, 725, 728, 729, 761 islessgreater( ) function 58 JacobiCS( ) function (Maple) 659 is( ) function (mathematical) 732, 746, isnan( ) function 1, 58, 80, 80, 135, 141, JacobiCS[] function (Mathematica) 659 747, 749, 750, 753, 754 143, 147, 150, 152, 154, 228, 364, 368, JacobiDC( ) function (Maple) 659 is_abs_safe( ) function 60, 74, 75 451, 458, 471, 780, 782, 785 JacobiDC[] function (Mathematica) 659 IS_ABS_SAFE( ) macro 75 ISNAN( ) macro 85, 96, 135, 141, 143, 147, JacobiDN( ) function (Maple) 659 is_add_safe( ) function 60, 74, 75, 558, 150, 152, 154, 192, 255, 275, 313, 315, JacobiDN[] function (Mathematica) 659 885, 898 331, 335, 338, 364, 368, 373, 375, 379, JacobiDS( ) function (Maple) 659 IS_ADD_SAFE( ) macro 75,76 393, 432, 433, 451, 458, 462, 471, 484, JacobiDS[] function (Mathematica) 659 is_add_safel( ) function 74 487, 491, 494, 497, 500, 509, 616, 617, JacobiNC( ) function (Maple) 659 is_add_safell( ) function 74 621, 633, 636, 640, 643, 663, 672, 677, JacobiNC[] function (Mathematica) 659 is_div_safe( ) function 60, 75 780, 785, 842, 846, 857 JacobiND( ) function (Maple) 659 IS_DIV_SAFE( ) macro 75,76 isnanf( ) function 154 JacobiND[] function (Mathematica) 659 IS_EVEN macro 186 isnanl( ) function 154 JacobiNS( ) function (Maple) 659 IS_EVEN( ) macro 313, 677 isnormal( ) function 58 JacobiNS[] function (Mathematica) 659 is_fdiv_safe( ) function 530, 531, 563, ISNORMAL( ) macro 464 JacobiSC( ) function (Maple) 659 566 ISODIGIT( ) macro 895 JacobiSC[] function (Mathematica) 659 is_fmul_safe( ) function 563, 566, 712 isprime( ) function (Maple) 175 JacobiSD( ) function (Maple) 659 is_mul_safe( ) function 60, 75, 76, 558 isprint( ) function 205 JacobiSD[] function (Mathematica) 659 IS_MUL_SAFE( ) macro 76, 419 isqnan( ) function 60 JacobiSN( ) function (Maple) 659 is_neg_safe( ) function 60, 76 issnan( ) function 60 JacobiSN[] function (Mathematica) 659 IS_NEG_SAFE( ) macro 76, 76 isspace( ) function 880, 881, 904 JacobiTheta1( ) function (Maple) 674 IS_ODD macro 186 issubnormal( ) function 60, 78 JacobiTheta2( ) function (Maple) 674 IS_ODD( ) macro 650, 760, 791 ISSUBNORMAL( ) macro 398, 464, 842 JacobiTheta3( ) function (Maple) 674 is_rem_safe( ) function 60, 76 isunordered( ) function 58 JacobiTheta4( ) function (Maple) 674 IS_REM_SAFE( ) macro 76 ISXDIGIT( ) macro 895 Java_MathCW_acos_ _D(( ) function 983 is_safe_add( ) function 898 Java_MathCW_acos_ _F(( ) function 983 IS_SET( ) macro 840, 840, 841–844, 846, J Java_MathCW_nan_ _F( ) function 984 Java_MathCW_vercwf( ) 847, 855, 862 J0( ) function (mathematical) 705, 707, function 984 is_sub_safe( ) function 60, 76 709 jn( ) function xxvii, 60, 62, 694, 713 Jncf( ) IS_SUB_SAFE( ) macro 76 J1( ) function (mathematical) 707, 710 function 711 isalpha( ) function 901 Jν( ) function (mathematical) 695, 823, JNU_GetStringNativeChars( ) function ISBDIGIT( ) macro 882, 884 987 983 ISCFINITE( ) macro 464 Jn( ) function (mathematical) 62, 694, iscinf( ) function 60 695, 696, 697, 701, 710, 713, 716, 755, K ISCINF( ) macro 462 769, 823 K0( ) function (mathematical) 726 iscnan( ) function 60 Jν( ) function (mathematical) 695 K1( ) function (mathematical) 726 ISCNAN( ) macro 462 j1( ) function (mathematical) 740 Kν( ) function (mathematical) 695, 823, ISCNORMAL( ) macro 464 jν( ) function (mathematical) 987 987 1058 Function and macro index . . . M

Kn( ) function (mathematical) 62, 718, llrancw_r( ) function 211, 212 lrand48( ) function 162, 163, 178, 202 728, 755, 769 llrincw( ) function 211, 212 lrcw( ) function 60, 211, 212 kν( ) function (mathematical) 987 llrincw_r( ) function 211 lrcw_r( ) function 60, 211 kn( ) function (mathematical) 62, 695, llrint( ) function 58, 142, 143 lrincw( ) function 211, 212 731, 743 LLRINT( ) macro 143 lrincw_r( ) function 211 K( ) function 630 llrintf( ) function 142 lrint( ) function 58, 132, 142, 142, 143 K( ) function (Maple) 638 llrintl( ) function 142 lrint( ) function (mathematical) 142 K’( ) function (mathematical) 625, 626 llround( ) function 58, 140, 141 LRINT( ) macro 143 K( ) function (mathematical) 624, 626, LLROUND( ) macro 141 lrintf( ) function 142 632, 638, 727, 987 llroundf( ) function 140 lrintl( ) function 142 KahanUlp( ) function 83, 84 llroundl( ) function 140 lround( ) function 58, 140, 140, 141, 143, KC( ) function 630 lmscw( ) function 211, 212 785 kei( ) function (mathematical) 695 ln( ) function (Maple) 626, 638 lround( ) function (mathematical) 140 ker( ) function (mathematical) 695 LN_B macro 785 LROUND( ) macro 141, 141, 785 Ks( ) function (mathematical) 719, 721, LN_MAXNORMAL macro 785 726, 727, 729, 761 LN_MINSUBNORMAL macro 785 M ks( ) function (mathematical) 732, 754, LO_BITNUM_OF_WORDNUM( ) macro 258, M68K_HW_EXP2( ) macro 293 755 259 macheps( ) function 87, 220, 233, 766, 955 loadLibrary( ) function 982 Main( ) function 922 L log( ) function 12, 44, 58, 61, 62, 189, main( ) function 90, 92–94, 101, 101, 113, Lν( ) function (mathematical) 695 191, 192, 282–284, 287, 290, 479, 532, 121, 122, 905, 925, 935 λ( ) function (mathematical) 587, 587 654–656, 657, 763, 782, 788, 791, 820, makeseed( ) function 159, 159, 160, 212 lclp2( ) function 166 824, 826, 827, 864 malloc( ) function 4 lcm( ) function 183 log( ) function (Maple) 10, 12, 33, 277, MASK16 macro 261 lcm( ) function (mathematical) 183 546, 553, 606 MASK32 macro 262, 262 LDBL_EPSILON macro 218, 238 LOG( ) macro 192, 288–290, 497, 500, 528, Math( ) function 922 LDBL_MANT_DIG macro 391 546, 557, 566, 636, 643, 725, 791 MATH_ERREXCEPT macro 94 LDBL_MAX_EXP macro 252, 391 log10( ) function 44, 58, 282, 283, 287, math_errhandling macro 94, 95 LDBL_MIN macro 100, 598 763, 982 MATH_ERRNO macro 94, 95 ldexp( ) function 57, 58, 147, 150, 152, LOG10( ) macro 288–290 MathCW( ) function 981 155, 272, 364, 413, 423, 439, 769, 782, log101p( ) function 60, 62, 290, 292 max( ) function 57 795, 896, 937 log101p( ) function (mathematical) 62 max( ) function (Maple) 553 LDEXP( ) macro 147, 148, 150, 152, 155, log10f( ) function 287 Max[] function (Mathematica) 41 257–259, 277, 281, 287, 364, 398, 399, log16( ) function 60, 283 MAX( ) macro 621, 650, 663, 858, 945, 945 404, 432, 433, 846, 885, 890 LOG16( ) macro 289 MAX_ACC macro 897, 898 ldexpb( ) function 155 log161p( ) function 60, 290, 292 MAX_UINT_LEAST32 macro 209 ldexpbl( ) function 155 log1p( ) function 44, 58, 62, 290, 290, MAX_X macro 255 ldexph( ) function 60 294, 298, 426, 656, 657, 767, 770, 982 MAX_X_M macro 255 ldexpo( ) function 60 log1p( ) function (mathematical) 44, 62, MAXAGM macro 622 legcd( ) function 188 290, 294, 295, 298, 348–350, 426, 535, MAXBIGBUF macro 841 Length[] function (Mathematica) 41 547, 607, 624, 643, 654, 655, 670, 704, MAXBUF macro 841, 844, 945 LG_B macro 256 713, 793, 794, 808 MAXEXTRAPREC macro 844 lgamma( ) function 44, 58, 521, 521, 522, LOG1P( ) macro xxv, 293, 350, 536, 640 MAXINT macro 165 531–534, 536, 540, 765–767 log2( ) function 44, 58, 282, 283, 827, 852 MAXLOSS macro 764 lgamma( ) function (mathematical) 563 LOG2( ) macro 289 MAXNORMAL macro 71, 154 LGAMMA( ) macro xxvii, 536–538, 557, 558 log21p( ) function 60, 62, 290, 292 MAXSTEP macro 219 lgamma_r( ) function 60, 522, 534 log21p( ) function (mathematical) 62 MAXSUBNORMAL macro 100 LGAMMA_R( ) macro 534 log8( ) function 60, 283 mchep( ) function 60 lgammaf_r( ) function 522 LOG8( ) macro 289 mcrule( ) function 203 lgammal_r( ) function 522 log81p( ) function 60, 290, 292 MCW_B_TO_CEIL_HALF_T macro 431, 432 lgcd( ) function 183 log_gamma( ) function 591 memset( ) function 257, 847, 909, 935 LIBS macro 765 logb( ) function 58, 155, 451, 453, 937 min( ) function 57 limit( ) function (Maple) 51, 478, 623 logb( ) function (mathematical) 553, 557 min( ) function (Maple) 553 linvmodpx( ) function 188 LOGB( ) macro 284, 451, 558, 650 MIN( ) macro 663, 858, 945 LK( ) function (Maple) 626 logbfact( ) function 60 minimax( ) function 28, 33 LKC( ) function (Maple) 626 LOGBFACT( ) macro 558, 591 minimax( ) function (Maple) 28, 29, 33, llclp2( ) function 166 logf( ) function 287 52, 55, 270, 271, 724 llcm( ) function 183 LOGN( ) macro 436 MiniMaxApproximation[] function llegcd( ) function 188 logonep( ) function 654, 655 (Mathematica) 34, 35, 35, 36, 42 llgcd( ) function 183 LONG_MAX macro 130, 141, 143, 419 minimize( ) function (Maple) 606, 607 llinvmodpx( ) function 188 LONG_MIN macro 130, 141, 143, 419 MINNORMAL macro 79, 100, 154 lllcm( ) function 183 longjmp( ) function 91, 107 MINSUBNORMAL macro 100 llmscw( ) function 211, 212 lprint( ) function (Maple) 54 (mod ...) function (Lisp) 130 LLONG_MAX macro 130, 141, 143 LR( ) function 630 mod_add( ) function 174, 174 LLONG_MIN macro 130, 141, 143 lrancw( ) function 209, 210, 212, 213 mod_mul( ) function 174, 174 llrancw( ) function 210, 212 lrancw_r( ) function 211, 212 MODF( ) function 961 Function and macro index . . . N 1059 modf( ) function 57, 58, 129, 132, 133, nextafterf( ) function 213 PATAN( ) macro xxviii, 804, 806 135, 135, 136–139, 177, 263, 264, 304, nextafterl( ) function 213 patan2( ) function 60 795 nexttoward( ) function 58, 921 patanh( ) function 60 MODF( ) macro 130, 135, 136, 137, 139, nexttowardf( ) function 921 PATANH( ) macro xxix, 810 156, 304, 315, 316 nextUp( ) function 982 pcbrt( ) function 60, 356, 383 modff( ) function 132, 135 nint( ) function 129, 130 PCBRT( ) macro 379 modfl( ) function 132 nlz( ) function 60, 166, 167 pcbrt2( ) function 383, 384 Module[] function (Mathematica) 38–42 NMAX macro 527 pcbrt2f( ) function 382, 384 modulo( ) function 130 nome( ) function (mathematical) 686 pcbrtf( ) function 382 MP_DIV( ) macro 251 nops( ) function (Maple) 52, 54 pcmp( ) function 60, 356, 358, 368, 791 MP_FMS( ) macro 250 norm( ) function 826 PCMP( ) macro 356, 358, 368, 376, 789, 791 MP_FROM_FP_T( ) macro 250, 251 norm2( ) function 223 pcon( ) function 60, 789, 791, 796 MP_FROM_STRING( ) macro 251 normal( ) function (Maple) 52, 53 PCON( ) macro 788, 789, 791, 804 MP_MUL( ) macro 250 normalize( ) function xxxiii, 60, 934 pcopy( ) function 60, 356, 358, 358, 779, MP_ROUND( ) macro 250 normalized( ) function 933, 934 785, 791 MP_TO_FP_T( ) macro 250 normalizedf( ) function 933 PCOPY( ) macro 358, 358, 376, 379, 385, mpfr_add( ) function 402 normalizedl( ) function 933 386, 779, 785, 791 mpfr_get_d( ) function 402 normalizedll( ) function 933 pcopysign( ) function 60 mpfr_init2( ) function 402 nrcw( ) function 60, 211, 212 pcos( ) function 60 mpfr_mul( ) function 402 nrcw_r( ) function 60, 211 PCOS( ) macro xxviii, 799, 800 mpfr_set_d( ) function 402 ns( ) function (mathematical) 659, 661, pcosh( ) function 60 mscw( ) function 211, 212 665, 683 PCOSH( ) macro xxviii, 807 ntos( ) function 60, 867, 867, 934 pcotan( ) function 60 N NTOS( ) macro 867 pdiv( ) function 60, 356, 383, 779, 785, Nν( ) function (mathematical) 695 ntosdf( ) function 934, 935 791 ntz( ) function 60, 166, 184 nn( ) function (mathematical) 695 PDIV( ) macro 372, 373, 376, 779, 785, 791 N[] function (Mathematica) 39, 41, 269 NUL macro 206, 868, 874, 897, 906–909 pdivf( ) function 382 N_ASYMPTOTIC macro 545 NULL macro 3, 117–119, 132, 135, 152, pdot( ) function 60, 356 nan( ) function 58, 122, 123, 147, 981 188, 250, 264, 265, 304, 620, 663, 830, PDOT( ) macro 386, 386, 410 NAN( ) macro 889 866, 871, 880, 881, 885–887, 889, 890, peps( ) function 60, 779, 780 NANF( ) function 945 892, 893, 897, 984 PEPS( ) macro 779, 780 nanf( ) function 147, 921, 925, 945, 981, Numerator[] function (Mathematica) 37, perror( ) function 93, 94 984, 992, 992 40, 41 peval( ) function 60, 356, 357, 451, 791 nanl( ) function 147 peval( ) function (mathematical) 794 NBSEllE( ) function 653 O PEVAL( ) macro 356, 357, 357, 375, 376, NBSEllE( ) function (Maple) 653 octfp( ) function 850 379, 386, 393, 451, 458, 785, 791 NBSEllE[] function (Mathematica) 653 ONE_OVER_PI macro 245 pexp( ) function 60, 780, 782, 785, 791 NBSEllF( ) function 653 op( ) function (Maple) 47, 53–55, 554 pexp( ) function (mathematical) 795 NBSEllF( ) function (Maple) 653 Options[] function (Mathematica) 34, PEXP( ) macro 780, 785, 788, 791, 794 NBSEllF[] function (Mathematica) 653 40 pexp10( ) function 60, 795 NBSEllPi( ) function 653 pexp10( ) function (mathematical) 795 NBSEllPi( ) function (Maple) 653 P PEXP10( ) macro xxviii, 798 NBSEllPi[] function (Mathematica) 653 ℘( ) function (mathematical) 682 pexp10f( ) function 798 nc( ) function (mathematical) 658, 661, P macro 2, 4, 32 pexp16( ) function 60, 795 665 P( ) function (mathematical) 697–699, pexp16( ) function (mathematical) 795 nd( ) function (mathematical) 658, 661, 709, 713, 739 PEXP16( ) macro xxviii, 799 665 P32( ) function 31 pexp2( ) function 60, 795 NDEBUG macro 186, 257 pabs( ) function 60, 356, 358, 785 pexp2( ) function (mathematical) 795 nearbyint( ) function 58, 139, 140, 140 PABS( ) macro 358, 785 PEXP2( ) macro xxviii, 796 NEARBYINT( ) macro 140 pacos( ) function 60 pexp2df( ) function 796 nearbyintf( ) function 139 PACOS( ) macro xxviii, 805 pexp8( ) function 60, 795 nearbyintl( ) function 139 pacosh( ) function 60 pexp8( ) function (mathematical) 795 NearSum( ) function 385 PACOSH( ) macro xxix, 809 PEXP8( ) macro xxviii, 797 NevilleThetaC[] function (Mathematica) padd( ) function 60, 355, 356, 366, 367, pexpd( ) function 785, 786 678 383, 785, 789, 791 PEXPD( ) macro xxviii, 786 NevilleThetaS[] function (Mathematica) PADD( ) macro 355, 366, 367, 371, 373, pexpdf( ) function 786 678 376, 393, 785, 789, 791 pexpm1( ) function 60, 793, 794, 808 New_Line( ) function 916 paddf( ) function 355, 382 PEXPM1( ) macro xxviii, 793, 794, 795 new_sink_file( ) function 871, 872 paddl( ) function 355 pfdim( ) function 60 new_sink_string( ) function 871, 872 pade( ) function 33 pfmax( ) function 60 new_source_file( ) function 904, 904 Part[] function (Mathematica) 36 pfmin( ) function 60 new_source_string( ) function 904, 904 pasin( ) function 60 pfrexp( ) function 60 next_bit( ) function 839, 839, 843 PASIN( ) macro xxviii, 803, 806 pfrexph( ) function 60 next_digit( ) function 839, 843, 844, 850 pasinh( ) function 60 pgamma( ) function 60 nextAfter( ) function 982 PASINH( ) macro xxix, 810 pgamma( ) function (mathematical) 62 nextafter( ) function 1, 58, 161, 542 patan( ) function 60 PGAMMA( ) macro xxvii, 556 1060 Function and macro index . . . Q pgammadl( ) function 559 polygamma( ) function 548 psilnf( ) function 991 pgammal( ) function 559, 560 PolyGamma[] function (Mathematica) psin( ) function 60 Φ( ) function (mathematical) 610, 610, 537, 548 PSIN( ) macro xxviii, 799, 801 612–615, 617 pop( ) function 60, 166, 184 psinh( ) function 60 Phi( ) function 610 pout( ) function 60 PSINH( ) macro xxix, 807 phi( ) function 60, 614 pow( ) function 44, 58, 411, 500, 815, 824, psnan( ) function 60 PHI( ) macro 616 826, 827, 856, 865, 866 psplit( ) function 60, 356, 364, 369, 370 Φc( ) function (mathematical) 612–615, pow( ) function (mathematical) 62 PSPLIT( ) macro 364, 365, 368–371, 617 POW( ) macro 501, 502, 528, 584, 586 386–388, 393, 410 Phic( ) function 610 pow_exp( ) function 566, 567 psqrt( ) function 60, 356, 383 phic( ) function 60, 614, 617 pow_exp_gam( ) function 566, 567 PSQRT( ) macro 375, 376 PHIC( ) macro 616 powd( ) function 992 psqrtf( ) function 382 phigh( ) function 60, 356, 357 powdl( ) function 439 psub( ) function 60, 356, 367, 368, 383, PHIGH( ) macro 356, 357, 357 power_of_10( ) function 855, 859, 860, 780, 785, 791 phypot( ) function 60 865, 898, 899 PSUB( ) macro 367, 367, 368, 371, 373, PI_STR macro 251 powf( ) function 411 780, 785, 791 pierf( ) function 60 powl( ) function 411, 439, 820 psubf( ) function 382 pierfc( ) function 60 powpy( ) function 429, 429, 430 psum( ) function 60, 356 pilogb( ) function 60 PPDIV( ) macro 417, 418 PSUM( ) macro 385, 386, 387, 410 pin( ) function 60 PPMUL( ) macro 417, 418 psum2( ) function 60, 356, 359, 366, 367, pinfty( ) function 60 pprosum( ) function 60, 356, 451 369, 371 pipow( ) function 60, 777, 779, 780, 785, PPROSUM( ) macro 386, 387, 451, 455, 458, PSUM2( ) macro 356, 358, 359, 359, 796 471, 698 365–367, 369, 371, 373, 375, 385, 410, PIPOW( ) macro 777, 779, 779, 780, 785 pq_approx_rounded( ) function (Maple) 804 pipowdf( ) function 796 43 ptan( ) function 60 pipowf( ) function 798 pqnan( ) function 60 PTAN( ) macro xxviii, 802 pisinf( ) function 60 priest_cxdiv( ) function 454, 454 ptanh( ) function 60 PISINF( ) macro 376 Print[] function (Mathematica) 40, 41 PTANH( ) macro xxix, 809 pisnan( ) function 60 printf( ) function 50, 58, 78, 92, 93, 101, Put( ) function 916 PISNAN( ) macro 376 113, 121, 166, 169, 199, 314, 463, 630, pythag( ) function 227, 228, 228, 229–233 pisqnan( ) function 60 829, 830, 840, 850, 851, 853, 854, 857, pissnan( ) function 60 860, 867–871, 873–875, 877, 878, 901, Q pldexp( ) function 60 904–906, 908–910, 925, 934, 935 Q( ) function (mathematical) 697–699, pldexph( ) function 60 printf( ) function (Maple) 48, 52, 54, 709, 713, 739 plog( ) function 60, 787, 788, 791, 796, 245, 247, 270, 271, 623, 626, 638 Q32( ) function 31 808 println( ) function 982, 985 QABS( ) macro 85, 135, 184, 186–188, 225, PLOG( ) macro 787, 791, 793 process( ) function 901, 907, 909 227, 237, 240, 255, 275, 277, 278, 309, plog101p( ) function 60 proj( ) function 826 313, 321, 331, 395, 398, 399, 404, 432, plog1p( ) function 60, 793, 794 pscalbln( ) function 60 453, 456, 484, 487, 494, 497, 500, 501, PLOG1P( ) macro 793, 793 pscalbn( ) function 60 514, 531, 650, 656, 663, 759, 760 plogb( ) function 60 pset( ) function 60, 356, 356, 358, 359, qert( ) function 60, 471, 942 plot( ) function (Maple) 26, 27 364, 366, 367, 370, 408, 409, 780, 785, QERT( ) macro 471, 471, 472, 473 Plot[] function (Mathematica) 36, 37 789, 791 QERT_COMPLEX macro 471 plow( ) function 60, 356, 357 PSET( ) macro 356, 356, 357–359, QERT_INDETERMINATE macro 471 PLOW( ) macro 356, 357, 357 364–367, 370, 373, 375, 376, 379, 385, QERT_REAL macro 471 pmul( ) function 60, 356, 371, 383, 779, 386, 393, 456, 780, 785, 789, 791 QFMA( ) macro 227, 527, 672, 677, 741, 780, 785, 789, 791 PSET_( ) macro 456 760, 761 PMUL( ) macro 368, 371, 371, 373, 376, ψ( ) function (mathematical) 44, 61, 62, qnan( ) function 60, 80, 135, 141, 147, 779, 780, 785, 789, 791 536, 537, 538, 539, 539, 541–543, 150, 152, 154, 471, 780, 785, 791, 981, pmul2( ) function 60, 356, 369, 370, 371 552–554 984 PMUL2( ) macro 365, 368, 369, 369, 370, psi( ) function 44, 60, 62, 536, 536, 537, QNAN( ) macro 96, 135, 141, 147, 150, 152, 370, 371–373, 375, 378, 379, 393, 410, 539–543, 548 154, 192, 255, 307, 331, 373, 375, 376, 432 Psi( ) function (Maple) 537, 540, 541, 379, 433, 471, 484, 487, 491, 509, 544, pmulf( ) function 382 546, 548, 552, 553 546, 621, 633, 636, 640, 643, 650, 663, pneg( ) function 60, 356, 358, 358, 367, psi( ) function (MuPAD) 548 672, 677, 719, 730, 780, 785, 791, 889 791 PSI( ) macro xxvii, 546, 556 qnanf( ) function 154, 925, 981 PNEG( ) macro 358, 358, 367, 791 psi[n]( ) function 548 qnanl( ) function 154 pnorm( ) function 616 psi_mccullagh( ) function 544 qnorm( ) function 616 pochhammer( ) function (Maple) 752 Psif( ) function 991 QP_FMOD( ) macro 265 Pochhammer[] function (Mathematica) psif( ) function 991 QP_LDEXP( ) macro 263, 264 752 psignbit( ) function 60 QP_MODF( ) macro 263, 264 polar( ) function 994 psiln( ) function 44, 60–62, 536, 537, QP_T_MANT_DIG macro 256 POLY( ) macro 88 539, 546, 547 QP_T_MIN_EXP macro 263 POLY_n( ) macro 89 psiln( ) function (mathematical) 61, 62 quantize( ) function xxxiii, 60, 932 POLY_P( ) macro 32, 89, 277, 281, 287, 331 PSILN( ) macro xxvii, 546, 547 quantized( ) function 931, 932 POLY_Q( ) macro 32, 89, 277, 281, 287, 331 Psilnf( ) function 991 quantizedf( ) function 931 Function and macro index . . . R 1061 quantizedl( ) function 931, 934 Replace[] function (Mathematica) 21 sbkn( ) function xxviii, 60, 62, 743, 756 quantizedll( ) function 931 RESCALE_CUTOFF macro 529 sbks0( ) function xxviii, 60, 743, 757 quicksort( ) function 966 Residue[] function (Mathematica) 477 sbks1( ) function xxviii, 60, 743, 757 quicktwosum( ) function 359 Return[] function (Mathematica) 38 sbksn( ) function xxviii, 60, 743, 757 quotient( ) function 530 revert( ) function (MuPAD) 21 sby0( ) function xxviii, 60, 744 rint( ) function 57, 58, 132, 132, 138, sby1( ) function xxviii, 60, 741, 742, 745 R 139, 139, 140, 142–144 sbyn( ) function xxviii, 60, 62, 746 R( ) function (Maple) 26, 27 rint( ) function (mathematical) 138 sc( ) function (mathematical) 657–659, R21( ) function (Maple) 638 RINT( ) macro 139, 140, 143 661, 663, 666 R2P( ) macro 659 Rint( ) macro 860 scalb( ) function 482, 982 R32( ) function 31 rintf( ) function 138 scalbln( ) function 58 R32( ) function (Maple) 638 rintl( ) function 138 scalbn( ) function 58, 155, 451, 453, 471, raise( ) function 90 RN( ) function 83, 84, 403, 404 782, 785, 937 rand( ) function 162–164, 171, 206, 622, RN( ) macro 406 scalbn( ) function (mathematical) 418 630 rnexp( ) function 189, 190, 190 SCALBN( ) macro 284, 419, 451, 466, 471, rand( ) function (Maple) 551 rnnorm( ) function 192, 194 472, 558, 650, 780, 785 rand1( ) function 163, 163 rnnorm_ext( ) function 194 scanf( ) function 58, 830, 869, 870, 874, rand1_new( ) function 164, 164 RO( ) function 403, 404 877, 901–903, 905–910 rand2( ) function 163, 165 RootOf( ) function 606 sccw( ) function 211, 212 rand3( ) function 163 RootOf( ) function (Maple) 603 sd( ) function (mathematical) 659, 661, rand4( ) function 163, 165 Round( ) function 57 666 RAND_MAX macro 162–164 (round ...) function (Lisp) 130 sec( ) function (mathematical) 572 randab( ) function 340 round( ) function 57, 58, 130, 137, 137, sech( ) function (Maple) 573 randint( ) function 196, 199, 205, 206 139–141, 408, 782 sech( ) function (mathematical) 572, 657, randlog( ) function 191, 212 round( ) function (Maple) 247, 408, 609 661 randlog( ) function (mathematical) 202 round( ) function (mathematical) 137, second( ) function 60 randoffset( ) function 160, 161, 161 243, 252, 253, 263, 265, 270, 271, 279, select( ) function 169, 169 random( ) function 57 306, 578, 781, 798 seq( ) function (Maple) 552, 570 randu( ) function 171, 201 ROUND( ) macro 137, 141, 245, 250, 281 series( ) function (Maple) 11, 21, 319, RANSIGN( ) macro 382 round_odd_sum( ) function 406 554, 604 RatScale[] function (Mathematica) 41, round_odd_sum( )( ) function 405, 406 Series[] function (Mathematica) 21, 42 roundf( ) function 137 477, 601, 670, 751 RC( ) macro 656 roundl( ) function 137 series( ) function (MuPAD) 21 rcos( ) macro 322, 323 RP( ) macro 307, 308–310, 340 SET( ) macro 187, 188 rcosm1( ) macro 323 RPH( ) macro 308, 321, 340, 667 SET_EDOM( ) macro 95, 96, 135, 147, 150, RD( ) function 83, 84, 404 rsin( ) macro 322, 323 152, 154, 192, 255, 275, 307, 313, 315, re( ) function 994 rsqrt( ) function 44, 60, 62, 233, 233, 331, 335, 338, 375, 376, 379, 471, 616, re( ) function (Maple) 626 234, 237 617, 621, 633, 636, 640, 643, 663, 672, real( ) function 826 rsqrt( ) function (mathematical) 62, 234 677, 730, 780, 785, 791 real( ) function (mathematical) 448, 500, RSQRT( ) macro 650, 667 SET_ERANGE( ) macro 93, 96, 135, 192, 548, 579 rsqrtf( ) function 235, 237 225, 227, 255, 275, 375, 376, 379, 530, rec( ) function (Maple) 626 RU( ) function 83, 84, 404 621, 633, 636, 730, 785, 791, 885 reduce( ) function 265, 306 RZ( ) function 83 set_fpc_csr( ) function 78 REDUCE( ) macro 250, 265, 270, 272, 274, SET_INVALID( ) macro 141, 143 277, 279, 281, 307, 308, 340, 433, 434, S SetFloatArrayRegion( ) function 984 434, 435, 940 Sn( ) function (mathematical) 695 setjmp( ) function 91, 107 ReleaseFloatArrayElements( ) function safe_split( ) function 404, 404, 431, 432 SetOptions[] function (Mathematica) 984 samequantum( ) function xxxiii, 60, 933 40 ReleaseStringUTFChars( ) function 983 samequantumd( ) function 931, 933 setseed( ) function 205 relerr( ) function (mathematical) 468 samequantumdf( ) function 931 setxp( ) function 59, 423, 439 relulpsf( ) function 82, 82 samequantumdl( ) function 931 SETXP( ) macro 284, 421 (rem ...) function (Lisp) 130 samequantumdll( ) function 931 show( ) function 400, 935 remainder( ) function 58, 143, 143, 144, sbi0( ) function xxviii, 60, 743, 744, 747, SIGFPE macro 74, 107 146, 148, 148, 149, 150, 150, 152, 152, 750, 753 σ( ) function (mathematical) 638 153, 154, 154, 155, 827 sbi1( ) function xxviii, 60, 743, 749 σw( ) function (mathematical) 686 remainder( ) function (mathematical) sbin( ) function xxviii, 60, 62, 743, 750, Sign( ) function 922 144 754 sign( ) function 922 REMAINDER( ) macro 150, 152, 153, 154, sbin[] function (Mathematica) 751 sign( ) function (mathematical) 348, 350, 155 sbis0( ) function xxviii, 60, 743, 748, 754 467, 596, 598, 607, 680 remainderf( ) function 143, 153, 154 sbis1( ) function xxviii, 60, 743, 750 signal( ) function 90 remainderl( ) function 143, 154 sbisn( ) function xxviii, 60, 743, 753, 755 signbit( ) function 58, 975 remquo( ) function 58, 143, 143, 144, 150, sbj0( ) function xxviii, 60, 741 SIGNBIT( ) macro 135, 150, 192, 433, 509, 150, 152, 152, 155 sbj1( ) function xxviii, 60, 741, 742 530, 621, 841, 861 REMQUO( ) macro 152, 152, 155 sbjn( ) function xxviii, 60, 62, 743 signf( ) function 922 remquof( ) function 143 sbk0( ) function xxviii, 60, 743, 756 signiﬁcand( ) function (mathematical) remquol( ) function 143 sbk1( ) function xxviii, 60, 743, 756 832 1062 Function and macro index . . . U signl( ) function 922 331, 375, 376, 471, 484, 491, 500, 526, T signum( ) function 982 621, 633, 636, 640, 643, 650, 656, 663, Tn( ) function (mathematical) 987 simplify( ) function (Maple) 623 686 T( ) function (Maple) 52 Simplify[] function (Mathematica) 751 sqrtd( ) function 102 T macro 2, 4, 85, 256, 708, 883, 885 simpson( ) function (Maple) 606, 607 sqrtdf( ) function 102 T1( ) function (Maple) 638 sin( ) function 4, 44, 58, 62, 299, 304, sqrtdl( ) function 102 T2( ) function (Maple) 638 306, 314, 479, 653, 763, 813, 824, 826, sqrtdll( ) function 102 T3( ) function (Maple) 638 827 sqrtf( ) function 102, 114, 216–218 tan( ) function 44, 50, 58, 61, 62, 299, sin( ) function (Maple) 10, 21, 52, 245, sqrtl( ) function 102, 114, 217 310, 763, 824, 826, 827 653 sqrtll( ) function 102 tan( ) function (Maple) 10, 316, 319 Sin[] function (Mathematica) 21, 35–37, sqrtq( ) function 101, 102 Tan[] function (Mathematica) 17, 477 653 sqrtw( ) function 101, 102 TAN( ) macro xxv, 313, 313, 663, 677 sin( ) function (MuPAD) 21 srg521( ) function 178 tand( ) function 305 SIN( ) macro xxv, 312, 321, 323, 663, 677 sscanf( ) function 58, 896, 901, 903 tandeg( ) function 60, 313 sinc( ) function 733 sscw( ) function 211, 212 tanh( ) function 44, 58, 62, 341, 345, 352, sincos( ) function 60, 320, 320, 321, 340, stderr macro 868, 870 826, 981, 982 479 stdin macro 901 tanh( ) function (Maple) 10, 607 SINCOS( ) macro 321, 323, 487, 491, 492, stdout macro 868 tanhd( ) function 345 494, 504, 514, 688, 738 stewart_cxdiv( ) function 453 tanhdf( ) function 345 sincosd( ) function 320, 321 store( ) function 66, 66, 121, 135, 139, tanhf( ) function 352 sincosp( ) function 60 240, 359, 364, 369, 370, 780, 785, 994 tanhl( ) function 820 sincospi( ) function 60 STORE( ) macro 93, 127, 135, 139, 163, tanl( ) function 820 sind( ) function 305 240, 245, 246, 250, 313, 326, 331, 335, tanp( ) function 60, 304 sindeg( ) function 60, 313, 340, 651, 652 359, 362, 364, 365, 369, 370, 393, 397, tanpi( ) function 60, 304, 315, 318, 545 single( ) function 394 399, 404, 406, 431–433, 436, 471, 497, tanpi( ) function (mathematical) 315, sinh( ) function 44, 58, 62, 341, 352, 479, 636, 686, 746, 749, 761, 780, 785, 849 319, 320 749, 763, 826, 982 strchr( ) function 834, 847, 862, 889 TANPI( ) macro 320 sinh( ) function (Maple) 10 strcmp( ) function 886 taylor( ) function (Maple) 10–12, 277, SINH( ) macro 663 strcpy( ) function 842 319, 569, 573, 602, 603, 717 sinhcosh( ) function 60, 348, 348, 479, strcspn( ) function 909 TBITS macro 844 749 strerror( ) function 93, 94 Test( ) function 916 SINHCOSH( ) macro 504, 514 StringJoin[] function (Mathematica) test05( ) function 993 sinhf( ) function 345, 818 38 test_chisq( ) function 199, 199 sinp( ) function 60, 304, 340 StringJustifyRight[] function tgamma( ) function 44, 58, 521, 522, 525, sinpi( ) function 60, 304, 315, 316, 340, (Mathematica) 38–40 534, 535, 544, 614, 765, 766, 981 531 StringLength[] function (Mathematica) TGAMMA( ) macro xxvi, 532–534, 566 sinpi( ) function (mathematical) 315, 317 38 time( ) function 158, 159 SINPI( ) macro 318, 584 strlcat( ) function 60, 858, 862, 863 tn( ) function (mathematical) 659 sinpi4( ) function 318 strlcpy( ) function 60, 842, 846, 858, TOLOWER( ) macro 886, 890, 892, 893 sinpi4( ) function (mathematical) 316, 862, 863, 889 ToString[] function (Mathematica) 39 317 strlen( ) function 205, 846, 862, 874 toupper( ) function 848 sn( ) function (mathematical) 657–664, strncmp( ) function 893 TOUPPER( ) macro 848, 886 666, 675, 680, 683 strncpy( ) function 847, 869, 945 ToUpperCase[] function (Mathematica) snan( ) function 60, 147, 981 strpbrk( ) function 909 41 SNAN( ) macro 889 strsep( ) function 909 traperror( ) function (Maple) 10 snanf( ) function 866, 925, 981 strspn( ) function 909 trunc( ) function 58, 130, 135, 136, 136, snprintf( ) function 58, 205, 867, 868, strtoc( ) function 826 144, 166, 785, 981 870, 871, 873, 907 strtod( ) function 867, 879, 880, 885, trunc( ) function (mathematical) 136, solve( ) function (Maple) 21, 229, 486, 887, 896, 897, 901, 905, 906, 909, 910 145, 246, 279, 306 602 strtof( ) function 879, 896 TRUNC( ) macro 136, 246, 250, 281, 287, split( ) function 404, 405, 435, 435, 436, strtoimax( ) function 896 304, 364, 419, 434, 437, 501, 785 439 strtok( ) function 909 (truncate ...) function (Lisp) 130 SPLIT( ) macro 396, 396, 397, 398, 434 strtol( ) function 58, 896, 905, 909, 910 truncf( ) function 136 sprintf( ) function 58, 860, 868, 873 strtold( ) function 58, 879, 896 truncl( ) function 136 sqr( ) function 826 strtoll( ) function 58, 896, 910 TWICE_MINNORMAL macro 154 Sqrt( ) function 991, 991 strtoul( ) function 896, 905, 910 twoproduct( ) function 369 twosum( ) sqrt( ) function 4, 44, 58, 62, 70, 87, 102, strtoull( ) function 896, 910 function 359, 369 114, 192, 215, 215, 216, 217, 224, 234, strtoumax( ) function 896 type( ) function (Maple) 53 467, 471, 479, 589, 630, 826, 827, 939, SUB( ) macro 187, 188 982, 991 subs( ) function (Maple) 551 U sqrt( ) function (Maple) 10, 15, 26, 27, subs( ) function (MuPAD) 21 U_MINUS_V_Q( ) macro 187, 188 33, 51, 478, 606, 623, 626, 638, 726 sum( ) function (Maple) 47, 553, 554, 583 uacc16( ) function 261, 262 Sqrt[] function (Mathematica) 17, 601, SUM( ) macro 326, 326, 331 uadd32( ) function 209, 261, 262, 262 751 SWAP( ) macro 453, 471 UI( ) macro 152, 155 sqrt( ) function (mathematical) 808 Switch[] function (Mathematica) 41, 41 UINT_BITS macro 152, 155 SQRT( ) macro 114, 225, 227, 241, 274, System.loadLibrary( ) function 982 UINT_MAX macro 155, 166 Function and macro index . . . V 1063 uirand( ) function 165, 167–169 vbks( ) function 60, 758 WORDNUM_OF_BITNUM( ) macro 258, 258, ulp( ) function 81–84, 630, 982 vby( ) function 60, 758 259 ulp( ) function (Maple) 609 vercw( ) function 60, 211, 984 Write( ) function 922 ulpk( ) function 60 vercw_r( ) function 60, 211 WriteLine( ) function 918, 922 ULPK( ) macro 85 vfprintf( ) function 58, 868, 870, 871 writeln( ) function 993 ulpmh( ) function 60 vfscanf( ) function 58, 901, 904 wsplit( ) function 436, 438, 439 ULPMH( ) macro 85 vllrancw( ) function 211 ulps( ) function 579 vllrancw_r( ) function 211 X ulpsf( ) function 83 vllrincw( ) function 211 X1 macro 546 umul64( ) function 177, 209, 261, 261, 262 vllrincw_r( ) function 211 XBIG macro 528, 534, 536 unapply( ) function (Maple) 47 vlrancw( ) function 211, 214 XCUT_0_1 macro 544, 545 unchecked_ipow( ) function 417, 419 vlrancw_r( ) function 211 XCUT_ASYMPTOTIC macro 545 ungetc( ) function 902 vlrcw( ) function 60, 211 XCUT_MIN_32 macro 545 UNIRAN( ) macro 382, 383 vlrcw_r( ) function 60, 211 XCUT_REFLECT macro 544, 545 urand( ) function 165, 189–193, 202, 203 vlrincw( ) function 211 XCUT_TAN_2 macro 545 URAND( ) macro 192, 472, 473 vlrincw_r( ) function 211 XHIGH macro 584, 585 urandom( ) function 826 vnrcw( ) function 60, 211 xintf( ) function 129 urandtoint( ) function 165, 199, 212 vnrcw_r( ) function 60, 211 XLARGE macro 545, 547 Urcw( ) function 913, 914 vprintf( ) function 58, 868, 871 XMAX macro 526, 534, 544, 545, 584 urcw( ) function 60, 211, 212, 981 vprt( ) function 871, 873, 904 xor( ) function 206 urcw1( ) function 60, 211, 212 vsbi( ) function 60, 758 XP_EXP10( ) macro 865, 899 urcw1_r( ) vsbis( ) function 60, 211 function 60, 758 XP_FLOOR( ) macro 857 urcw1df_r( ) vsbj( ) function 211 function 60, 758 XP_FMA( ) macro 898 urcw1f( ) vsbk( ) function 925 function 60, 758 XP_FMOD( ) function 861 urcw2( ) vsbks( ) function 60, 211 function 60, 758 XP_FMOD( ) macro 860 urcw2_r( ) vsby( ) function 60, 211 function 60, 758 XP_FREXP( ) macro 857 urcw2f( ) vsbyd( ) function 213, 925 function 758 XP_LDEXP( ) macro 865, 899 urcw2l( ) 213 vscan( ) 904 function function 904, , 907, 908 XP_LOG10( ) macro 857 Urcw3( ) function 913, 921 vscanf( ) function 58, 901, 904 XP_RINT( ) macro 860 urcw3( ) function 60, 211, 921 VSET( ) macro 759 XREDMAX macro 307, 308 urcw3_r( ) function 60, 211 vsnprintf( ) function 58, 868, 871 XSMALL macro 544 Urcw3f( ) function 913, 921 vsprintf( ) function 58, 868, 871, 872 urcw3f( ) function 921, 925 vsscanf( ) function 58, 901, 904 Urcw3l( ) function 913 vsum( ) function 60 Y Y ( ) function (mathematical) 713, 714 urcw3l( ) function 921 VSUM( ) macro 275, 277, 279, 281, 286, 0 Y ( ) function (mathematical) 713 Urcw4( ) function 913, 914, 921 287, 289, 309, 347, 455 1 Yν( ) function (mathematical) 695, 823, urcw4( ) function 60, 211, 212, 921 vurcw( ) function 60, 211, 214 987 urcw4_r( ) function 60, 211 vurcw1( ) function 60, 211, 214 Y ( ) function (mathematical) 62, 694, Urcw4f( ) function 913, 914, 921 vurcw1_r( ) function 60, 211 n 695, 696, 697, 701, 715, 716, 755, 769 urcw4f( ) function 921, 925 vurcw2( ) function 60, 211 y ( ) function (mathematical) 740 Urcw4l( ) function 913, 914 vurcw2_r( ) function 60, 211 1 y ( ) function (mathematical) 62, 695, urcw4l( ) function 921 vurcw3( ) function 60, 211 n 731, 735 urcw_r( ) function 60, 211 vurcw3_r( ) function 60, 211 y0( ) function xxvii, 60, 694, 714 Urcwf( ) function 913, 914 vurcw4( ) function 60, 211, 214 y1( ) function xxvii, 60, 694, 715 urcwf( ) function 925, 981 vurcw4_r( ) function 60, 211 YMAX macro 246 Urcwl( ) function 913, 914 vurcw_r( ) function 60, 211 yn( ) function xxvii, 60, 62, 120, 122, 123, USE_ASM macro 241, 292, 338, 352 694, 717 USE_CHEBYSHEV macro 708 W USE_DEKKER_CBRT macro 379 W( ) function (mathematical) 627 USE_DEKKER_SQRT macro 376 w( ) function (mathematical) 627 Z USE_FP_T_KERNEL macro 310, 345, 350 WeierstrassP( ) function (Maple) 685 Zν( ) function (mathematical) 695 ζ USE_SERIES macro 708 WeierstrassP[] function (Mathematica) ( ) function (mathematical) 542, USE_XOR_ENCRYPTION macro 205, 206 685 551–554, 557, 579, 579, 581, 582, 582, usplit( ) function 438, 439 WeierstrassPPrime( ) function (Maple) 583, 583 ζ 685 n( ) function (mathematical) 695 ζ V WeierstrassPPrime[] function w( ) function (mathematical) 686 va_arg( ) macro 908 (Mathematica) 685 zeta( ) function 60, 583 va_end( ) macro 870, 873, 903 WeierstrassSigma( ) function (Maple) Zeta( ) function (Maple) 581, 583 va_list macro 868, 870, 871, 873, 901, 688 Zeta[] function (Mathematica) 583 903, 904 WeierstrassSigma[] function ZETA( ) macro xxvii, 585, 586 va_start( ) macro 870, 873, 903 (Mathematica) 688 zetac( ) function 583 vagm( ) function 60 WeierstrassZeta( ) function (Maple) zetam1( ) function 60, 585 VAGM( ) macro 620, 640, 643, 662, 663 688 ZETAM1( ) macro xxvii, 585, 586, 592 vbi( ) function 60, 758 WeierstrassZeta[] function zetnm1( ) function 60 vbis( ) function 60, 758 (Mathematica) 688 ZETNM1( ) macro 551, 585, 586, 592 VBIS( ) macro 761 While[] function (Mathematica) 38 zetnum( ) function 60 vbj( ) function 60, 758 with( ) function (Maple) 28, 29, 47, 48, ZETNUM( ) macro 551, 554, 557, 584–586 vbk( ) function 60, 758 52, 53, 270, 606, 724, 726 Subject index

IN THE BAD OLD DAYS, THE INDEX WAS A LIST OF PROHIBITED BOOKS; MAY WE NOW, INAMORE ENLIGHTENED AGE, BAN BOOKS WITHOUT INDEXES?

—STEPHEN JAY GOULD An Urchin in the Storm (1987).

Page numbers of biographical, deﬁning, and primary entries are in bold. Publication titles explicitly cited in the text are in italic. Names of people are indexed if they are explicitly mentioned prior to the bibliography. Personal names in the bibliography are recorded in the separate author/editor index on page 1039. Index entries for words inside verbatim code blocks are generated at end-of-block. Thus, blocks that cross page boundaries may produce off-by- one page numbers in this index. The Greek letter entry has subentries for each such letter used in this book, but ordered by their names in the Latin, rather than Greek, alphabet.

Symbols .so file 920 *.dat.maple file 771 /6 (model) 597, 948, 970 *.log file 771 /7 (model) 597, 948, 970 *.map file 29 /depot/lib/libmcw.a file xxxv -Dvolatile= option 66 /dev/random file 207 -G option 980 /dev/urandom file 207 -I option xxxv /usr/local file xxxv -L option xxxv, 946 ## directive 3 -O3 option 218 #define directive 3, 116, 130, 131, 218, 219, 235, 237, 238 -R/usr/local/lib option 944 #elif directive 3 -Wl,-rpath,/usr/local/lib option 944 #error directive 3 -autodbl option 968 #if directive 130 -classpath option 980 #include directive 101, 111, 113, 114, 130, 131 -fno-builtin option xxxv, 216 #pragma directive 110, 113, 114 -fpwidetypes option 100, 101 #undef directive 924 -ftrap option 946 $MachinePrecision option (Mathematica) 35, 39 -g option 218 % input conversion specifiers 906 -gnaty option 913 % output conversion specifiers 873, 874 -ieee option xxxv _Complex keyword 441 -ieee_with_inexact option xxxv _Complex_I keyword 441, 442 -lc option 825 _Imaginary data type 441, 463 -lc128 option xxxv _Imaginary_I keyword 441, 442 -lfdm option 811 _ _GROUP_ _ global variable 851 -lfmcw option 946 _ _float128 data type 101, 877 -lm option xxxv, 320, 765, 811, 825 _ _float128_pair data type 355 -lmcr option 811 _ _float80 data type 101, 877 -lmcw option 765, 771, 946 _ _float80_pair data type 355 -lmf option 811 _ _fpreg data type 101 -lsunmath option 294 _ _mcw_fe_dfl_env global variable 116, 117 -lultim option 811 _ _volatile_ _ keyword 293, 339 -mfp-rounding-mode=d option xxxv 1 (model) 305, 948, 949, 951–953, 965, 970, 971 -mieee option xxxv 1000 (model) 970 -mieee-conformant option xxxv 1010 (model) 970 -mieee-with-inexact option xxxv 1100 (model) 74, 965, 966, 970, 972 -qlongdouble option xxxv 1107 (model) 353 -trapuv option 931, 951 1130 (model) 948, 970 -unsafe option 921 1400 (model) 970 ../maple file 771 1520 (model) 976 .NET Framework viii, 867, 917 1604 (model) 948, 949, 970 .adb file 911 160A (model) 970 .ads file 911 160G (model) 970 .dll file 920 1650 (model) 353 .dylib file 920 1700 (model) 396, 949 .exe file 919 1S (model) 948, 952

2 (model) 948, 952, 969, 970 8600 (model) 951 200 (model) 948 88000 (CPU) 970 2000/213 (model) 970 88100 (CPU) 86 210B (model) 970 900 (model) 970 250 (model) 970 9080 (model) 948, 970 3 (model) 976, 977 924 (model) 970 3000 (model) 949 3000/400 (model) 976, 977 A 3090 (model) 976, 977 A Mathematical History of Golden Number 8 3200 (model) 970 A Short Account of the History of Mathematics 927 32016 (CPU) 970 A Treatise on the Theory of Bessel Functions 693 3400 (model) 948 ABC (model) 970 3600 (model) 353, 520, 948, 949, 970 Abel, Niels Henrik (1802–1829) 7, 619 386 (model) 976 Abrham, A. 217 386i (model) 977 abrupt underflow 78 4 (model) 976, 977 absolute value 4.3BSD operating system 237, 273, 290 complex arithmetic 443, 444 4004 (CPU) 283, 970 of most negative integer 73, 74, 973 418 (model) 970 pair-precision arithmetic 358 470 (model) 963 safe integer 74 490 (model) 970 acc_t data type 897 50 (model) ix acceleration of convergence 582, 589 502 (model) 970 accuracy of algorithms 811 503 (model) 970 Accuracy of Floating Point Arithmetic 366 520 (model) 970 Accurate Portable Mathematical Library 827 600 (model) 305, 947, 948, 958, 970 ACM Algorithm 116 451, 452 6000 PPU (model) 970 ACM Collected Algorithms 583 6000 (model) 74, 80, 305, 948, 949, 970 ACM Transactions on Mathematical Software 214 601 (model) 970 ACM Transactions on Mathematical Software (TOMS) 475, 583, 826 6080 (model) 958 ACM Transactions on Modeling and Computer Simulation 214 620 (model) 353 ACM Turing Award 763, 941, 959, 963 6200 (model) 949 ACRITH package 967 6400 (model) 949, 970, 989 acroread program 1115 650 (model) 948 Ada 6500 (model) 949 deficiencies in mathematical library 223 6502 (CPU) 971 Ada 95 Reference Manual 914 6600 (model) 949, 951 ada file 911 6700 (model) 949 Ada interface 68000 (CPU) 65, 68, 124, 145, 146, 150, 217, 240, 292–294, 338, 352, building 911, 911 362, 363, 395, 401, 823, 970 programming 912 68020 (CPU) 976 using 915 68040 (CPU) 71, 216 Ada language vii, 1, 2, 223, 355, 829, 830, 870, 875, 899, 911–916, 7/32 (model) 970 923, 927, 928, 977, 993, see also Lovelace, Lady Augusta Ada 700 (model) 959 addition, safe integer 75 7000 (model) 74, 80, 305, 948, 959, 970 addition-rule evaluation 98 7030 Stretch (model) 948, 949, 959, 969–971 address, endian problem 930 704 (model) 353, 948, 959, 961, 963, 970, 971 Adobe (vendor) vii 7040 (model) 353, 948, 970 Advanced Encryption Standard (AES) 178, 208 7044 (model) ix, 353, 948 Advanced Scientific (vendor) 970 709 (model) 341, 353, 948 AEI (vendor) 970 7090 (model) 353, 520, 948, 954, 970, 971 AES see Advanced Encryption Standard 7094 (model) 353, 948 AGM see arithmetic-geometric mean 7600 (model) 949 Airy function 695 8/32 (model) ix, 896, 948, 965, 970 Airy, Sir George Biddel (1801–1892) 695 8008 (CPU) 970 AIX operating system xxxv, 71, 87, 109, 218, 233, 355, 816, 817 801 (CPU) 86 al-Khwarizmi, Muhammed (ca. 780–850) 575 80186 (CPU) 971 algebra, origin of word 15, 575 80286 (CPU) 971 Algol 60 language vii, 73, 353, 978 803 (model) 970 Algol 68 language vii 80386 (CPU) 976 Algol language 763, 873, 963 8080 (CPU) 954, 971 algorithm 8086 (CPU) 970, 971 accuracy 811 8087 (CPU) vii, 63, 105, 825, 928 add-with-carry generator 177 840A (model) 970 AES (Advanced Encryption Standard) 178 85 (model) 948 annuity (financial instrument) 294 86 (model) 948 argument reduction 243 Subject index . . . A 1067

argument reduction (exact) y1(x) 738, 740 implementation 253 Yn(x) 715, 716 retrospective 265 yn(x) 738 testing 265 Yν(x) 698 theory 250 beta function 589, 590 argument reduction (simple trigonometric) 243 beta function, minus one 590 arithmetic-geometric mean agm(a, b) 621 binary search 976 asymptotic expansion 19 Birthday Spacing test of random-number generator 200 backward evaluation of continued fraction 12 ceiling function ceil(x) 136 base determination 103 chi-square function 561 Bessel function cn(u, k) 659 bis0(x) 725 combined generator 177 bis1(x) 725 complementary cumulative distribution function Φc(x) 614 bks0(x) 726 complementary error function erfc(x) 595 bks1(x) 726 complex absolute value 443, 444 downward recurrence premature underﬂow 759 complex addition 445 I0(x) 724 complex argument 445 i0(x) 738, 744 complex conjugate 446 I1(x) 724 complex conversion 448 i1(x) 738, 747 complex copy 448 In(x) 728 complex cube root 485 in(x) 738, 743, 750 complex division is0(x) 746 avoiding subtraction loss 455 is1(x) 749 C99 Standard 449 Isn(x) 719, 721, 724 C99 style 449 isn(x) 753 LAPACK style 452 J0(x) 707, 708 Priest style 453 j0(x) 733, 734, 738 Smith style 451 J1(x) 707 special cases 449 j1(x) 738, 740 Stewart style 452 Jn(x) 710, 712 subtleties 451 jn(x) 738 complex exponential 487 Jν(x) 698 complex exponential minus one, cexpm1()z 492 K0(x) 726 complex function k0(x) 738 preserving symmetry properties 447 K1(x) 726 principal value 476 k1(x) 738 complex hyperbolic functions 509 Kn(x) 728 complex imaginary part 456 kn(x) 738, 743, 754 complex inﬁnity test 462 Ksn(x) 719, 721 complex inverse hyperbolic functions 514 ksn(x) 754 complex inverse trigonometric functions 504 large argument 716 complex logarithm 495 large index 716 complex logarithm near one 497 ratio in(x)/in−1(x) 750, 753 complex multiplication 456 ratio Iν(x)/Iν−1(x) 721, 729 complex NaN test 462 ratio jn(x)/j0(x) 738 complex negation 459 ratio Jν(x)/Jν−1(x) 702, 710, 712 complex power 500 research literature 693 complex projection 460 sbi0(x) 738, 744 complex real part 460 sbi1(x) 738, 749 complex square root 480 sbin(n,x) 738, 750, 753 complex subtraction 461 sbisn(n,x) 753 complex trigonometric functions 502 sbj0(x) 733, 738 compound interest 294 sbj1(x) 738, 741 congruential generator 171 sbjn(n,x) 738 continued fraction sbk0(x) 738 backward evaluation 12 sbk1(x) 738 forward evaluation 12, 17 sbkn(n,x) 738, 755 Lentz algorithm 18 sbksn(n,x) 755 Steed algorithm 17 sby0(x) 734, 738 cosine 306 sby1(x) 738, 741 cosine and sine together 320 sbyn(n,x) 738 cryptographic 214 sequences 755 cryptographic generator 178 Y0(x) 705, 713 cube root 237 y0(x) 734, 738 cumulative distribution function Φ(x) 616 Y1(x) 713 digits in base conversion 831 1068 Subject index . . . A

divide and conquer 425 eljtda() 676 dn(u, k) 659 inverse 664 duplication rule for elliptic functions 648 Jacobian Eta function 679 e (leading digits of) 268 Jacobian Theta function 679, 681 elementary functions Jacobian theta function 673 from elliptic auxiliary function 655 logarithmic derivative 675 in hardware 240, 292, 338, 350 Jacobian Zeta function 679, 681 elliptic function Kahan’s quadratic-equation discriminant 472 auxiliary functions RX () 648 KISS generator 202 E(m) 637 lagged Fibonacci generator 176 E(m) 637 leading digits of e 268 elk(q) 669 Lentz continued fraction 18, 710 elkm1(q) 671 linear congruential generator 171 elle(k) 638 log-gamma function lgamma(x) 534 ellec(k) 641 logarithm 282 ellk(k) 632 argument near one 290 ellkc(k) 635 by AGM 624 first kind 624 decimal base 287 historical forms 652 machine epsilon 62, 354, 779, 849 K(m) 631 Mersenne Twister generator 202, 207 K(m) 631 test results 200, 201 RC (x, y) 649 multiple recursive congruential generator 176 second kind 627 multiplication on early Cray models 953 third kind 630 multiplicative congruential generator 171 error function 593 multiply-with-carry generator (MCW1038) 177 error function erf(x) 595 Neville theta functions 678 Euclid test of random-number generator 200 Newton–Raphson iteration for elwk() 685 Euclidean norm 113 oldest known 181 exponential function exp(x) 270 origin of word 15, 575 Tang style 271 pair-precision function exponential minus one, expm1(x) 273 pabs() 358 fdlibm error function 595 padd() 366 floor function floor(x) 136, 137 pcbrt() 378 forward evaluation of continued fraction 12, 17 pcmp() 368 fused multiply-add 388 pcon() 788 fused multiply-add error correction 406 pcopy() 357 gamma function tgamma(x) 525 pcos() 799 Gorilla test of random-number generator 200 pdiv() 372 historical elliptic integrals 643 pdot() 386 historical inverse error function 603 peps() 779 history 59 peval() 357 hyperbolic cosine 347 pexp() 782, 783 hyperbolic cosine and sine together 348 phigh() 357 hyperbolic functions 341, 804 pipow() 778 hyperbolic sine 347 plog() 787, 789 hyperbolic tangent 344 plow() 357 hypotenuse 224 pmul() 371 iterative computation 227 pmul2() 369, 370 improvement on Cody/Waite 823 pneg() 358 incomplete gamma function 562 pprosum() 386 integer and fraction function modf(x,y) 134 pset() 356 integer power ipow(x,n) 415, 777 psplit() 363 interest (compound) 294 psqrt() 373, 375 inverse chi-square function 567 psub() 367 inverse complementary cumulative distribution function Φc(x) psum() 384 614 psum2() 359 inverse cosine by AGM 623 pi (π) by the AGM 622 inverse cumulative distribution function Φ−1(x) 617 polygamma function 556 inverse error function 605, 609 power function pow(x,y) 421 inverse hyperbolic cosine by AGM 623 psi function ψ(x) 543 inverse hyperbolic functions 348, 349 psi function psiln(x) 546 inverse tangent 336 quadratic congruential generator 176 inverse tangent by AGM 623 quadratic equation solution 467 Jacobian elliptic function 657 random integer in given range 165, 167 eljag() 662 random integers in order 168 eljsc() 663 remainder function Subject index . . . A 1069

fmod() 146, 153 AMI (vendor) 971 remainder() 149, 152, 154 amsfonts package 1115 remquo() 150 amsmath package 1115 Riemann zeta function An Atlas of Functions 657 zeta(x) 583 An Urchin in the Storm 1065 zetam1(x) 585 Analytic Theory of Continued Fractions 19 zetnm1(x) 585 Anderson, Carl David (1905–1991) 475 zetnum(x) 585 Anger’s function 695 rounding function annuity (financial instrument) 294 llrint(x) 143 error magnification 295 llround(x) 141 Anomalies in the IBM ACRITH Package 967 lrint(x) 142 ANSI standards see ISO standards lround(x) 140 ANSI X3.9-1978 Fortran vii, 830 nearbyint(x) 139, 140 ANSI/ISO/IEC 1539-1:1997 Fortran Standard vii, 106 rint(x) 138 ANSI/MIL-STD-1815A Ada Standard vii round(x) 137 ansi2knr package 2 scaled complementary error function erfcs(x) 598 antilogarithms 282 secret is suspect 208 APMathLib package 811, 820, 827 sequences of Bessel functions 729 Apollo (vendor) 948 series inversion 20 Apple (vendor) x, 71, 109, 818, 982 sine 306 Applied Cryptography 214 spherical Bessel function Applied Statistics 214, 583 jn(x) 735 Approximations for Digital Computers 827 sbjn(n,x) 735 arc cosine see acos sbyn(n,x) 735 arc hyperbolic cosine see acosh yn(x) 735 arc hyperbolic sine see asinh spherical Bessel functions 731 arc hyperbolic tangent see atanh square root 217 arc sine see asin Steed continued fraction 17, 710 arc tangent see atan subtract-with-borrow generator 177 AGM algorithm 623 tangent 310 signed zero 70 continued fraction 17 arccos see acos testing nonuniform generator 202 Archimedes (ca. 287–212 BCE) 267 testing uniform generator 196 architecture see also CPU theory of random-number generation 214 CDC family 949 truncation function trunc(x) 136 Cray family 952 vector sum 385 DEC PDP-10 953 vector sum (exact) 385 DEC PDP-11 956 Weierstrass function DEC VAX 956 ℘() 689 General Electric family 958 σw() 689 IBM family 959 ζw() 689 Lawrence Livermore National Laboratory S-1 965 zeta function arcsin see asin zeta(x) 583 arctan see atan, atan2 zetam1(x) 585 Ardent (vendor) 952 zetnm1(x) 585 argument zetnum(x) 585 hidden 941 Algorithms + Data Structures = Programs 3 purification 97–99, 237, 239, 240, 339, 597, 766, 768, 811 all make target xxxv argument reduction 243 all-hp make target xxxv base conversion 837 Allen, Frances Elizabeth 959 catastrophic bit loss 763 Alliant (vendor) 952 cosine 304, 306, 308 Alpha (CPU) xxxv, 68, 71, 79, 86, 105, 107, 108, 121, 123, 131, 147, critical for Bessel functions 709, 734, 740, 762 153, 216, 240, 439, 459, 812, 953, 956, 970, 976, 990 difficulty in pair-precision arithmetic 797 not fully conformant to IEEE 754 Standard 79 effect on accuracy of complex functions 489, 504, 512, 520 ALPINE operating system 825 elliptic functions of large modulus 663 Alto (model) 954 exact 250, 253, 489, 512, 659, 667, 734 ALWAC III-E (model) 970 exponential 271, 272, 274, 275, 277, 279, 281, 781, 787 AMD (vendor) 65, 293, 339, 1021 logarithm 283, 285, 291 AMD64 (CPU) ix, 65, 68, 69, 71, 108, 121, 123, 124, 131, 177, 216, Payne/Hanek algorithm 253 217, 220, 235, 239, 240, 242, 352, 362, 363, 382, 388, 439, 459, powers of integers 418 681, 696, 765, 813, 824, 825, 911, 928, 967, 1115 retrospective 265 precision control on 124 role of remainder functions 156 Amdahl (vendor) 963 simple 243 Amdahl, Gene Myron (1922–2015) 963 sine 304, 308, 531 American Revolution 206 tangent 304, 310 1070 Subject index . . . B

testing 265 Autometrics (vendor) 970 trigonometric functions 243, 244, 250, 531, 709, 740, 762 awk language vii, 31, 811 with respect to π 306 AxesLabel option (Mathematica) 37 argument-passing conventions Axiom language 694, 773 C 356 Fortran 941 B Pascal 991 B2n (Bernoulli number) 303, 304, 342, 525, 542, 554, 569–571, arithmetic see also floating-point arithmetic 573–575, 577, 582, 585, 800 biased integer 974 B macro see also BASE macro D’s-complement integer 263 B1700 (model) 948, 969, 970, 977 exception 106 B5000 (model) 970 excess-n integer 974 B5700 (model) 305, 948 integer division by zero 975, 977 B6700 (model) 305, 948 integer overflow 550, 973–976, 978 B7700 (model) 305, 948 integer parity test 975 Babbage, Charles (1791–1871) 911 integer sign test 975 Babylonians 8, 299 nine’s-complement integer 263 backward evaluation of continued fraction 12 one’s-complement integer 263, 951, 954, 972 Bailey, David Harold 4, 366, 407, 777 pair-precision 353 Ball, Walter William Rouse (1850–1925) 927 sign-magnitude integer 961, 971 Ballistic Research Laboratories Electronic Scientific Computer see two’s-complement integer 132, 140, 142, 890, 896, 917, 952, 954, BRLESC 955, 958, 963, 972 Ballistics Research Laboratory (vendor) 970 arithmetic-geometric mean 619 base 62 book about 623 decimal 927 Arpanet 954 hexadecimal 24, 25, 155, 283, 290, 423, 427, 428, 437, 596, 608, arprec package 4 617 array package 1115 octal 283 ASC (model) 963 run-time determination 103 ascending order for random integers 168 BASE global variable 43, 782 ASCII character set 905, 969, 983 BASE macro see also B macro ASI 2100 (model) 970 base-conversion precision 853 asin.h header file 326 based number AspectRatio option (Mathematica) 37 conversion specifier 874 assembly (executable program in C#) 919 definition 829 assembly language in C 106, 241, 292, 339, 388, 392 input conversion 899 system header file 3 BaseStyle option (Mathematica) 37 asteroid BASIC language 251, 954 1552 Bessel 693 Basset function 695 orbital eccentricity 630 Bateman G function 555 asymptotic expansion 19 bc program 362, 408, 409, 1115 Bessel function Iν(z) 723 BCC-500 (model) 948 Bessel function Jν(x) 697 BCD character set 928, 961 Bessel function Kν(z) 723 BeEF package 774 Bessel function P(ν, x) 698 Bell Laboratories x, 168, 341, 763, 775, 823, 941, 969 Bessel function Q(ν, x) 698 mathematical software libraries 823 Bessel function Yν(x) 697 Bell Laboratories (vendor) 463 Φ ( ) complementary cumulative distribution function c x 615 bell-shaped curve 192 complementary error function erfc(x) 20, 595, 769 Berkeley (vendor) 237, 273, 290, 948 cumulative distribution function Φ(x) 615 Berlin papyrus 465 factorial function n! 525 Bernoulli family biography 591 gamma function Γ(x) 524, 527 Bernoulli Number 569 general f (x) 19 Bernoulli numbers 303, 304, 319, 342, 525, 542, 554, 568, 574, 800 log-factorial function 525 Bernoulli, Daniel (1700–1782) 693 log-gamma function 525, 528, 536, 569 Bernoulli, Jacob (or Jacques or James) (1654–1705) 568 polygamma functions 554, 555, 570 bernum.c file 572 psi function ψ(x) 542, 570 bernum2*.c file 575 Asymptotics and Special Functions 19 bernum3*.c file 575 AT&T Bell Laboratories see Bell Laboratories bernumf.c file 572 atan.h header file 32, 89 bernx.h header file 573 atan2x.h header file 70 Berra, Lawrence Peter “Yogi” 61 atanhx.h header file 348, 350 Bessel function 20, 57, 60, 120, 123, 541, 591, 693, 695, 823, 826, 987 atanx.h header file 32, 88, 89 cylindrical 693, 694, 769 Atlas (model) 948, 970 I0(x) 724 attribute list (in C#) 921 I1(x) 724 authidx package 1115 In(x) 718, 728 authidx program 1115 J0(x) 707 Subject index . . . C 1071

J1(x) 707 output conversion 851 Jn(x) 695, 697, 710 binomial K0(x) 726 coefficient 43, 571, 573 K1(x) 726 distribution 195 Kn(x) 718, 728 binx.h header file 728 near zeros 716 biography of mathematician 59 Y0(x) 713 Birds and Frogs (2008 AMS Einstein Lecture) 475 Y1(x) 713 Birthday Paradox 206 Yn(x) 695, 697, 715 Birthday Spacings test 200 modified 718 bisnx.h header file 728 ratios 702, 710, 712, 721, 729, 738, 750, 753 BIT 476 recurrence bit cylindrical functions 700 count 166 In(z) 720, 721, 723, 729, 755, 759–761 guard 67, 68 in(z) 734, 750, 752, 753 origin of word 969 is1(z) 750 rounding 67, 68 isn(z) 754 sticky 67, 68 J0(x) 705 bknx.h header file 730 Jn(x) 700, 701, 706, 710, 712, 717, 755, 759, 761 Blinn, James Frederick 956 jn(z) 737, 738 Bliss language 873, 954 Kn(z) 720, 723, 729, 755, 761 bm-fma.c file 404, 405 kn(z) 754 Boldo, Sylvie 366, 403 P(ν, x) 698 Bolender, Gerd 366 sbin(n, x) 750, 753 bond (financial) 297 sbkn(n, x) 755 bool data type 453 spherical functions 733 Bowler, Roger x Yn(x) 700, 701, 716, 755, 761 Brake option (Mathematica) 34 yn(z) 737, 739 branch cut 476, 732 retrospective 761 numerical and symbolic computation 478 sequences 755 Branch Cuts for Complex Elementary Functions or Much Ado About spherical 693, 731 Nothing’s Sign Bit 476 i1(x) 747 break statement 219, 240, 264, 416, 566, 783, 842, 881 in(x) 731, 743 Brent, Richard Peirce 28 is0(x) 746 Brigham Young University 961 is1(x) 749 British mil 305 isn(x) 750, 753 BRLESC (model) 970 j1(x) 740 Brooks, Jr., Frederick 963 jn(x) 731, 735 bugs kn(x) 731, 743, 754 inexact flag unset on 128-bit overflow and underflow on Alpha ksn(x) 754 79 y1(x) 740 invalid flag not set properly on IA-32 80 fma() INUX yn(x) 731, 735 incorrect on most GNU/L systems 87 Bessel, Friedrich Wilhelm (1784–1846) 693, 695 compiler mishandling of negative zero 885 beta*.map file 590 computation of relative error 99, 940 betnm.h header file 590 failures to detect integer overflow in C library routines 889 Bézout’s identity 186 from language features 982 Bias option (Mathematica) 34 integer overflow in binary search 425, 976 biased integer 974 build-all program ix, 1115 BibNet Project xi, 228 Bull (vendor) 970 BUNCH (IBM competitors) 949 BIBTEX 954 bibtex program 1115 Burroughs (vendor) 305, 948, 949, 969, 970, 977 BID see Binary Integer Decimal Byron, Lord George Gordon Noel (1788–1824) 911 big epsilon 63 byte big-endian addressing 963 origin of word 969 big-oh notation, O(xn) 11 storage order 2, 867, 917, 930, 956, 963 bill (financial) 297 variable size 257, 959, 966, 969 binary 158 BYTE data type 941 conversion specifier 873, 874 ByteInt data type 990 floating-point conversion specifier 907 IEEE 754 floating-point arithmetic 63, 65, 67, 68 C notation 977 C language vii, x, xii, xxxv, xxxvi, 1–6, 24, 29, 34, 37, 39–42, 47, 48, search 425 52, 54, 56–62, 64–66, 69–74, 77, 80, 81, 87, 90–93, 95, 96, 99–102, Binary Floating-Point Arithmetic for Microprocessor Systems 133 104–110, 112, 113, 115, 117, 123–125, 127, 129, 130, 132, 133, Binary Integer Decimal (BID) 928, 929, 930 135, 139–144, 147, 152, 155, 156, 159, 167, 173, 176, 181, 186, binary number 200, 206, 211, 218, 236, 238, 239, 241, 246, 251, 254, 256–258, input conversion 879 260, 264, 283, 290, 304, 326, 338, 340, 347, 353–356, 358, 359, 1072 Subject index . . . C

362, 365, 385, 397, 400, 404, 407, 410–413, 421, 426, 441, 448, CDC (vendor) 74, 80, 85, 305, 353, 365, 396, 520, 948–953, 956, 453, 459, 463, 472, 478, 488, 521, 560, 561, 583, 591, 595, 598, 963–965, 969, 970, 972, 989 614, 625, 675, 682, 690, 691, 694, 708, 712, 763–765, 769, 771, Indefinite floating-point value 80, 950 772, 778, 780, 783, 785, 789, 824–827, 829, 830, 832, 834, 840, Cedar language 954 841, 845, 848, 850, 851, 853, 854, 860, 867, 869, 870, 873, 875, ceiling function 136 877–880, 886, 887, 889, 890, 892, 896, 897, 899, 901, 902, 904, Central Limit Theorem 194, 196 905, 908–911, 913, 914, 916, 917, 921, 923–925, 928, 931–933, numerical demonstration 196 936, 940–945, 955, 956, 962, 965, 966, 972, 975, 978–984, 989–994 Cephes package 133, 521, 583, 644, 708, 811, 821–823 C Mathematical Function Handbook 827 certificate authority 204 C++ char * data type 990 deficiencies in mathematical library 223 char data type 257, 877, 906–908 C++ interface 923 character conversion specifier 873 building 923 CHARACTER data type 941, 942, 945 programming 924 character set using 925 ASCII 905, 969, 983 C++ language vii, xxxv, 1, 2, 4–6, 29, 52, 57, 69, 71, 73, 74, 90, BCD 928, 961 100–102, 106, 109, 124, 125, 173, 176, 200, 211, 223, 354, 355, EBCDIC 905 365, 410, 441, 763, 776, 826, 827, 830, 870, 878, 917, 920, regular expression 880 923–925, 928, 932, 936, 967, 979, 982–984, 994 Unicode 921, 983 C++98 language 57 vendor/model dependence 963 C89 language xxxv, 2, 3, 57, 58, 91, 93, 115, 121, 135, 162, 209, 223, CharSet keyword 921 231, 233, 254, 255, 336, 341, 358, 362, 365, 413, 420, 441, 719, chebfit.mth file 56 765, 785, 868, 869, 871, 873–875, 877, 896, 906, 908 chebfun package 57 c89 program 816 Chebfun Project 57 C99 language xxxv, 1, 3–5, 57, 58, 74, 78, 85, 89, 91–95, 100, Chebyshev polynomial 105–110, 117, 120, 122–125, 127, 130–133, 155, 156, 173, 209, closed forms 43 210, 218, 219, 223, 227, 231, 233, 237, 256, 260, 284, 336, 338, coefficient sorting 47 341, 358, 362, 370, 377, 385, 388, 405, 406, 409, 410, 412–415, conversion to rational form 52,55 419, 441, 442, 444–446, 448, 449, 451, 453, 455, 456, 458–464, definitions 48 466, 482, 485, 489, 490, 492, 495–497, 500, 502, 507, 512–514, economization 43, 58, 526, 535, 604, 703, 704, 707, 709, 713, 715, 517, 518, 520–522, 524, 525, 534, 593, 719, 765, 785, 787, 791, 724 792, 829, 830, 832, 834, 841, 842, 848, 850, 857, 860, 868–870, equal extrema 44 873–875, 877–879, 885, 896, 897, 902, 906–908, 937, 942, 951, error compensation 50 953, 954, 957, 964, 978, 979, 982 evaluation 48 c99 program 818, 819, 822 fit improvement 51 C9X Rationale 223 fitting in Maple 47, 51 C# fitting in Mathematica 56 deficiencies flexibility and generality 46 binary arithmetic 4, 80, 104, 105, 918 forms 45 decimal arithmetic 102 function representation 57 integer arithmetic 978 numerical stability 48 mathematical library 57, 70, 223 orthogonal 44 virtual machine viii, 80, 917 plots 46 C# interface recurrence relation 45, 48 building 917, 918 summation formula 43 programming 920 zeros 56 using 922 Chebyshev, Pafnuty Lvovich (1821–1894) 43, 702 C# language vii, viii, 2, 4, 57, 70, 80, 90, 100, 102–105, 223, 341, 826, check-hp make target xxxv 830, 917–923, 927, 978, 994 checked keyword 90, 918, 978 CACM (Communications of the ACM) 826 Chen–Ho encoding 928 Calcomp (vendor) 970 chi-square Calculating Instruments & Machines 829 distribution 195 calculator see also hoc measure 197, 198, 988 Leibniz’s 8 test 197 multiple-precision 408 China 8 Pascaline 972, 989 chkasm.c file 770 calligra package 1115 chkasm.h header file 770 Cambridge (vendor) 970 chkasm.map file 770 Cartesian form of complex number 443 chkatan2.c file 338 case statement 416, 789, 873, 904, 940 chkatan2d.c file 338 Catalan’s constant 587 chkdelim program 1115 Catalan, Eugène Charles (1814–1894) 587 chkell.c file 681 catch statement 90, 830, 918 chktex program 1115 Cauchy, Augustin Louis (1789–1857) 194 ciphertext 203, 206 cc program xxxv, 388, 812, 815–817, 820, 821, 905 CITAC (vendor) 970 cc128 program xxxv ckfinite instruction 918 Subject index . . . C 1073 class one’s-complement arithmetic problems 972 Math 57, 920, 921, 979, 981, 982, 985 precision control 124, 401 MathCW 921, 925, 979–982, 985, 990 rounding control 105, 845, 951 numeric_limits 106 shared-library support 944 Single 100 storage initialization with NaN 931, 951 class (programming construct) 2, 920, 979 subnormals flushed to zero 78, 79 class file for Java 979 two’s-complement arithmetic problems 978 CLASSPATH environment variable 980 type promotion 79, 968 Clemens, Samuel Langhorne (1835–1910) see Twain, Mark unsafe floating-point optimizations 64, 163 CLI see Common Language Infrastructure variable argument count handling 871 CLR see Common Language Runtime warning diagnostic elimination 331 COBOL language vii, 763, 927, 928, 963 complementary error function 593, 593 Cody, Jr., William J. v, viii, xxv, 1, 2, 4, 10–12, 23–26, 28, 32, 42–44, inverse 600 52, 57, 59, 61, 70, 79, 98, 102, 215, 245, 246, 270–272, 284, 285, scaled 598 287, 289, 290, 298, 306, 308, 310, 324, 325, 332, 336, 340, complex arithmetic 441, 475 343–345, 349, 411, 412, 414, 421, 423–429, 433, 434, 438, 440, absolute value 443 644, 714, 763, 765, 781, 797, 798, 804, 811, 823, 823, 826, 939, absolute value from hypotenuse 444 940, 949 addition 445 cohaversine function 301 argument 445 col program 1115 conjugate 446 color package 1115 conjugation symmetry 446 colortbl package 1115 copy 448 combined cube root 485 generator 177 data conversion 448 Tausworthe generator 177 division 449, 451–453 Comet avoiding subtraction loss 455 Halley’s 9, 630 elementary functions 475 Kohoutek 630 exponential 487 comet, orbital eccentricity 630 complex exponential minus one cexpm1()z 492 command program 954 hyperbolic functions 509 comments in input files 909 imaginary part 456 commercial mathematical libraries 826 infinity test 462 Common Language Infrastructure (CLI) 867, 917, 919, 921 inverse hyperbolic functions 514 floating-point deficiencies 918 inverse trigonometric functions 504 virtual machine 80 logarithm 495 Common Language Runtime (CLR) 917, 918 logarithm near one 497 Common Lisp — The Language 476 multiplication 456 Common Lisp language 130, 341 error analysis 458 Common Random Numbers 158 NaN test 462 Communications of the ACM (CACM) 826 negation 459 Compaq (vendor) 71, 79, 812 power 500 compiler projection 460 64-bit integer support 173, 210, 260, 262 real part 460 Ada floating-point support 911 Riemann sphere 460 argument-passing conventions 941, 942, 945 square root 480 assembly-code support 241, 292, 338, 352, 391, 392, 824, 994 subtraction 461 binary floating-point constant support 4, 409, 977 trigonometric functions 502 C/C++ compatibility 923 complex data type 441, 442, 994 class overhead in C++ 925 complex double data type 504, 509, 514, 517 comparison of floating-point values 934 complex elementary functions 475 complex-arithmetic caveats 441–443, 459, 463, 520 complex number decimal-arithmetic support ix, 4, 101, 355, 826, 845, 928, 930, Cartesian form 443 936 polar form 443 float-to-double automatic conversions 877 system header file 441 floating-point deficiencies on MAC OS X 433, 818, 851 system header file 441, 442 fused multiply-add support 87, 89, 362, 370, 392, 399, 401 complexcw.h header file 442 IEEE 754 poorly supported 106 compound interest 294 inline expansion 463, 914 error magnification 294 integer division replaced by bit operations 176 Computational Aspects of Three-Term Recurrence Relations 693 integer-overflow caveats 73 computational precision 65 interface between C and Fortran 941 Computer Approximations 827 interval-arithmetic support 967 computer architecture see CPU just-in-time 982 Computer Architecture: Concepts and Evolution 104, 947, 978 mishandling of NaN in comparisons 80, 104, 137 Computer Arithmetic II 966 mishandling of negative zero 69, 69, 104, 135, 478, 520, 885 computer model see model need for volatile 66, 66, 121, 135, 358, 365, 471, 746, 761 Computer Physics Communications 214, 693 1074 Subject index . . . C computer vendor see vendor decimal to binary 927 Conference on Computer Arithmetic 104 elliptic roots to modulus 685 congruential generator floating-point ceiling and floor 136 computing 171 floating-point decimal to binary 826 correlations between output values 170 floating-point division to quotient and remainder 150 deficiencies 170 floating-point to based-number string 865 good parameters are hard to find 170 floating-point to binary string 851 recovery of parameters from output stream 207 floating-point to decimal string 851 Connolly, John William Domville 956 floating-point to exact string 831 const char * data type 990 floating-point to floating-point 293 const keyword 3, 94, 356, 365, 992 floating-point to floating-point with current rounding 138 const.h header file 365 floating-point to floating-point with fixed rounding 137 constant, signed-zero 69 floating-point to floating-point without raising exception 139 continued fraction 12 floating-point to hexadecimal string 832 backward evaluation 12, 803 floating-point to integer 80, 129, 129, 918, 949, 952, 953 Bessel-function convergence failure 712, 738 programming issues 130 Bessel-function ratios 701, 710, 712, 729, 738, 761 rounding 132 closest rational approximation 251 floating-point to integer and fractional parts 132 complementary error function erfc(x) 594, 768, 769 floating-point to integer with current rounding 142 e (base of natural logarithms) 268 floating-point to integer with fixed rounding 140 error function erf(x) 594, 768, 769 floating-point to octal string 850 forward evaluation 12, 803 floating-point to remainder in nonbinary base 155 gamma function Γ(x) 524 floating-point to remainder of division 143, 146, 148 history 59 floating-point to string 829 incomplete gamma function 563 floating-point truncation 135 inverse tangent function atan(x) 802 from complex Cartesian to polar 70, 479 Lentz algorithm 710, 712, 729, 753, 754 general numeric string to floating-point 900 modified 18 hardware out-of-range 131 relation to orthogonal polynomial 59 hexadecimal string to floating-point 895 scaled complementary error function erfcs(x) 599 Infinity 866 simple 13 integer to floating-point 161, 949, 952, 953 special functions 827 NaN 866 Steed algorithm 17, 710, 712 number to exact round-trip string 867 tangent function tan(x) 17 numbers to continued fractions 14 Control Data Corporation see CDC octal string to floating-point 894 Control Data Corporation (vendor) 949 overflow in string-to-numeric conversion 974 conventions pair-precision constants 777 argument passing in Fortran 941 Pascal string to C string 991 argument passing in Pascal 991 plot to PostScript 36 filename 3 printf() 867 naming 4 problem with double rounding 265 programming 2 real to complex 442 convergence scanf() 901 acceleration 582, 589 string to floating-point 879 cubic 10, 622 conversion specifier quadratic 8 binary floating-point 907 quartic 23, 215, 622 decimal floating-point 907 quintic 622 integer 907 convergent of infinite continued fraction 12 converting floating-point values to integers 129 conversion Convex (vendor) 952 accuracy of floating-point to string 865 convolution 966 argument types 947 Cooley, James William (1926–2010) 969 avoidance of integer to floating-point 761 Corbett, Robert Paul 250 based-number string to floating-point 899 Coriolanus 411 between hexadecimal and decimal 772 correct rounding between remainders 152 cube root (almost) 239 binary string to floating-point 879 reciprocal square root (almost) 235 binary string to higher base 977 square root 217 binary to decimal 927 cosdbl.h header file 700 Chebyshev polynomial to rational form 52,55 cosecant 299, 300 Chebyshev polynomial variable 318 coshx.h header file 348 compiler inaccuracy for floating-point string 162, 474, 525 cosine 299 complex to complex-as-real 448 argument in degrees 313, 314 cost of floating-point binary–decimal 164 argument in units of fl(2π) 304 decimal quantization to integer 932 argument in units of π 315, 316 decimal string to floating-point 895 argument reduction 304, 306, 308 Subject index . . . C 1075

computing 306 Itanium-1 824, 970 computing with sine 320, 339 Itanium-2 814, 815, 824, 970 definition 299 K5 293 derivative 301 KA10 305, 948, 955 error magnification 310 KI10 948, 955 identities for testing 301, 339 KL10 305, 948, 954, 955 in hardware 338 KLH10 ix, 216, 948, 954, 1115 inverse 323 KS10 948, 955 1 π of 2 304 MC68040 131 of angle sum 300 MIPS 68, 71, 153, 240, 392, 439, 867, 976 properties 299 Opteron 339 range of 299 PA-RISC 68, 71, 86, 101, 131, 216, 218, 219, 240, 370, 383, 388, Taylor series 302 392, 816, 970 Taylor series of inverse 323 PDP-1 970 cospix.h header file 318 PDP-10 v, viii, ix, 71, 72, 77, 107, 131, 147, 216, 251, 256, 257, 262, cosx.h header file 308 305, 478, 608, 761, 763, 848, 849, 855, 908, 928, 947, 948, 951, cotangent 299 953–956, 958, 965, 966, 969–971, 977, 978, 1115 argument in units of π 320 PDP-11 viii, ix, 66, 224, 478, 761, 850, 908, 928, 948, 953, 956, computing 310 957, 970, 971, 977 identities for testing 340 PDP-12 948 notations for 302 PDP-15 970 cotanx.h header file 313 PDP-2 970 Coulomb wave function 693 PDP-3 970 coversine function 301 PDP-4 970 Coveyou, Robert R. 214 PDP-5 970 Cowlishaw, Michael F. ix PDP-6 948, 954, 970 CP/M operating system 954 PDP-7 850, 956 cpolyfma.map file 488 PDP-8 970, 971 cpp file 923 PDP-9 970 cppcheck program 870 Pentium 339 CPU see also model POWER 65, 86, 87, 109, 218, 219, 370, 391, 410, 816, 825, 970, 801 86 976, 1035 4004 283, 970 PowerPC vii, 68, 71, 79, 87, 109, 131, 216, 219, 233, 240, 355, 370, 6502 971 388, 392, 399, 438, 439, 459, 818, 878, 927, 936, 970, 976, 1035 8008 970 R10000 131, 220, 392, 817 8080 954, 971 R2000 86 8086 970, 971 R3000 86 8087 vii, 63, 105, 825, 928 R4400SC 131, 817 32016 970 R5000 392 68000 65, 68, 124, 145, 146, 150, 217, 240, 292–294, 338, 352, 362, ROMP 86 363, 395, 401, 823, 970 S-1 305, 463, 948, 965, 966 68020 976 SPARC 68, 71, 86, 99, 109, 122, 129, 131, 216, 218, 240, 242, 383, 68040 71, 216 388, 392, 399, 439, 459, 697, 811, 818–821, 824, 867, 953, 956, 80186 971 967, 970, 976, 990 80286 971 VAX viii, ix, xxix, 71, 131, 146, 251, 271, 305, 365, 473, 478, 708, 80386 976 761, 774, 855, 928, 947, 948, 951, 954, 956–958, 970, 974, 1115 88000 970 VAX-11 956 88100 86 x86 xxxv Alpha xxxv, 68, 71, 79, 86, 105, 107, 108, 121, 123, 131, 147, 153, Xeon 339 216, 240, 439, 459, 812, 953, 956, 970, 976, 990 z-Series 241, 438 AMD64 ix, 65, 68, 69, 71, 108, 121, 123, 124, 131, 177, 216, 217, z10 927, 936 220, 235, 239, 240, 242, 352, 362, 363, 382, 388, 439, 459, 681, Z80 971 696, 765, 813, 824, 825, 911, 928, 967, 1115 z9 927, 936 EM64T ix, 65, 71, 124, 217, 362, 825, 928 CPU register 13 G5 86, 217, 219, 370, 388 crack1.c file 206 i860 86 crack2.c file 206 IA-32 ix, xxv, xxxv, 63, 65, 68, 71, 80, 92, 100, 108, 109, 121, Cray (vendor) 68, 85, 256, 257, 305, 365, 948, 949, 951–953, 955, 957, 124–127, 131, 146, 148, 150, 216–218, 234, 237, 240, 242, 964, 965, 969–971, 977 292–294, 338, 339, 350, 352, 362, 363, 365, 388, 400, 401, 439, Cray 1 Computer System Hardware Reference Manual 952 459, 697, 716, 814, 818–820, 822–825, 867, 911, 917, 928, 967, Cray Research Inc. (vendor) 949 970, 1021, 1115 Cray, Seymour (1925–1996) 949 IA-64 viii, ix, xxxv, 58, 65, 68, 71, 86, 87, 100, 101, 108, 121, 123, cryptanalysis 204 124, 131, 145, 146, 176, 200, 216–219, 230, 233–235, 237, 238, cryptographic generator 178 240–242, 355, 362, 363, 365, 370, 382, 383, 388, 391, 392, 395, cryptographic quantum generator 178 399, 401, 412, 459, 765, 811, 814, 815, 819, 823, 824, 911, 928, 953 cryptography iAPX 432 970 attacks on one-time pad 207 1076 Subject index . . . D

caveats 208 Danielson, Gordon C. (1913–1983) 969 choosing keys and encryption methods 207 DASK (model) 970 communicating encrypted keys 205 Data General (vendor) 948, 963, 970 demonstration of one-time pad 204 data type see also typedef hardware accelerators 207 _Imaginary 441, 463 problems 203 _ _float128 101, 877 cryptanalysis of ciphertext patterns 204 _ _float128_pair 355 distribution of secret keys 203 _ _float80 101, 877 public-key ownership 204 _ _float80_pair 355 provably secure encryption 204 _ _fpreg 101 public and private key pairs 207 acc_t 897 public key 203 bool 453 security of public-key methods 203 BYTE 941 slow public-key methods 207 ByteInt 990 symmetric key 207 char 257, 877, 906–908 Cryptography Engineering 214 char * 990 Cryptologia 214 CHARACTER 941, 942, 945 cscc program 919 complex 441, 442, 994 csharp file 918 complex double 504, 509, 514, 517 CString data type 990 const char * 990 cube root 237 CString 990 almost correct rounding 239 cx_decimal_double 442 improved rounding 237 cx_decimal_float 442 cubic convergence 10 cx_decimal_long_double 442 cumulative distribution function 189, 593, 610, 610, 988 cx_decimal_long_long_double 442 cvtdir.h header file 849 cx_double 442 cvticw.h header file 879 cx_float 442 cvtid.h header file 898 cx_float128 442 cvtocw.h header file 840, 854 cx_float80 442 cvtodx.h header file 864 cx_long_double 442 cvtoh.h header file 840, 844 cx_long_long_double 442 cvtohx.h header file 834, 850 decContext 403 cvtoox.h header file 850 decimal 102, 103 cvtsfx.h header file 890, 892 decimal128 403 cx_decimal_double data type 442 decimal_double 102, 758, 877, 936, 937 cx_decimal_float data type 442 decimal_double * 907 cx_decimal_long_double data type 442 decimal_double_pair 355 cx_decimal_long_long_double data type 442 decimal_float 102, 211, 875, 877, 878, 936 cx_double data type 442 decimal_float * 907 cx_float data type 442 decimal_float_pair 355 cx_float128 data type 442 decimal_long_double 102, 164, 865, 877, 936 cx_float80 data type 442 decimal_long_double * 907 cx_long_double data type 442 decimal_long_double_pair 355 cx_long_long_double data type 442 decimal_long_long_double 102, 877 cxcw.h header file 442, 507 decimal_long_long_double * 907 cxl1px.h header file 497, 500 decimal_long_long_double_pair 355 Cyber (model) 949 decNumber 403 Cydrome (vendor) 952 DOUBLE 962 cylindrical Bessel function see Bessel function Double 990 Cymbeline 215 double xxxv, xxxvi, 4, 5, 47, 58, 73, 91, 92, 102, 129, 130, 155, 163, 174, 210, 254, 256, 263, 265, 292, 293, 308, 310, 340, 355, 356, D 388, 391, 395, 396, 399, 401, 402, 418, 420, 454, 459, 475, 527, D language vii, 830 545, 555, 557, 558, 567, 572, 578, 586, 597, 614, 681, 709, 725, D-floating 948, 956 738, 764, 770, 771, 811, 815, 817, 820, 821, 824, 827, 829, 833, D21 (model) 970 834, 842, 851, 854, 855, 857, 865, 867, 877, 890, 896, 908, 911, danger 918, 921, 923, 941, 948, 956, 962, 966, 981, 983, 990 absolute value of most negative integer 73, 74, 973 double * 907 array indexing 982 double complex 441 comparison of floating-point values 934 DOUBLE PRECISION 129, 941, 949, 962 conflict between input and output format specifiers 905 double_pair xxxi, 355, 383, 384 formatted input routines 904 exact_t 382 formatted output routines 868 Extended 990 improperly initialized input strings 909 extended 58, 100, 101, 877 pointers 982 extended_pair 355 scanset ranges in input format specifiers 905 fenv_t 108, 116, 117, 120, 123 unsafe modifier in C# 921 fexcept_t 108, 116, 123 Subject index . . . D 1077

Float 911 opaque 108, 116, 120, 982 float xxxvi, 4, 5, 57, 58, 82, 92, 102, 129, 163, 210, 213, 237, 254, packed-decimal 928 265, 292, 293, 310, 355, 388, 391, 395, 396, 399, 420, 454, 459, Packed_Decimal 928 475, 527, 534, 557, 558, 572, 586, 597, 657, 724, 738, 764, 770, ptrdiff_t 877, 907, 908 771, 811, 815, 818, 824, 829, 834, 865, 875, 877–879, 890, 896, ptrdiff_t * 907 908, 911, 918, 921, 941, 962, 981, 983, 990 qp_t 255–257, 263–265 float _Complex 441 quad 58, 101, 877 float complex 441 quad_pair 355 float_pair xxxi, 355, 381, 382, 384 rancw_state_t 212 fp_c_t 442, 443 randcw_state_t 211 fp_cx_t 442, 443, 692 REAL 941, 948, 949, 962 fp_pair_t 355 Real 990 fp_t 3, 5, 85, 101, 135, 247, 250, 251, 265, 310, 313, 355, 356, 382, REAL (SELECTED_REAL_KIND(75)) 4 429, 430, 667, 741 REAL*16 941 fpu_control_t 125 REAL*32 4, 64 gmp_rounding_mode 402 REAL*4 941 hp_t 85, 310, 429, 430, 688, 741 REAL*8 941 int 73, 74, 90, 91, 94, 125, 131, 162, 163, 206, 209, 254, 257, 356, short int 74, 116, 131, 829, 877, 907, 941, 990 421, 422, 667, 868, 877, 896, 941, 990 short int * 907 int * 874 ShortInt 990 int_t 74 ShortReal 990 INTEGER 129, 941, 962 signed char 257, 941, 990 Integer 911, 990 signed char * 874, 907 INTEGER*1 941 SINGLE 962 INTEGER*2 941 Single 990 INTEGER*4 941 sink_t 871, 902 INTEGER*8 173, 941 size_t 257, 846, 872, 877, 907, 908 interval_t 115 size_t * 907 intmax_t 877, 896, 907 source_t 902, 904 intmax_t * 907 split_t 396 jdouble 983 String 981, 983 jfloat 983 UINT_LEAST32_T 209, 211, 260–262 JNICALL 983, 984 uint_least32_t 209 JNIEnv 983, 984 UINT_LEAST64_T 209–211, 260 JNIEnv * 982 uint_least64_t 209, 260 JNIEXPORT 983, 984 uintmax_t 877, 896, 907 jobject 982 uintmax_t * 907 LOGICAL 941, 961 unsigned char 257, 873, 908 long 173 unsigned char * 874 long double xxxv, xxxvi, 4, 5, 57, 58, 92, 100–102, 124, 129, 155, unsigned int 152, 892 164, 210, 213, 218, 237, 238, 293, 310, 347, 352, 355, 388, 391, unsigned long int 896 399, 412, 454, 764, 770, 815–818, 820, 821, 823, 829, 854, 856, unsigned long int * 907 865, 867, 877, 879, 890, 896, 907, 908, 911, 921, 941, 990 unsigned long long int 173, 896 long double * 907 unsigned long long int * 907 long double complex 441 unsigned short int * 907 long int 74, 129, 131, 140, 161, 162, 209, 254, 257, 260, 877, 892, unsigned wchar_t 873 896, 907, 908, 979, 990 void 109, 125, 148, 355, 356, 442, 906 long int * 907 void * 874 long long double 4, 5, 58, 64, 890 wchar_t 877, 901, 906, 907 long long int 74, 129, 131, 260, 453, 877, 892, 896, 907, 941, wchar_t * 874, 907 979, 990 wint_t 877, 907 long long int * 907 wint_t * 907 long_double_pair 355 xp_t 854, 856, 857 Long_Float 911 Datasaab (vendor) 970 Long_Integer 911 Daumas, Marc 366 long_long_double 102, 877 de Laplace, Pierre Simon (1749–1827) 194, 195 long_long_double * 907 de Moivre, Abraham (1667–1754) 194 long_long_double_pair 355 DEC (vendor) v, viii, ix, 66, 71, 86, 107, 146, 153, 216, 224, 250, 251, Long_Long_Float 911 256, 305, 365, 478, 608, 761, 763, 774, 812, 850, 855, 928, 947, Long_Long_Integer 911 948, 951–954, 956, 965, 969, 970, 974, 976–978, 1115 LongInt 990 decContext data type 403 LongReal 990 deccw.h header file 102 MedInt 990 system header file xxxiii, 103, 252, 936, 937 mp_t 250, 251 decimal arithmetic 97–99, 927 mpfr_t 402 algorithm design 763 number 907 argument purification problem 99 1078 Subject index . . . D

BID encoding 929 definition 61 BID storage layout 930 elliptic integral function 628, 629 Binary Integer Decimal (BID) format 928 error functions 595, 603 compliance testing 827 error-magnification factor 61, 603 conversion specifier 873, 874, 907 exponential function 267 data types 102 gamma function 591 Densely Packed Decimal (DPD) format 928 Halley’s method 9, 230 design issues 928 inverse error functions 603, 607 DPD encoding 929 Jacobian Eta function 687, 692 DPD storage layout 930 Jacobian theta functions 675, 676 elementary functions 4 logarithm of gamma function 536 exact scaling 937 modified Bessel functions 721 exactly representable constants 597 Newton–Raphson iteration 8, 607 header file 936, 937 numerical approximation 8 language extensions 101 ordinary Bessel functions 700 macros for rounding 109 partial 680 mathematical libraries 826 psi function 539 need for 927 quadratic equation 9 normalization 934 relation to quadrature error 560 precisions 97, 99 sine function 301 quantization 931–933 tangent function 303 remainder computation 144, 145 Taylor series 8 rounding 936 Weierstrass ℘()function 684, 685, 688 rounding mode extensions 109 Weierstrass sigma function 686 standardization vii Weierstrass zeta function 686, 689 storage initialization 935 Derivatives option (Mathematica) 34 type suffix deroff program 1115 constant 102 descriptor 942 library function 102 detecting sign of zero 69 variable precision 216 Determination of Correct Floating-Point Model Parameters 958 decimal data type 102, 103 detex program 1115 decimal number deviation see standard deviation input conversion 895 Devore, Jay Lewis 610 output conversion 851 dgcc program 681, 938 decimal128 data type 403 Dictionnaire historique de la Suisse 568 decimal_double * data type 907 DIDBR instruction 146 decimal_double data type 102, 758, 877, 936, 937 DIEBR instruction 146 decimal_double_pair data type 355 Diehard Battery package 200, 202 decimal_float * data type 907 diffraction grating 801 decimal_float data type 102, 211, 875, 877, 878, 936 digamma (obsolete Greek letter) 521 decimal_float_pair data type 355 digamma function 537 decimal_long_double * data type 907 DIGIAC 3800 (model) 970 decimal_long_double data type 102, 164, 865, 877, 936 Digital Computer User’s Handbook 947, 978 decimal_long_double_pair data type 355 digital cryptographic signature 204 decimal_long_long_double * data type 907 Digital Electronics (vendor) 970 decimal_long_long_double data type 102, 877 Digital Equipment Corporation see DEC decimal_long_long_double_pair data type 355 Digital Equipment Corporation (vendor) 954 decNumber data type 403 Digits global variable 28, 29, 245, 247, 252, 408, 546, 604, 606, 626, decNumber package 218, 387, 402, 403, 433, 867, 897, 928, 930–932, 638, 724 936 Digits option (Mathematica) 39 decryption 203 Dijkstra, Edsger Wybe (1930–2002) 763, 947, 962 DECstation (model) 976, 977 DIMENSION statement 962 default statement 41, 419, 894 Dirac, Paul Adrien Maurice (1902–1984) 475 deficiencies of congruential generator 170 directive Dekker, Theodorus Jozef 353, 356, 360, 361, 365–371, 373, 375–377, ## 3 379–381, 387, 407 #define 3, 116, 130, 131, 218, 219, 235, 237, 238 Demmel, James Weldon 385 #elif 3 Denelcor (vendor) 963 #error 3 denial-of-service attack 207 #if 130 denormalized number 78, see subnormal #include 101, 111, 113, 114, 130, 131 Densely Packed Decimal (DPD) 928, 929, 930 #pragma 110, 113, 114 derivative #undef 924 complete elliptic integral functions 628 Dirichlet, Johann Peter Gustav Lejeune (1805–1859) 587 cosine function 301 dirty zero 963 cotangent function 548, 557 discriminant 466 cubic methods 10 distill program 1115 Subject index . . . E 1079 distribution ECMAScript language vii binomial 195 École Nationale Supérieure 825 exponential 189, 190 edigs.c file 268 F 195 EDSAC (model) 353, 970 function 189 EDVAC (model) 970 gamma 195 egcdx.h file 188 hypergeometric 195 egrep program 880, 1115 Laplace 195 Egypt 299, 465 logarithmic 190 Eiffel language 830 normal 192, 194 Einstein, Albert (1879–1955) 303, 475 Poisson 195 EISPACK package 227, 228, 232 power-law 196 EL X1 (model) 970 random number 189 EL X8 (model) 970 Student’s t 195 El-tronics (vendor) 970 uniform 189 Electrologica (vendor) 970 univariate 196 electrostatic potential 627 Weibull 196 ELEFUNT package 61, 96, 98–100, 216, 338–340, 342, 412, 430, 436, divbyzero exception flag 70, 71, 123, 336, 496, 518, 792 438, 439, 763–765, 769, 770, 773, 774, 776, 811–822, 940 divide-and-conquer algorithm 425 eljagx.h header file 662 division eljcnx.h header file 664 by zero 70, 105 eljdax.h header file 676 safe integer 75 eljdnx.h header file 664 DLL hell 920 eljscx.h header file 663 DLMF Project 826 ellfun.c file 655 Dolphin (model) 954 Elliott (vendor) 970 Domain (model) 948 ellipse perimeter 619, 630 DotGNU Project viii, 917 elliptic integral functions 619 double * data type 907 elliptic package 659 double complex data type 441 ellrcx.h header file 649 DOUBLE data type 962 else statement 135, 148, 240, 275, 276, 338, 373, 378, 384, 397, 398, Double data type 990 785, 842 double data type xxxv, xxxvi, 4, 5, 47, 58, 73, 91, 92, 102, 129, 130, elwkx.h header file 685 155, 163, 174, 210, 254, 256, 263, 265, 292, 293, 308, 310, 340, ELXSI (vendor) 952, 970, 977 355, 356, 388, 391, 395, 396, 399, 401, 402, 418, 420, 454, 459, EM64T (CPU) ix, 65, 71, 124, 217, 362, 825, 928 475, 527, 545, 555, 557, 558, 567, 572, 578, 586, 597, 614, 681, precision control on 124 709, 725, 738, 764, 770, 771, 811, 815, 817, 820, 821, 824, 827, emacs program 2, 954, 1115 829, 833, 834, 842, 851, 854, 855, 857, 865, 867, 877, 890, 896, EMOD instruction 146 908, 911, 918, 921, 923, 941, 948, 956, 962, 966, 981, 983, 990 Emulab Network Emulation Testbed ix double factorial 523 encoding double make target xxxv PDP-10 fraction 954 DOUBLE PRECISION data type 129, 941, 949, 962 PDP-10 numbers 954 double rounding 265, 339, 359, 363, 396, 400, 908 CDC 6000 exponent 950 double_pair data type xxxi, 355, 383, 384 CDC 6000 signed zero 950 doubled-double arithmetic 353, see pair-precision arithmetic BID 928, 930 doubleword 969 Chen–Ho 928 DPD see Densely Packed Decimal DPD 928, 930 DRAGONFLYBSD operating system x floating-point exponent 974 DRAGORA operating system 825 function argument types 982 DSI (vendor) 970 IEEE 754 binary 63 duplication rule for elliptic auxiliary functions 648, 649, 690 IEEE 754-2008 decimal BID 929 dv2dt program 1115 IEEE 754-2008 decimal DPD 929 dvips program 1115 signed integers 971 dw program 1115 Encore (vendor) 952 encryption 203 E Enenkel, Robert Frederick 353 E2n (Euler number) 572, 572, 573, 574, 577, 587 English Electric (vendor) 948, 970 E global variable 850, 851 English Electric LEO-Marconi (vendor) 970 e history 59 environment e10m1x.h header file 279 access pragma 110 e: The Story of a Number 269 getting 117 Earth (planet) 630 setting 117 EBCDIC character set 905 updating 119 eccentricity 630 environment variable Eclipse (model) 970 CLASSPATH 980 Eclipse S/200 (model) 948 INITIALSEED 764 ECMA-334 C# Specification vii LD_LIBRARY_PATH 919, 946 1080 Subject index . . . E

MAXTEST 764, 812, 813 Euler Archive 591 EPIC (Explicitly Parallel Instruction Computer) 824 Euler formula 443 EPIC mathematical functions 824 Euler identity (eiπ + 1 = 0) 59, 444 epigraph vii, xxxv, 1, 7, 12, 23, 61, 105, 129, 157, 214, 215, 243, 267, Euler numbers 568, 572 299, 341, 353, 359, 411, 441, 465, 471, 472, 475, 521, 547, 593, Euler, Leonhard (1707–1783) 12, 267, 267, 268, 269, 282, 521, 524, 619, 657, 693, 763, 777, 811, 823, 829, 879, 911, 917, 923, 927, 541, 572, 589, 591, 619, 693, 702, 703, 722, 801 939, 941, 947, 949, 952, 953, 956, 958, 959, 969, 971, 979, 987, biography 59, 591 989, 995 Euler–Maclaurin summation formula 570 equity 296 Euler–Mascheroni constant 524, 541, 591, 702, 703, 722, 988 EQUIVALENCE statement 962 eulnum.c file 573 erf-cf.hoc file 594 eulnumf.c file 573 erfc-cf.hoc file 594 eulnx.h header file 573 erfcinv( ) function see also ierfc( ) function evaluation erfcs() 598 addition-rule 98 erfcsx.h header file 598 order in C 64 erfcx.h header file 598 Taylor series 97, 768 erfinv( ) function see also ierf( ) function even series 25 erid.h header file 255, 258 exact quadrature conditions 560 errata in Cody/Waite book 939 exact round-trip conversion 840, 844, 851 errno global variable 70, 71, 91, 93–96, 130, 132, 136, 137, 139–143, exact summation 385 148, 150, 152, 155, 563, 690, 700, 719, 730, 758, 763, 785, 791, exact_t data type 382 792, 803, 885, 897, 908 exception 106 thread safety 95 exception flag values 91 access 107, 116 system header file 3, 91, 93, 94 divbyzero 70, 71, 123, 336, 496, 518, 792 error function 593, 593 getting 118 complementary 593 holding 119 computing 595 inexact 79, 79, 106, 111, 112, 114, 123, 133, 135–137, 139, 140, 142, inverse 600 143, 275, 324, 325, 332, 338, 344, 345, 585, 598, 782, 803, 804 inverse complementary 600 invalid 70, 71, 80, 80, 94, 114, 123, 135–137, 139–143, 336, 482, properties 593 486, 490, 496, 507, 513, 514, 518, 791 scaled complementary 598 no access in Ada 914 error magnification 61, 62, 340, 438, 439, 596, 603, 604, 795 overflow 71, 71, 111, 114, 124, 415, 778, 887 annuity function 295 setting 118 In(x) and Kn(x) 721 subnormal 108, 123, 124 Isn(x) and Ksn(x) 721 testing 112 Jn(x) and Yn(x) 700 underflow 78, 79, 106, 111, 114, 123, 124, 338, 415, 598, 778, 785 complete elliptic integral functions 625, 628, 629 using 112, 120 complex exponential function 500 excess-n integer 974 compound interest function 294 exclusive-OR 159, 176–178, 206 cosine function cos(x) 310 exered.c file 265 elementary and special functions 61, 62 exerid.c file 265 error functions 595, 596, 616 exp file 123, 206, 233, 459, 572, 573 exponential function exp(x) 268, 343, 528, 557, 558, 578, 672, exp.h header file 272 746, 787 Explication de l’Arithmétique Binaire 969 inverse cosine function acos(x) 324, 804 expm1x.h header file 274, 276 inverse error functions 603, 604, 616 exponent inverse sine function asin(x) 324, 804 bias removal in hardware 950 logarithm function log(x) 283, 531 boundaries and ulp measures 81 power function 412, 528, 940 CDC 6000 950 psi function 539 dirty zero 963 Riemann zeta function ζ(x) 584 encoding in decimal BID 929 roots of quadratic equations 471, 474 encoding in decimal DPD 930, 931 sine function sin(x) 309, 531 encoding in storage 947 spherical Bessel functions in(x), jn(x), kn(x), and yn(x) 732 extended range 79, 82, 101, 124, 145, 241, 556, 572, 582, 655, 824, square root 517 826, 951, 953, 955, 956 tangent function tan(x) 310, 545 extraction in Java 982 ESA/390 (model) x, 1115 extraction with frexp() 148, 155, 257, 279, 284, 769, 837, 857, ETA (vendor) 949, 952 914, 922, 937, 944, 981, 992 Eta function (Jacobian) 679 extraction with intxp() 284 Euclid of Alexandria (ca. 300 BCE) 180, 222 extraction with logb() 284 Euclid test of random-number generator 200 flag bit 959, 960 Euclid’s algorithm for extended gcd 186 IEEE 754 subnormal 78 Euclid’s algorithm for gcd 180, 183, 184 inadequate range in C# decimal type 102 Euclidean distance 222, 444 Indefinite 950, 951 Euclidean norm 113, 222, 223 Infinitesimal 960 Subject index . . . F 1081

Infinity 950, 953, 960, 963 facos instruction 338 limit symbols 251, 831 factorial limited range in older systems 253, 555, 586, 899, 947, 955, 956, definition 8 961, 964 double 523 linking absent in pair-precision arithmetic 354, 365, 407, 779 quadruple 523 maximum power in polynomial 40 triple 523 minimum output width 840 fasin instruction 338 need for larger range 407, 730, 752 Fast Fourier Transform 966, 969 nonzero for floating-point zero 951 fatan instruction 338 order-of-magnitude-zero (OMZ) 960 fatanh instruction 352 phantom in second word 947 fcos instruction 338 power operator 420 fcosh instruction 352 range fdlibm package 133, 153, 274, 325, 349, 352, 595, 597, 598, 811, 821, 68000 extended 124 824, 825, 940 IA-64 extended 100, 101, 124, 241, 824 fdtoi instruction 129 IEEE 754 binary arithmetic 65 fdtox instruction 129 IEEE 754-2008 decimal arithmetic 929 features package 69 limits in continued-fraction evaluation 13 fecmplx.c file 123 mandated by COBOL 928 fecmplx2.c file 123 multiple-precision arithmetic 407 fecmplx3.c file 123 not extended in pair-precision arithmetic 354, 781 system header file 107–109, 113, 116, 120 RS/6000 817 fenv_t data type 108, 116, 117, 120, 123 reduced in second word 949, 955 fenvcw.c file 107 reduction in integer-power computation 502 fenvcw.h header file 108–110, 112, 116, 120, 121, 127 register 958 fenvx.h header file 107, 110, 116, 126 relation to maximum exactly representable number 133 Fermat’s Last Theorem 60 scaling with ldexp() 148, 155, 257, 272, 279, 413, 418, 423, 439, Fermat, Pierre de (ca. 1601/1607–1665) 222 769, 795, 846, 885, 890, 896, 899 Ferranti (vendor) 970 scaling with scalbn() 284 Ferranti–Packard (vendor) 970 scaling with setxp() 284, 423, 439 fetox instruction 294 smallest normal number 83 fetoxm1 instruction 294 tapered arithmetic 966 fexcept_t data type 108, 116, 123 testing extraction 769 FFT see Fast Fourier Transform undetected overflow 889, 896 fibnx.h header file 578 unsymmetric range on Cray 953 Fibonacci biography 59 unusual storage encoding 947, 956 Fibonacci generator 176 widest range 670 Fibonacci numbers 15, 472, 575, 577 wrapped on overflow or underflow 77, 955 closed form 578 zero with nonzero fraction 957 discriminant relation 473 exponential 267, 267 generalization 473 AGM algorithm 624 history 59 argument reduction 271, 272, 274, 275, 277, 279, 281 in Euclid’s algorithm 182 distribution 189, 190 recurrence relation 15, 473, 576 error magnification 268 symmetry relation 576 in hardware 292 Fibonacci’s Liber Abaci: A Translation into Modern English of Leonardo ( ) minus one, expm1 x 273 Pisano’s Book of Calculation 575 Taylor series 267, 277 file see also header file, see also system header file export statement 991 *.dat.maple 771 expx.h header file 272 *.log 771 extbook package 1115 *.map 29 Extended data type 990 ../maple 771 extended data type 58, 100, 101, 877 .adb 911 extended Euclid’s algorithm for gcd 186 .ads 911 extended_pair data type 355 .dll 920 extending the library 57 .dylib 920 extern keyword 984 .exe 919 external statement 991 .so 920 extracting integral and fractional parts 132 /depot/lib/libmcw.a xxxv Eyring, Henry (1901–1981) ix /dev/random 207 /dev/urandom 207 F /usr/local xxxv F distribution 195 ada 911 F-floating 956 bernum.c 572 f2c program 763 bernum2*.c 575 f2xm1 instruction 293, 294 bernum3*.c 575 f77 program 941, 942 bernumf.c 572 1082 Subject index . . . F

beta*.map 590 nanf.c 944 bm-fma.c 404, 405 nearpi.c 251 chebfit.mth 56 nearpi.dat 251 chkasm.c 770 numtest.pas 994 chkasm.map 770 okay 919, 924, 990 chkatan2.c 338 pascal 989 chkatan2d.c 338 perf.adb 916 chkell.c 681 perf.java 982 cpolyfma.map 488 pgamma.hoc 556 cpp 923 polyfit.mth 38, 42 crack1.c 206 polyfma.map 488 crack2.c 206 pxy*.c 430 csharp 918 pythagn.c 233 edigs.c 268 rndcb1.c 238–240 egcdx.h 188 rndcb2.c 240 ellfun.c 655 rndoff.c 161 erf-cf.hoc 594 rndrs1.c 235, 237 erfc-cf.hoc 594 rndrs2.c 237 eulnum.c 573 rndsq1.c 216, 220 eulnumf.c 573 rndsq3.c 217, 220 exered.c 265 rndsq4.c 217, 220 exerid.c 265 rndsq5.c 217, 220 exp 123, 206, 233, 459, 572, 573 rndsq6.c 217, 220 fecmplx.c 123 sbj1taylor.map 740 fecmplx2.c 123 sby1taylor.map 740 fecmplx3.c 123 split-base.map 708 fenvcw.c 107 split.map 408 filnam.ext 3 sqrt.c 3, 4 fitrndx.map 43 sqrtf.c 3, 4 fixed-nearpi.c 251 sqrtl.c 3, 4 frexpf.c 944 tatanh.c 99 ftocs.c 945 tcmul2.c 459 gamierf*.c 566 tcmul3.c 459 gamiexp*.c 567 terf.c 768, 769 genmap-* 771 terfc.c 768, 769 glquad.c 560 test*.cs 919 glquad.map 560 test*.pas 989 ipowx.h 420 test-* 765, 769 irnint.c 167 test.adb 912, 915 ixsq*.c 567 test.ali 912 J0taylor.map 718 test00.pas 991 java 979 test01.cc 925 jmmred.map 251 test01.pas 991 libMathCW.dylib 982 test02.cc 925 libMathCW.so 980, 982 test02.pas 991 libmcw.a 4, 771 test03.cc 925 libmcw.dylib 920 test03.pas 991 libmcw.so 4, 920 test05.pas 993 Makefile 3, 4, 442, 764, 765, 771, 911, 912, 919, 923, 925, 943, tfrexp.c 769 946, 979, 989 tgcd.c 184 maple 28, 29, 55, 408, 488, 772 timred*.c 265 mathcw.ads 911, 912, 914, 915 tldexp.c 769 mathcw.bib xii tlgamm.c 766 MathCW.c 982–984 tpsi.c 768 MathCW.class 980 tpsiln.c 768 mathcw.cs 919–922 tqert.c 473 MathCW.dll 982 tstkis.c 177 mathcw.gpi 993 ttgamm.c 766 MathCW.java 980 filename conventions 3 mathcw.map 772 Filling option (Mathematica) 37 MathCW.o 980 FillingStyle option (Mathematica) 37 mathcw.o 993 filnam.ext file 3 mathcw.pas 989, 991–993 final keyword 981 msbis0.c 771 first-order Taylor-series approximation 8 myprog.exe 920 Fisher, Sir Ronald Alymer (1890–1962) 196 myprog.exe.config 920 fitrndx.map file 43 Subject index . . . F 1083 fixed-nearpi.c file 251 IEEE 754 binary formats 63 fixed-point accumulator 385, 898 IEEE 754-2008 decimal characteristics 929 fixed-point arithmetic IEEE 754-2008 decimal design 927 address calculation 961 IEEE 754-2008 decimal formats 930 binary 970 inexact operation 79 databases 928 invalid operation 79 decimal 928, 954 NaN test 80 discarding fractional digits 133 overflow 71 divide exception 977 overflow in splitting 362 EDSAC 353 precision control 123, 126 elementary functions viii, 763 rational numbers 15 emulating with floating-point arithmetic 931–933 rounding control 107, 110, 115 exact summation 385 rounding operation 66 graphics processors 86 S-floating on Alpha 956 PL/1 928 signed zero 69 representation of large integers 133 significance loss 89 rescaling problem 927, 933 splitting 132, 359 fld1 instruction 293 subnormal number 78 fldlg2 instruction 293 T-floating on Alpha 956 fldln2 instruction 293 test for decimal quantization 933 float _Complex data type 441 trap 106 float complex data type 441 underflow 77 Float data type 911 unusual systems 966 float data type xxxvi, 4, 5, 57, 58, 82, 92, 102, 129, 163, 210, 213, floating-point conversion 237, 254, 265, 292, 293, 310, 355, 388, 391, 395, 396, 399, 420, format specifier 873, 874 454, 459, 475, 527, 534, 557, 558, 572, 586, 597, 657, 724, 738, output precision 876 764, 770, 771, 811, 815, 818, 824, 829, 834, 865, 875, 877–879, floating-point environment 105 890, 896, 908, 911, 918, 921, 941, 962, 981, 983, 990 floating-point input 879 float make target xxxv floating-point output 829 system header file 3, 62, 82, 100, 135, 252, 527, 598, 769, Floating-Point Systems (vendor) 952 785, 855, 859, 867, 936, 994 flog10 instruction 294 float_pair data type xxxi, 355, 381, 382, 384 flog2 instruction 294 Floating Point Computation 948 flogn instruction 294, 352 floating-point arithmetic see also wobbling precision flognp1 instruction 294, 352 Binary Integer Decimal (BID) format 930 floor function 136 conversion specifier 907 Florida State University 200 conversion to integer 129 FLT_MAXRANL_INV global variable 213 D-floating on PDP-10 948 flush to zero see underflow D-floating on VAX 948, 957, 958 Flux Research Group ix decimal design issues 928 fma see fused multiply-add decimal desirability 927 fma instruction 86, 391 decimal exact scaling 937 fma.d instruction 391 decimal extensions 101, 927 fma.s instruction 391 decimal header file 936, 937 fmadd instruction 391 decimal NaN 930 fmadds instruction 391 decimal normalization 934 fmaxxx.h header file 391, 394 decimal quantization 932 fmcw.h header file 944 decimal rounding 936 FMOD instruction 150 decimal storage initialization 935 fmpyfadd,dbl instruction 391 Densely Packed Decimal (DPD) format 930 fmpyfadd,sgl instruction 391 differences between decimal and binary 931 FNLIB package xxxi, 341, 352, 823 division by zero 70 fontenc package 1115 exact scaling see ldexp(), see scalbln(), see scalbn() Foonly (vendor) 954 exception 106 footnote viii, 3, 4, 7, 8, 13–16, 24, 28, 43, 48, 57, 63, 69, 104, 170, 176, exception flags 107, 110, 112, 116, 120 206, 223, 228, 267, 283, 297, 299, 303, 385, 433, 441, 460, 475, F-floating on PDP-10 948 524, 525, 550, 568, 569, 572, 576, 578, 579, 587, 589, 591, 604, F-floating on VAX 948, 957 616, 630, 671, 693, 763, 769, 773, 774, 776, 801, 802, 823–826, fused multiply-add (fma) 85 848, 869, 896, 899, 917, 947, 952, 963, 966, 969, 976, 979 G-floating on PDP-10 948 FORMAT statement 829 G-floating on VAX 948, 957, 958 Forsythe, George Elmer (1917–1972) 472 H-floating on VAX 948, 957, 958 Fortran hexadecimal formats on System/360 964 deficiencies in mathematical library 223 historical formats 948 support for IEEE 754 106 I/O primitives 829, 879 Fortran 2003 language 106, 130, 941 IEEE 754 binary characteristics 65 Fortran 2008 language 130, 223, 591, 593, 598, 694, 941 IEEE 754 binary design 63 Fortran 66 language 129, 941, 942 1084 Subject index . . . G

Fortran 77 language 4, 57, 129, 875, 940–942, 945, 977, 994 special functions 590, 827 Fortran 90 language 4, 57, 106, 130, 355, 829, 942, 945, 946, 967, 977 fused multiply-add (fma) 85, 86–89, 145, 218–220, 224, 235–242, Fortran 95 language 57, 106, 946 362, 365, 452, 458, 491, 525, 528, 596, 599, 651, 681, 700, 704, FORTRAN Automatic Coding System for the IBM 704 EDPM 959 708, 713, 760, 781, 787, 824, 825 Fortran interface 941 cheap but inaccurate 239 building 943 correcting for double rounding 393 programming 944 divide algorithm 953 using 945 faulty implementation 87, 220, 235, 370 Fortran language vii, 1, 2, 4, 28, 29, 37, 57, 61, 64, 70, 72, 74, 77, 91, graphics processors 86 99, 106, 108, 124, 129, 130, 173, 200, 223, 232, 341, 343, 385, 411, IEEE 754-2008 966 412, 420, 441, 442, 449, 463, 520, 556, 562, 583, 593, 645, 650, implemented with multiple precision 401 763, 769, 775, 823, 826, 829, 830, 832, 843, 869, 870, 873, 879, implemented with pair precision 388 904, 909, 910, 940–946, 949, 951, 952, 954, 955, 961, 963, 973, implemented with round-to-odd 403 974, 976, 977, 994 implemented without pair precision 395 Fortran Version 3A/B Reference Manual 949 in hardware 218 forward evaluation of continued fraction 12 polynomial evaluation 88 Four-Color Problem 60 significance of 86 Fourier, Jean Baptiste Joseph (1768–1830) 299 square root evaluation 218 FP-6000 (model) 970 future value of an annuity 295 fp_c_t data type 442, 443 fyl2x instruction 294 fp_cx_t data type 442, 443, 692 fyl2xp1 instruction 294 fp_pair_t data type 355 fp_t data type 3, 5, 85, 101, 135, 247, 250, 251, 265, 310, 313, 355, G 356, 382, 429, 430, 667, 741 G-15 (model) 970 fpatan instruction 338 G-20 (model) 970 FPREM instruction 146, 148, 150 G-floating 948, 955, 956 FPREM1 instruction 146, 150 G5 (CPU) 86, 217, 219, 370, 388 fptan instruction 338 gamierf*.c file 566 fptest package 775 gamiexp*.c file 567 system header file 125 gamma (Euler’s constant, γ) history 59 fpu_control_t data type 125 Gamma 60 (model) 970 France 802, 825 gamma distribution 195 FREEBSD operating system viii, x, 71, 124, 131, 459, 825 gamma function Γ() 521, 521 Freely Distributable Math Library (fdlibm) 824 regularized incomplete 595 FREM instruction 146, 150 GAMMA global variable 850, 851 French libraries 825 garbage collection 91 FREQUENCY statement 962 Gauss, Carl Friedrich (1777–1855) 441, 558, 560, 619, 623, 631, 632, frexpf.c file 944 663, 702, 969 fsin instruction 338 biography 59 fsincos instruction 338, 339 Gauss–Chebyshev quadrature 702 fsinh instruction 352 Gauss–Laguerre quadrature 560 fstoi instruction 129 Gauss–Legendre quadrature 702 fstox instruction 129 Gautschi, Walter 562, 563 ftan instruction 338 Gay, David M. 763, 896 ftanh instruction 352 gcc program xxxv, 87, 101, 153, 216, 292, 338, 391, 392, 401, 442, ftentox instruction 294 813, 814, 817, 818, 821, 825, 826, 912 ftocs.c file 945 gcd ftwotox instruction 293, 294 example 182 Fujitsu (vendor) 952, 963 iteration counts 182 Fullerton, Louis Wayne 823 negative function value 184 Fun with Fibonacci 578, 978 symmetry relations 183 function with iteration 182 ceiling 136 with recursion 181 floor 136 gcdcw.h header file 183, 188 integer rounding 140, 142 GE 235 (model) 970 rounding 137–139 GE 435 (model) 970 truncation 135 GE 635 (model) 970 FunctionApproximations package 34 Gegenbauer, Leopold (1849–1903) 59 further reading General Electric (vendor) 65, 305, 947, 948, 958, 959, 970 computer arithmetic 103 generator cryptography 214 AES 178 elementary functions 827 combined 177 mathematical biographies 58 computing congruential 171 orthogonal polynomials 58 cryptographic 178 polynomial fits 58 deficiencies of congruential 170 random numbers 214 Diehard Battery test suite 200 Subject index . . . G 1085

floating-point to integer 165 glquad.map file 560 Gorilla test 200 GMP package 402, 433, 825, 994 Hansson–Pike–Hill 812, 813 system header file 402 improving 178 gmp_rounding_mode data type 402 integer to floating-point 160 gnat program 911, 915 integer to integer 166 gnatbind program 912 inversive congruential 180 gnatlink program 912 KISS 177, 208, 210 gnatmake program 911–913 lagged Fibonacci 176 GNU (vendor) xxxv, 71, 87, 101, 133, 274, 320, 352, 391, 433, 442, linear congruential 169 813, 814, 817, 819, 821, 825, 860, 911, 928, 930, 936, 944, lrand48() 162 989–991, 993, 994 mathcw library 208 compiler family xxxv Mersenne Twister 207 GNU libraries 825 multiple recursive congruential 176 GNU MP: The GNU Multiple Precision Arithmetic Library 401, 407 multiplicative congruential 169 GNU operating system x multiply-with-carry (MCW1038) 177 GNU Scientific Library 583, 694, 825 NIST Statistical Test Suite 200 GNU/LINUX operating system viii, x, xxxv, 71, 78, 87, 93, 109, other algorithms 176 123, 125, 127, 131, 216, 218, 220, 235, 238, 239, 370, 399, 401, period 157 459, 696, 811, 813–815, 817, 819, 825, 833, 834, 911, 956, 967 POSIX Standard 162 gnuplot program 223, 1115 quadratic congruential 176 Go language vii quantum cryptographic 178 GO TO statement 962 range 157 Go To Statement Considered Harmful 962 seed 157 Goldberg base-conversion precision 853 shuffled nested Weyl sequence 177 Goldberg, I. Bennett 851,√ 853 software guidelines 157 golden ratio (φ =(1 + 5)/2 ≈ 1.618) 8, 473, 577, 988 testing nonuniform 202 golden ratio (φ) history 14, 59, 577 testing uniform 196, 200 Good Ideas, Through the Looking Glass 959 TestU01 suite 200 Good, Irving John 169 tuftest suite 200 googol 283, 542 Weyl sequence 177 googolplex 283 XOR-shift 176 Gorilla test of random-number generator 200 genmap-* file 771 Gosset, William Sealey (1876–1937) 196 Gentle, James Eddie 214 goto statement 2, 184 Gentoo (vendor) 956 Gould (vendor) 948, 963, 970 GHOSTBSD operating system x gp language 269 GIER (model) 970 gp program 1115 glibc package 133, 274, 825 gpc language 993 Global Positioning System (GPS) 204 gpc program 989, 990, 993, 994 global variable GPU (graphics processing units) 475 $MachinePrecision (Mathematica) 35, 39 gradual underflow 64, 78 _ _GROUP_ _ 851 graphics processing units (GPU) 475 _ _mcw_fe_dfl_env 116, 117 graphicx package 1115 BASE 43, 782 greatest common divisor see gcd Digits 28, 29, 245, 247, 252, 408, 546, 604, 606, 626, 638, 724 Greece 299 Digits (Mathematica) 39 Greek letter 988 E 850, 851 alpha (α, A) 283, 624, 627, 632, 852 errno 70, 71, 91, 93–96, 130, 132, 136, 137, 139–143, 148, 150, beta (β, B) 62, 283, 587 152, 155, 563, 690, 700, 719, 730, 758, 763, 785, 791, 792, 803, chi (χ, X) 197, 562 885, 897, 908 delta (δ, Δ) 61, 658 FLT_MAXRANL_INV 213 digamma (obsolete) 521 GAMMA 850, 851 epsilon ( , ε,E) 62 LDBL_MAXRANLL_INV 213 eta (η, H) 587, 643 LLRANDCW_MAX 211 gamma (γ, Γ) 61, 521 LRANDCW_MAX 211 lambda (λ, Λ) 587 MAXNORMAL 782, 955 mu (μ, M) 194 MINNORMAL 711, 955 nu (ν, N) 198, 562 MINSUBNORMAL 394, 407, 782 omega (ω, Ω) 627 Order 11, 21 phi (φ, ϕ, Φ) 8, 172, 521, 577, 593, 610, 624, 627 PI 408, 409, 850, 851, 955 pi (π, , Π) 14, 630 PRECISION 43 psi (ψ, Ψ) 61, 521 signgam 521, 534 rho (ρ, , P) 645 sys_errlist 94 sigma (σ, ς, Σ) 8, 194, 848 sys_nerr 94 tau (τ, T) 344 thread problem 95, 132, 522, 897 theta (θ, ϑ, Θ) 70, 202, 299, 624, 697 glquad.c file 560 xi (ξ, Ξ) 695 1086 Subject index . . . H

zeta (ζ, Z) 303, 427, 521, 695 complexcw.h 442 Gregory, James (1638–1675) 801 const.h 365 groff program 1115 cosdbl.h 700 gs program 1115 coshx.h 348 GSL package 825 cospix.h 318 guard bit 67, 68, 256, 259, 882, 987 cosx.h 308 guidelines for random-number generator software 157 cotanx.h 313 Guinness Brewery 196 cvtdir.h 849 Gustavson, Fred G. 353 cvticw.h 879 Gutmann, Peter 214 cvtid.h 898 gv program 1115 cvtocw.h 840, 854 gzip program 1115 cvtodx.h 864 cvtoh.h 840, 844 H cvtohx.h 834, 850 H-floating 956 cvtoox.h 850 Hacker’s Delight 166, 176, 978 cvtsfx.h 890, 892 HAIKU operating system x cxcw.h 442, 507 half float 64 cxl1px.h 497, 500 halfword 969 deccw.h 102 Halley’s Comet 630 e10m1x.h 279 Halley’s method 9, 10, 230, 610 eljagx.h 662 Halley, Edmund (1656–1742) 9, 10, 604 eljcnx.h 664 Hamming, Richard Wesley (1915–1998) 22 eljdax.h 676 Handbook of Continued Fractions for Special Functions 19, 827 eljdnx.h 664 Handbook of Elliptic Integrals 667, 682 eljscx.h 663 Handbook of Floating-Point Arithmetic 104 ellrcx.h 649 Handbook of Mathematical Functions 6, 59, 269, 562, 600, 643, 651, elwkx.h 685 652, 657, 682, 684, 693, 731, 826, 827 erfcsx.h 598 Hanek, Robert N. 250, 253, 259, 265 erfcx.h 598 Hankel function 695 erid.h 255, 258 Hankel, Hermann (1839–1873) 695 eulnx.h 573 Hansson–Pike–Hill random-number generator 812, 813 exp.h 272 hard-to-round base conversions 852 expm1x.h 274, 276 hard-to-round function values 28, 251 expx.h 272 HARDENEDBSD operating system x fenvcw.h 108–110, 112, 116, 120, 121, 127 hardware instructions see also _ _asm_ _, see also instruction fenvx.h 107, 110, 116, 126 exponential 292 fibnx.h 578 fused multiply-add 388 fmaxxx.h 391, 394 hyperbolic functions 350 fmcw.h 944 logarithm 292 gcdcw.h 183, 188 precision control 124 inttcw.h 209, 260 reciprocal square root 240 issafe.h 77 square root 240 j0.h 708 trigonometric functions 338 j0x.h 708, 718 hardware out-of-range conversion 131 j1x.h 718 Hardy, Sir Godfrey Harold (1877–1947) 579 jnx.h 712 harmonic series 541, 579, 703, 722 l21px.h 292 Harrenstien, Ken ix lgammx.h 534 Harris (vendor) 254, 396, 597, 947, 948, 970 lgbfax.h 558 Hart, John F. 644 log.h 287 Harvard University (vendor) 970 logx.h 286, 292 Hastings, Jr., Cecil 643, 644 MathCW.h 980, 983 haversine function 301 mathcw.h xxxv, 2, 4, 5, 108, 130, 209, 308, 325, 816, 879, 923, 924 Hayes, Wayne B. 385 mathcw.hh 923, 924 header file see also file, see also system header file mconf.h 824 asin.h 326 modf.h 130 atan.h 32, 89 modfx.h 130 atan2x.h 70 paircw.h 355 atanhx.h 348, 350 pcbrtx.h 379 atanx.h 32, 88, 89 pgammx.h 556–558 bernx.h 573 powx.h 411, 430 betnm.h 590 prec.h 85, 135, 256, 529 binx.h 728 psix.h 543, 555 bisnx.h 728 pspli.h 365 bknx.h 730 psqrtx.h 376 chkasm.h 770 pxy*.h 427 Subject index . . . I 1087

pxy.h 438 histogram 189 pxyx.h 411, 429, 430, 433, 434 historical floating-point architectures 947 randcw.h 209, 211 history of mathematics 59 remqu.h 152 HITAC 3030 (model) 970 rphx.h 308 Hitachi (vendor) 952, 963, 970 rpx.h 306 Hoare, Charles Anthony Richard 963 sbinx.h 753, 754 hoc language vii, 31, 107, 166, 182, 196, 227, 231, 313, 316, 394, 400, sbis0x.h 747 401, 407, 408, 415, 560, 570, 589, 590, 622, 630, 651, 653, 675, sbis1x.h 750 689, 705, 706, 711, 777, 778, 782, 785, 787–789, 803, 830, sbisnx.h 754 849–851, 873–876, 906, 950, 954 sbj1x.h 738 hoc program 1, 29, 78, 87, 696 sbk0x.h 755 hoc128 program 408, 766, 1115 sbk1x.h 755 hoc32 program 220, 850, 851, 1115 sbknx.h 755 hoc36 program 107, 849, 955, 1115 sbks0x.h 755 hoc64 program 622, 1115 sbks1x.h 755 hoc72 program 1115 sbksnx.h 755 hoc80 program 78, 950, 1115 scpi4.h 318 hocd128 program 1115 seterr.h 96 hocd32 program 1115 shchx.h 348 hocd64 program 1115 sinhx.h 348 Hollerith string 941 sinpix.h 318, 531 Honeywell (vendor) 65, 305, 948, 949, 958, 959, 970 sinx.h 309 Horner’s rule 49, 89, 97, 221, 275, 745, 748 sqrt.h 3 definition 24 sqrtx.h 3, 4, 87, 96, 219, 241 Horner, William George (1786–1837) 24 store.h 365 Hough, David Granville 851 tanhx.h 805 How Cray’s Arithmetic Hurts Scientific Computation 953 tanpix.h 319, 545 HP (vendor) see Hewlett–Packard tanx.h 313 HP-UX operating system xxxv, 58, 71, 100, 101, 131, 218, 233, 355, tgamm.h 527 388, 765, 815, 816, 834, 877 tgammx.h 525, 528, 529, 531, 534, 535 hp_t data type 85, 310, 429, 430, 688, 741 vprtx.h 878 Hull, Thomas E. (1922–1996) 217 x.h 3 HURD operating system 825 y0x.h 718 Hurwitz zeta function 583 y1x.h 718 hygrometer 802 zetax.h 583 hyperbolic cosecant 569 zetm1x.h 583 hyperbolic cosine see cosh Heaviside step function 477 computing with hyperbolic sine 348 heliotrope 441 Taylor series 342 Helmholtz equation 693 hyperbolic function 341, 341 Henry Eyring Center for Theoretical Chemistry ix improving 345 Hercules program x, 1115 in hardware 350 Hermite polynomials 57 inverse 348 Hermite, Charles (1822–1901) 16, 59, 267, 619 hyperbolic secant function 572 Hess, Victor Francis (1883–1964) 475 hyperbolic sine see sinh Hewlett–Packard (vendor) viii, xxxv, 4, 71, 86, 100, 101, 233, 355, computing with hyperbolic cosine 348 383, 388, 765, 812, 815, 816, 824, 970 Taylor series 342 Test Drive Laboratory ix, 811 hyperbolic tangent see tanh hexadecimal Taylor series 342 base 24, 25, 155, 283, 290, 423, 427, 428, 437, 596, 608, 617 hypergeometric distribution 195 conversion specifier 873, 874 hypotenuse 222, 480 floating-point layouts on System/360 964 by iteration 227 notation 977 definition 299 hexadecimal number relation to complex absolute value 444 input conversion 895 output conversion 832, 834 I hhmm package 1115 I/O primitives 829, 879 Hida, Yozo 366, 385, 407, 777 i860 (CPU) 86 hidden argument 941 IA-32 (CPU) ix, xxv, xxxv, 63, 65, 68, 71, 80, 92, 100, 108, 109, 121, hidden bit (in floating-point significand) 63, 64, 67, 78, 956, 957, 124–127, 131, 146, 148, 150, 216–218, 234, 237, 240, 242, 965 292–294, 338, 339, 350, 352, 362, 363, 365, 388, 400, 401, 439, High Accuracy Arithmetic option 964, 967 459, 697, 716, 814, 818–820, 822–825, 867, 911, 917, 928, 967, highest common factor see gcd 970, 1021, 1115 Hilbert, David (1862–1943) 579 not fully conformant to IEEE 754 Standard 63, 365 HIPAC 103 (model) 970 IA-64 (CPU) viii, ix, xxxv, 58, 65, 68, 71, 86, 87, 100, 101, 108, 121, Hisab Al-Jabr wal Mugabalah 575 123, 124, 131, 145, 146, 176, 200, 216–219, 230, 233–235, 237, 1088 Subject index . . . I

238, 240–242, 355, 362, 363, 365, 370, 382, 383, 388, 391, 392, instruction 395, 399, 401, 412, 459, 765, 811, 814, 815, 819, 823, 824, 911, ckfinite 918 928, 953 DIDBR 146 extended data types 100 DIEBR 146 instruction bundles 241, 824 EMOD 146 iAPX 432 (CPU) 970 f2xm1 293, 294 IAS (model) 970 facos 338 IBM (vendor) vii–x, xxxv, 65, 68, 71, 79, 85–87, 104, 109, 146, 155, fasin 338 171, 217, 218, 233, 241, 254, 287, 305, 341, 353, 355, 361, 365, fatan 338 370, 375, 402, 410, 433, 438, 478, 520, 761, 811, 816, 817, 820, fatanh 352 825, 827, 848, 850, 855, 867, 896, 905, 927–930, 936, 942, fcos 338 947–949, 951, 952, 954, 956, 959, 961–964, 967, 969–971, fcosh 352 976–978, 1035 fdtoi 129 Israel Scientific Center 827 fdtox 129 Linux Community Development System ix fetox 294 Icarus asteroid 630 fetoxm1 294 icc program 87, 388, 442, 814, 815 fld1 293 IEC 60559:1989 standard for binary floating-point arithmetic 119, fldlg2 293 123, 124, 133, 144, 914 fldln2 293 IEEE 1788 interval arithmetic 967 flog10 294 IEEE 754 flog2 294 binary arithmetic 63, 105 flogn 294, 352 decimal arithmetic 927 flognp1 294, 352 mathcw library support 106 fma 86, 391 programming-language support 105 fma.d 391 single extended format 63 fma.s 391 IEEE 754 Standard for Binary Floating-Point Arithmetic vii, 63, 966 fmadd 391 IEEE Micro 104 fmadds 391 IEEE Portable Operating System Interface (POSIX) Standard 441 FMOD 150 IEEE Transactions on Circuits and Systems 104 fmpyfadd,dbl 391 IEEE Transactions on Computers 104 fmpyfadd,sgl 391 if statement 69, 85, 139, 140, 147, 150, 240, 260, 373, 395, 397, 399, fpatan 338 402, 413, 453, 562, 893, 940 FPREM 146, 148, 150 III (model) 970 FPREM1 146, 150 Illiac I (model) 948, 970 fptan 338 Illiac II (model) 948, 970 FREM 146, 150 Illiac III (model) 948 fsin 338 Illiac IV (model) 947, 948 fsincos 338, 339 implementation issues 61 fsinh 352 import statement 993 fstoi 129 improving fstox 129 Chebyshev fits 51 ftan 338 Cody/Waite algorithms 823 ftanh 352 In Code 208 ftentox 294 in keyword 914 ftwotox 293, 294 incomplete gamma function 595 fused multiply-add 86 Indefinite 80, 950, 951, 953, 963 fyl2x 294 India 8, 299 fyl2xp1 294 Indigo-2 Extreme (model) 976 madbr 391 Indigo-2 (model) 977 madd.d 391 Indy (model) 976, 977 madd.s 391 inexact exception flag 79, 79, 106, 111, 112, 114, 123, 133, 135–137, maebr 391 139, 140, 142, 143, 275, 324, 325, 332, 338, 344, 345, 585, 598, move 478 782, 803, 804 nop 230 inexact operation 79 return 443 Infinity 1, 71, 114, 115, 133, 135, 137, 139, 140, 147, 950, 951, 953, store 960 956, 963, 965 store root 960 arithmetic sets exception flag 123 store rounded 960 pair-precision number 355, 364 TMI 962 infinity history 59 TPL 962 infinity norm 48, 223 TRA 962 initialization of floating-point storage 931, 935 TZE 962 INITIALSEED environment variable 764 video set 86 Inline keyword 915 int * data type 874 inline keyword 115 int data type 73, 74, 90, 91, 94, 125, 131, 162, 163, 206, 209, 254, installation of mathcw library xxxv 257, 356, 421, 422, 667, 868, 877, 896, 941, 990 Subject index . . . I 1089 int_t data type 74 invalid exception flag 70, 71, 80, 80, 94, 114, 123, 135–137, 139–143, integer see also safe integer arithmetic 336, 482, 486, 490, 496, 507, 513, 514, 518, 791 absolute value (safe) 74 invalid operation 79 addition (safe) 75 inverse complementary error function 600 arithmetic 969 inverse cosine 323, see acos arithmetic problems 978 accuracy 325 biased representation 974 from elliptic function 654, 655 binary notation 977 from inverse sine 323 conversion identities for testing 340 rounding modes 132 Taylor series 323 specifier 907 inverse cotangent division (safe) 75 from elliptic function 654, 655 division by zero 975, 977 inverse error function 600 exception 975 computing 605 excess-n 974 historical algorithms 603 excess-n representation 974 properties 601 hexadecimal notation 977 inverse hyperbolic cosine 348, see acosh lack of symmetry of two’s-complement representation 973 from elliptic function 654, 655 largest signed and unsigned 975 Taylor series 348 memory addressing 971 inverse hyperbolic cotangent multiplication (safe) 75 from elliptic function 654, 655 negation (safe) 76 inverse hyperbolic function 348 octal notation 850, 908, 949, 950, 953, 955, 977 inverse hyperbolic sine 348, see asinh one’s-complement 972 from elliptic function 654, 655 one’s-complement representation 972 Taylor series 348 inverse hyperbolic tangent 348, see atanh overflow 72, 550, 975 from elliptic function 654, 655 LCG computation 173 Taylor series 348 preventing 74 inverse normal distribution function 610 random-number generation 167 inverse sine 323, see asin parity test 975 accuracy 325 quartal notation 977 from elliptic function 654, 655 range 974 identities for testing 340 remainder (safe) 76 Taylor series 323 rounding function 140, 142 inverse tangent 331, see atan, atan2 sign representation 971 AGM algorithm 623 sign test 975 from elliptic function 654, 655 sign-magnitude 971 identities for testing 340 subtraction (safe) 76 with two arguments 336 symmetry of one’s complement representation 972 InverseErf[] function (Mathematica) see also ierf( ) function symmetry of sign-magnitude representation 971 InverseErfc[] function (Mathematica) see also ierfc( ) function two’s-complement 973 inversion of series 20 two’s-complement representation 972 inversive congruential generator (ICG) 180 word sizes 970 relative performance 189 INTEGER data type 129, 941, 962 ipowx.h file 420 Integer data type 911, 990 IRIX operating system 78, 131, 153, 355, 817 INTEGER*1 data type 941 irnint.c file 167 INTEGER*2 data type 941 irrational number 14 INTEGER*4 data type 941 Is Floating Point Really This Complicated? 947 INTEGER*8 data type 173, 941 ISO 10206:1990 Extended Pascal Standard vii, 989 integration (numerical) see quadrature ISO 7185-1982 Pascal Standard 70 Intel (vendor) vii–ix, xxxv, 63, 65, 71, 80, 86, 87, 100, 104, 105, 124, ISO Standard C 1989 see ISO/IEC 9899:1990 C Standard 146, 148, 150, 283, 292, 293, 310, 338, 339, 350, 388, 395, 442, ISO Standard C 1999 see ISO/IEC 9899:1999 C Standard 716, 814, 815, 824, 867, 928–930, 953, 954, 959, 970, 971, 976 ISO/IEC 14882:1998 C++ Standard vii, 57, 106, 441 Interdata (vendor) ix, 896, 948, 963, 965, 970 ISO/IEC 14882:2003 C++ Standard vii, 57, 106 interest (compound) 294 ISO/IEC 14882:2011 C++ Standard vii interface (programming construct) 2 ISO/IEC 1539-1:1997 Fortran Standard vii, 106 Interlisp language 954 ISO/IEC 1539-1:2004 Fortran Standard 106, 941 International Business Machines Corporation see IBM ISO/IEC 1539-1:2010 Fortran Standard vii, 223, 591, 593, 694, 941 Internet 954 ISO/IEC 1539:1991(E) Fortran Standard vii, 106 interval arithmetic 84, 115, 128, 476, 827, 960, 966, 967 ISO/IEC 23270:2006 C# Standard vii interval notation 23 ISO/IEC 8652:1995 Ada Standard vii interval_t data type 115 ISO/IEC 8652:2012 Ada Standard vii intmax_t * data type 907 ISO/IEC 9899:1990 C Standard vii, 4, 64–66, 70, 105, 109, 129, 152 intmax_t data type 877, 896, 907 ISO/IEC 9899:1999 C Standard vii, 4, 70, 87, 105, 106, 108–110, 117, inttcw.h header file 209, 260 129, 133, 135, 136, 139–144, 147, 152, 411, 441, 942 1090 Subject index . . . K

complex division algorithm 449 JNIEnv data type 983, 984 complex multiplication algorithm 456 JNIEXPORT data type 983, 984 complex projection algorithm 460 jnx.h header file 712 hexadecimal floating-point output 832 job termination (premature) 104, 381, 830, 950, 976 output of NaN 842 jobject data type 982 Rationale 123 JOHNNIAC (model) 970 storage of complex data 441 Journal of Computational Physics 214, 693 Technical Corrigendum 2 (2005) 144, 857 Jovial language 763 violation 218, 238 Julia language vii ISO/IEC 9899:2011 C Standard vii Jupiter (planet) 630 ispell program 1115 just-in-time compiler 982 issafe.h header file 77 JVM see Java Virtual Machine Itanium-1 (CPU) 824, 970 Itanium-2 (CPU) 814, 815, 824, 970 K Itel (vendor) 963 K5 (CPU) 293 iteration see also Newton–Raphson iteration KA10 (CPU) 305, 948, 955 nonlinear equation solution 7 Kahan, William Morton “Velvel” v, 63, 251, 265, 326, 353, 354, 358, self-correcting 8 365, 366, 369, 384, 385, 952, 967 iterative solutions 7 KD10 (model) 955 its4 program 870 KDF 9 (model) 948 ixsq*.c file 567 KDF9 (model) 970 Kelvin function 695 J Kelvin, Lord (William Thomson) (1824–1907) 695 j0.h header file 708 Kendall Square Research (vendor) 952 J0taylor.map file 718 Kepler’s Conjecture (sphere-packing problem) 60 j0x.h header file 708, 718 kermit program 954 j1x.h header file 718 Kernighan, Brian Wilson 2, 6 Jacobi, Carl Gustav Jacob (1804–1851) 59, 619, 657, 663, 679 keyword Jacobian Elliptic Functions 678 _Complex 441 Jacobian elliptic functions 657 _Complex_I 441, 442 Jacobian Eta function 679 _Imaginary_I 441, 442 Jacobian Theta function 679 _ _volatile_ _ 293, 339 Jacobian theta functions 673 CharSet 921 Jacobian Zeta function 679 checked 90, 918, 978 Jarno, Aurelien 129 const 3, 94, 356, 365, 992 Java extern 984 deficiencies final 981 binary arithmetic 4, 104, 105 in 914 integer arithmetic 978 Inline 915 mathematical library 70, 223, 341 inline 115 java file 979 name 991 Java interface 979 native 979, 982 building 979 out 914, 921, 922 programming 980, 982 pow 992 using 985 private 981 Java just-in-time compiler 982 protected 990, 992 Java language vii, viii, 2, 4, 29, 52, 57, 70, 71, 73, 74, 80, 90, 99, 100, Pure_Function 915 102, 104, 105, 173, 176, 223, 341, 353, 763, 826, 830, 867, 870, ref 921 917, 919–921, 923, 940, 945, 976–985, 994 restrict 868, 868, 871, 873, 901, 903, 904 Java Native Interface (JNI) 979, 979, 980 sealed 920 overhead 982 sizeof 50, 58, 159, 256, 257, 419, 846, 847, 854, 855, 858, 862, java program 980 863, 889, 907 Java Virtual Machine (JVM) viii, 73, 80, 867, 979 static 3, 174, 396, 402, 439, 841, 853, 866 corruption 982 unsafe 921 java.lang.math package 57 var 991 javac program 979 volatile 65, 66, 121, 127, 135, 139, 163, 231, 245, 246, 250, 275, javah program 979 326, 358, 359, 362–366, 369–371, 393, 404–406, 431–433, 436, javald program 980 451, 471, 478, 598, 746, 749, 761, 780, 785, 849, 994 JavaScript language vii Khoey Ho Tum Kahan 341 jdouble data type 983 KI10 (CPU) 948, 955 jfloat data type 983 King, Louis Vessot (1886–1956) 657, 663 jmmred.map file 251 KISS generator 177, 202, 208–210 JNI see Java Native Interface KL10 (CPU) 305, 948, 954, 955 system header file 983 KLH10 (CPU) ix, 216, 948, 954, 1115 JNICALL data type 983, 984 Knuth, Donald Ervin 6, 89, 157, 200, 366 JNIEnv * data type 982 Kohoutek see Comet Subject index . . . L 1091

Kornerup, Peter 385 ECMAScript vii Kovacs, James 917 Eiffel 830 Kowa, Takakazu Seki (1642–1708) 568 Fortran vii, 1, 2, 4, 28, 29, 37, 57, 61, 64, 70, 72, 74, 77, 91, 99, 106, Kronecker, Leopold (1823–1891) 619 108, 124, 129, 130, 173, 200, 223, 232, 341, 343, 385, 411, 412, KS10 (CPU) 948, 955 420, 441, 442, 449, 463, 520, 556, 562, 583, 593, 645, 650, 763, Kummer, Ernst Eduard (1810–1893) 589 769, 775, 823, 826, 829, 830, 832, 843, 869, 870, 873, 879, 904, KVM (Kernel-based Virtual Machine) x 909, 910, 940–946, 949, 951, 952, 954, 955, 961, 963, 973, 974, 976, 977, 994 L Fortran 2003 106, 130, 941 l21px.h header ﬁle 292 Fortran 2008 130, 223, 591, 593, 598, 694, 941 lacheck program 1115 Fortran 66 129, 941, 942 lagged Fibonacci generator 176 Fortran 77 4, 57, 129, 875, 940–942, 945, 977, 994 Lagrange, Joseph-Louis (1736–1813) 619, 623, 663, 802 Fortran 90 4, 57, 106, 130, 355, 829, 942, 945, 946, 967, 977 Laguerre polynomials 57 Fortran 95 57, 106, 946 Laguerre, Edmond Nicolas (1834–1886) 59, 560 Go vii Lambda (model) 970 gp 269 Lambert, Johann Heinrich (1728–1777) 17, 802 gpc 993 Lanczos, Cornelius (1893–1974) 536, 969 hoc vii, 31, 107, 166, 182, 196, 227, 231, 313, 316, 394, 400, 401, language 407, 408, 415, 560, 570, 589, 590, 622, 630, 651, 653, 675, 689, Ada vii, 1, 2, 223, 355, 829, 830, 870, 875, 899, 911–916, 923, 927, 705, 706, 711, 777, 778, 782, 785, 787–789, 803, 830, 849–851, 928, 977, 993 873–876, 906, 950, 954 Algol 763, 873, 963 Interlisp 954 Algol 60 vii, 73, 353, 978 Java vii, viii, 2, 4, 29, 52, 57, 70, 71, 73, 74, 80, 90, 99, 100, 102, Algol 68 vii 104, 105, 173, 176, 223, 341, 353, 763, 826, 830, 867, 870, 917, awk vii, 31, 811 919–921, 923, 940, 945, 976–985, 994 Axiom 694, 773 JavaScript vii BASIC 251, 954 Jovial 763 Bliss 873, 954 Julia vii C vii, x, xii, xxxv, xxxvi, 1–6, 24, 29, 34, 37, 39–42, 47, 48, 52, 54, Lisp vii, 34, 90, 188, 830, 896, 954, 963 56–62, 64–66, 69–74, 77, 80, 81, 87, 90–93, 95, 96, 99–102, Lua vii 104–110, 112, 113, 115, 117, 123–125, 127, 129, 130, 132, 133, MacLisp 954 135, 139–144, 147, 152, 155, 156, 159, 167, 173, 176, 181, 186, Macsyma 28, 954 200, 206, 211, 218, 236, 238, 239, 241, 246, 251, 254, 256–258, MAINSAIL 954 260, 264, 283, 290, 304, 326, 338, 340, 347, 353–356, 358, 359, Maple viii, x, 10, 11, 14, 16, 21, 25, 26, 28, 31–33, 35, 41, 43, 46, 362, 365, 385, 397, 400, 404, 407, 410–413, 421, 426, 441, 448, 47, 50–52, 54, 55, 82, 89, 215, 228, 237, 240, 243, 246, 251–253, 453, 459, 463, 472, 478, 488, 521, 560, 561, 583, 591, 595, 598, 265, 269, 271, 277, 290, 313, 316, 318, 320, 323, 388, 401, 408, 614, 625, 675, 682, 690, 691, 694, 708, 712, 763–765, 769, 771, 463, 477, 486, 488, 523, 526, 527, 532, 533, 535, 537, 538, 546, 772, 778, 780, 783, 785, 789, 824–827, 829, 830, 832, 834, 840, 548, 550, 552, 553, 556, 559–561, 567, 569, 572, 583, 584, 587, 841, 845, 848, 850, 851, 853, 854, 860, 867, 869, 870, 873, 875, 588, 590, 602–609, 615, 617, 620, 622, 623, 625, 626, 628, 631, 877–880, 886, 887, 889, 890, 892, 896, 897, 899, 901, 902, 904, 637, 638, 650, 653, 659, 667, 669, 670, 672, 674, 685, 688, 694, 905, 908–911, 913, 914, 916, 917, 921, 923–925, 928, 931–933, 697, 705, 708, 718, 724, 726, 740, 741, 749, 750, 752, 753, 936, 940–945, 955, 956, 962, 965, 966, 972, 975, 978–984, 989–994 770–773, 827, 954 C++ vii, xxxv, 1, 2, 4–6, 29, 52, 57, 69, 71, 73, 74, 90, 100–102, Mathematica viii, x, 16, 21, 28, 33, 34, 36–38, 40, 42, 55, 56, 269, 106, 109, 124, 125, 173, 176, 200, 211, 223, 354, 355, 365, 410, 401, 477, 537, 548, 556, 561, 569, 573, 583, 587, 590, 601, 620, 441, 763, 776, 826, 827, 830, 870, 878, 917, 920, 923–925, 928, 625, 628, 631, 653, 659, 667, 669, 670, 674, 678, 685, 688, 694, 932, 936, 967, 979, 982–984, 994 750, 752, 753, 966 C++98 57 MATLAB x, 3, 57, 171, 228, 348, 385, 537, 539, 548, 583, 595, 596, C89 xxxv, 2, 3, 57, 58, 91, 93, 115, 121, 135, 162, 209, 223, 231, 601, 603, 604, 608, 614, 659 233, 254, 255, 336, 341, 358, 362, 365, 413, 420, 441, 719, 765, Maxima viii, 28, 269, 537, 548, 561, 569, 573, 583, 625, 628, 631, 785, 868, 869, 871, 873–875, 877, 896, 906, 908 659, 667, 694, 773 C99 xxxv, 1, 3–5, 57, 58, 74, 78, 85, 89, 91–95, 100, 105–110, 117, Mesa 954 120, 122–125, 127, 130–133, 155, 156, 173, 209, 210, 218, 219, Modula vii 223, 227, 231, 233, 237, 256, 260, 284, 336, 338, 341, 358, 362, MuPAD viii, x, 21, 269, 537, 548, 561, 569, 583, 694 370, 377, 385, 388, 405, 406, 409, 410, 412–415, 419, 441, 442, NetRexx viii, 928, 968 444–446, 448, 449, 451, 453, 455, 456, 458–464, 466, 482, 485, Oberon vii 489, 490, 492, 495–497, 500, 502, 507, 512–514, 517, 518, OCaml vii 520–522, 524, 525, 534, 593, 719, 765, 785, 787, 791, 792, 829, PARI/GP viii, 269, 537, 548, 561, 569, 583, 620, 685, 694 830, 832, 834, 841, 842, 848, 850, 857, 860, 868–870, 873–875, Pascal 2, 70, 74, 130, 223, 341, 411, 763, 829, 870, 879, 949, 877–879, 885, 896, 897, 902, 906–908, 937, 942, 951, 953, 954, 989–994 957, 964, 978, 979, 982 PCL 954 C# vii, viii, 2, 4, 57, 70, 80, 90, 100, 102–105, 223, 341, 826, 830, Perl vii 917–923, 927, 978, 994 PHP vii Cedar 954 PL/1 vii, 763, 927, 928 COBOL vii, 763, 927, 928, 963 Portable Fortran 823 Common Lisp 130, 341 PostScript vii, 36, 105 D vii, 830 PSL 954 1092 Subject index . . . L

PUB 954 Lindemann, Carl Louis Ferdinand von (1852–1939) 16 Python vii linear congruential generator 169 R 601, 616, 659 Linnainmaa, Seppo 370 REDUCE viii, 28, 269, 537, 548, 569, 573, 620, 625, 628, 659, 674, LINPACK benchmark 952 694, 954 LINPACK package 223, 228 Rexx vii, viii, 928, 968 lint program 870, 908 Ruby vii, 923 Linux see GNU/Linux Rust vii Linux Community Development System at IBM ix S-Plus 601, 616 Lisp language vii, 34, 90, 188, 830, 896, 954, 963 Sage 269 little epsilon 63, 304 SAIL 954 little-endian Scheme vii addressing 956 Scribe 954 format 917 SDL 977 LLRANDCW_MAX global variable 211 Simulink 228 LMI (vendor) 970 Smalltalk 954 log-gamma function log |Γ()| 521 SPELL 954 log.h header file 287 Tcl vii logarithm 267, 282 LAPACK package 223 AGM algorithm 624 Laplace argument near one 290, 654, 655 distribution 195 argument reduction 283, 285, 291 equation 693 error magnification 283 transform 673 from elliptic function 654, 655 Laplace, Pierre Simon (de) (1749–1827) 194, 195 in hardware 292 LATEX 954 Napierian 282 latex program 1115 natural 282 Lawrence Livermore National Laboratory (vendor) 305, 463, 948, Taylor series 284, 285, 292 965 logarithmic distribution 190 lcc program 3 LOGICAL data type 941, 961 LCG (linear congruential generator) 169 logical-AND 177 lcm symmetry relations 183 logx.h header file 286, 292 LD_LIBRARY_PATH environment variable 919, 946 long data type 173 LDBL_MAXRANLL_INV global variable 213 long double * data type 907 leap-frog method 179 long double complex data type 441 least common multiple see lcm long double data type xxxv, xxxvi, 4, 5, 57, 58, 92, 100–102, 124, Legendre 129, 155, 164, 210, 213, 218, 237, 238, 293, 310, 347, 352, 355, polynomials 57 388, 391, 399, 412, 454, 764, 770, 815–818, 820, 821, 823, 829, relation 630, 690 854, 856, 865, 867, 877, 879, 890, 896, 907, 908, 911, 921, 941, 990 Legendre, Adrien Marie (1752–1833) 59, 537, 619, 663, 702 long int * data type 907 Lehmer, Derrick Henry (1905–1991) 169 long int data type 74, 129, 131, 140, 161, 162, 209, 254, 257, 260, Leibniz, Gottfried Wilhelm (1646–1716) 8, 969 877, 892, 896, 907, 908, 979, 990 Lentz algorithm for continued fractions 18 long long double data type 4, 5, 58, 64, 890 Lentz, W. J. 18 long long int * data type 907 Leo 3 (model) 970 long long int data type 74, 129, 131, 260, 453, 877, 892, 896, 907, LEO I (model) 970 941, 979, 990 Leonhardi Euleri opera omnia 591 long_double_pair data type 355 letter notation 987 Long_Float data type 911 lgammx.h header file 534 Long_Integer data type 911 lgbfax.h header file 558 long_long_double * data type 907 LGP-21 (model) 970 long_long_double data type 102, 877 LGP-30 (model) 970 long_long_double_pair data type 355 Li, Xiaoye S. 366, 407, 777 Long_Long_Float data type 911 Liber Abaci 575 Long_Long_Integer data type 911 libMathCW.dylib file 982 longdouble make target xxxv libMathCW.so file 980, 982 LongInt data type 990 libmcr package 811, 821, 824 LongReal data type 990 libmcw.a file 4, 771 longword 969 libmcw.dylib file 920 loop invariant 425 libmcw.so file 4, 920 Los Alamos 202 library extensions 57 Los Alamos Laboratory 959 library testing 763 Los Alamos Scientific Laboratories (vendor) 970 Librascope (vendor) 970 loss of significance see significance loss lightweight process see thread Lovelace, Lady Augusta Ada (1815–1852) 568, 911 limit operator 61 LRANDCW_MAX global variable 211 limitations of Cody/Waite polynomials 28 ls program 912 system header file 3, 94, 130, 152, 159, 260, 994 Lua language vii Subject index . . . M 1093 luximono package 1115 Mark I (model) 970 Lyon, France 825 Mark IIA (model) 948, 965 Lyons (vendor) 970 Markstein, Peter 410, 824 markup language see language M Mars (planet) 630 MAC OS X operating system x, 71, 109, 131, 399, 697, 818, 920, 982 Marsaglia, George (1924–2011) 176, 177, 200, 214, 618 MacBeth 777 Mascheroni, Lorenzo (1750–1800) 524, 541, 591, 702, 703, 722 Macdonald function 695 Math class 57, 920, 921, 979, 981, 982, 985 MACH operating system 71, 131 math program 601, 1115 machine epsilon 62, 87, 97, 217, 234, 290, 544, 597, 602, 608, 765, system header file xxxv, 2, 50, 57, 82, 91, 92, 94, 95, 100, 785, see also relative error, see also ulp (unit in the last place) 101, 108, 120, 130, 223, 336, 411, 816, 905 aberrant computation in pair-precision arithmetic 777 MathCW class 921, 925, 979–982, 985, 990 aberrant computation on PDP-10 849 MathCW package 57 definition 62, 466 mathcw package xii, xxv, xxxv, xxxvi, 1, 2, 4–6, 20, 25, 28, 29, 33, extended arithmetic 100 38, 43, 44, 50, 55, 57–62, 64–66, 70, 71, 77, 79, 80, 84, 85, 87, 89, IEEE 754 64-bit arithmetic 608 95, 96, 101–107, 109, 116, 117, 120, 123, 124, 130, 133, 147, 152, pair-precision arithmetic 779, 780 155, 156, 166, 183, 184, 188, 206, 208, 210, 216, 219, 220, 224, quad arithmetic 101 233, 237, 247, 250, 251, 254, 255, 257, 260, 271, 275, 277, 283, scaling in pythag() 232 284, 288–290, 292–294, 315, 331, 338–341, 345, 346, 351–353, machine number 62, 81, 83, 217, 218, 234, 238, 243, 245, 246, 290, 355, 356, 359, 363, 365–367, 370, 385, 386, 388, 391, 401–403, 303, 305, 708, 897, 940 406–408, 410–412, 414, 418, 427, 429, 430, 432, 434, 438, MacLisp language 954 440–442, 451, 459, 463, 464, 466, 478, 479, 484, 489, 492, 497, MACOS operating system x 512, 521, 522, 525–529, 531, 537, 542, 548, 550, 554, 555, 557, macro expansion prevention 112 558, 561, 562, 572, 573, 578, 583, 590–592, 595–598, 605, 608, Macsyma language 28, 954 614, 616, 619, 620, 625, 628, 631–633, 643, 645, 649, 651, 653, madbr instruction 391 657, 659, 662, 667, 669, 671, 672, 674, 676, 678, 681, 682, 685, madd.d instruction 391 688, 690, 693, 694, 707, 709, 716, 719, 724, 734, 738, 740, 755, madd.s instruction 391 762–765, 767–769, 771, 776, 779, 792, 798, 808, 811–819, 826, MADIC IIA (model) 970 830, 831, 848, 853, 856, 865, 867, 868, 871, 873–879, 897, 899, MADIC III (model) 970 902, 905–907, 910, 911, 913–925, 928, 931–933, 936, 937, 939, maebr instruction 391 940, 942, 943, 945–947, 954, 967, 978, 979, 982, 989–991, 993, Magnuson (vendor) 963 1115 MAINSAIL language 954 library contents 58–60 make program 771, 911, 912, 916, 919, 924, 943, 944, 979, 980, 989, mathcw program 847 990, 993, 1115 mathcw.ads file 911, 912, 914, 915 make target mathcw.bib file xii all xxxv MathCW.c file 982–984 all-hp xxxv MathCW.class file 980 check-hp xxxv mathcw.cs file 919–922 double xxxv MathCW.dll file 982 float xxxv mathcw.gpi file 993 longdouble xxxv MathCW.h header file 980, 983 Makefile file 3, 4, 442, 764, 765, 771, 911, 912, 919, 923, 925, 943, mathcw.h header file xxxv, 2, 4, 5, 108, 130, 209, 308, 325, 816, 879, 946, 979, 989 923, 924 makeidx package 1115 mathcw.hh header file 923, 924 makeindex program 1115 MathCW.java file 980 makeinfo program 1115 mathcw.map file 772 man2html program 1115 MathCW.o file 980 man2texi program 1115 mathcw.o file 993 Manchester University (vendor) 948 mathcw.pas file 989, 991–993 mangling of function names 981, 982 Mathematica language viii, x, 16, 21, 28, 33, 34, 36–38, 40, 42, 55, Manhattan Project 202 56, 269, 401, 477, 537, 548, 556, 561, 569, 573, 583, 587, 590, 601, MANIAC (model) 970 620, 625, 628, 631, 653, 659, 667, 669, 670, 674, 678, 685, 688, mantissa see significand 694, 750, 752, 753, 966 maple file 28, 29, 55, 408, 488, 772 mathematical function see function Maple language viii, x, 10, 11, 14, 16, 21, 25, 26, 28, 31–33, 35, 41, mathematical library publications 826 43, 46, 47, 50–52, 54, 55, 82, 89, 215, 228, 237, 240, 243, 246, Mathematical Methods for Physicists 8 251–253, 265, 269, 271, 277, 290, 313, 316, 318, 320, 323, 388, mathematics history 59 401, 408, 463, 477, 486, 488, 523, 526, 527, 532, 533, 535, 537, Mathematics of Computation 476, 693 538, 546, 548, 550, 552, 553, 556, 559–561, 567, 569, 572, 583, Mathematics of Physics and Modern Engineering 194 584, 587, 588, 590, 602–609, 615, 617, 620, 622, 623, 625, 626, mathpazo package 1115 628, 631, 637, 638, 650, 653, 659, 667, 669, 670, 672, 674, 685, MathSciNet database 59, 576, 591, 693 688, 694, 697, 705, 708, 718, 724, 726, 740, 741, 749, 750, 752, MathWorld 465, 569, 572, 576, 587, 591 753, 770–773, 827, 954 MATLAB language x, 3, 57, 171, 228, 348, 385, 537, 539, 548, 583, maple program 10, 26–28, 251, 408, 602, 1115 595, 596, 601, 603, 604, 608, 614, 659 Mark 1 (model) 970 matlab program 228, 1115 1094 Subject index . . . M

Matsumoto, Yukihiro 923 input handling of most-negative two’s-complement number Matsushita (vendor) 970 896 Matula base-conversion precision 853 input parse failure not detectable 896 Matula, David William 851–853, 866, 867, 875 input pushback limit 902 Maxima language viii, 28, 269, 537, 548, 561, 569, 573, 583, 625, irregular naming of reentrant functions 522 628, 631, 659, 667, 694, 773 Java has no name for smallest normal number 100 maxima program 1115 lack of dynamic field widths in input format specifiers 907 MaxIterations option (Mathematica) 34–36 lack of input overflow alerts 908 MAXNORMAL global variable 782, 955 lack of overflow detection in type narrowing 908 MAXTEST environment variable 764, 812, 813 library suffixes in MAC OS X 920 MC68040 (CPU) 131 limited support for conversion of floating-point values to McCullagh, Peter 543 integers in C89 129 McDonald, Stuart 251 missing output array size in string primitives 879 MCG (multiplicative congruential generator) 169 naming conventions in 936 mconf.h header file 824 naming of strtod() family 879 ψ( ) mcs program 919 negative arguments unsupported by MATLAB x 539 mean value 194 no standard names for common extended exception flags 108 MedInt data type 990 prohibition on mixed lettercase of type suffixes 890 Melcom 1101F (model) 970 reversed precision-control return values on SOLARIS 124 Melquiond, Guillaume 403 some original C99 exception-flag functions fail to return a value memory leak 91 109 Mercury (planet) 630 Standard C strtod() recognizes only a single NaN 887 Mersenne Twister generator 177, 200–202, 207 subnormal formatting unspecified in formatted output 878 Mesa language 954 subnormals unrecognizable in formatted output 78 type suffixes on input numbers unrecognized 890 Mesopotamia 299 undetected format-specifier data type mismatch 908 METAFONT 954 undetected missing argument 908 METAPOST 954 unit leading hexadecimal digit 833 method (in C++, C#, or Java) see function unspecified behavior for NULL pointer to modf() 264 Microsoft (vendor) viii, x, 125, 867, 917, 920, 954, 982 unsupported exception masks are undefined instead of zero Middle Kingdom 465 108 MIDNIGHTBSD operating system x unterminated input strings 908 mil (military angular measurement) 305 widening of float arguments 877 Millennium Prize problems 60 zero powers of NaNs fail to produce a NaN 415 minifloat 64 zero-length strings illegal in Fortran 77 945 minimax rational approximation 33 × − Mitsubishi (vendor) 970 Minimizing q m n 251 mod-mathpazo package 1115 MINIX operating system 92 model see also CPU MINNORMAL global variable 711, 955 /6 597, 948, 970 MINSUBNORMAL global variable 394, 407, 782 /7 597, 948, 970 MIPS (CPU) 68, 71, 153, 240, 392, 439, 867, 976 160A 970 integer overflow detection 73 160G 970 MIPS (vendor) 73, 78, 86, 146, 216, 219, 220, 355, 391, 392, 817, 970 1S 948, 952 MIPS IV architecture 391 2000/213 970 MIPS RISC Architecture 73 210B 970 mistake 3000/400 976, 977 0x prefix dropped for zero values 878 386i 977 allowing machine epsilon constant to be a run-time value 785 6000 PPU 970 balanced parentheses in NaN strings 889 7/32 970 0 C89 does not specify 0 413 7030 Stretch 948, 949, 959, 969–971 C# has confusing names for floating-point limits 100 8/32 ix, 896, 948, 965, 970 differences in input and output type modifiers 908, 909 840A 970 exception flags may not be settable without causing the 1 305, 948, 949, 951–953, 965, 970, 971 exception 111 2 948, 952, 969, 970 exception flags overlap sign bit 109 3 976, 977 exception masks require bitwise-OR instead of addition 108 4 976, 977 failure of programming language standards to recognize IEEE 50 ix 754 Standard 914 85 948 FE_ALL_EXCEPT does not include all flags 109 86 948 fixed exponent size in formatted output 875 200 948 gcc does not support decimal complex arithmetic 442 250 970 global variables not thread safe 897 386 976 IEEE 754 subset in C# 918 418 970 inaccuracies in SOLARIS fmal() 388 470 963 inappropriate six-digit default precision in formatted output 490 970 853, 854, 857, 875 502 970 Subject index . . . M 1095

503 970 EL X1 970 520 970 EL X8 970 600 305, 947, 948, 958, 970 ESA/390 x, 1115 601 970 FP-6000 970 620 353 G-15 970 650 948 G-20 970 700 959 Gamma 60 970 704 353, 948, 959, 961, 963, 970, 971 GE 235 970 709 341, 353, 948 GE 435 970 803 970 GE 635 970 900 970 GIER 970 924 970 HIPAC 103 970 1000 970 HITAC 3030 970 1010 970 IAS 970 1100 74, 965, 966, 970, 972 III 970 1107 353 Illiac I 948, 970 1130 948, 970 Illiac II 948, 970 1400 970 Illiac III 948 1520 976 Illiac IV 947, 948 1604 948, 949, 970 Indigo-2 977 1650 353 Indigo-2 Extreme 976 1700 396, 949 Indy 976, 977 3000 949 JOHNNIAC 970 3090 976, 977 KD10 955 3200 970 KDF 9 948 3400 948 KDF9 970 3600 353, 520, 948, 949, 970 Lambda 970 6000 74, 80, 305, 948, 949, 970 Leo 3 970 6080 958 LEO I 970 6200 949 LGP-21 970 6400 949, 970, 989 LGP-30 970 6500 949 MADIC IIA 970 6600 949, 951 MADIC III 970 6700 949 MANIAC 970 7000 74, 80, 305, 948, 959, 970 Mark 1 970 7040 353, 948, 970 Mark I 970 7044 ix, 353, 948 Mark IIA 948, 965 7090 353, 520, 948, 954, 970, 971 Melcom 1101F 970 7094 353, 948 Model 1 463 7600 949 Model 4 463 8600 951 Model 5 463 9080 948, 970 NORC 970 ABC 970 NORD-1 970 Alto 954 NORD-5 970 ALWAC III-E 970 Nova 970 ASC 963 OKITAC 5090H 970 ASI 2100 970 ORDVAC 970 Atlas 948, 970 PDP 850 B1700 948, 969, 970, 977 PGM 948 B5000 970 Pilot ACE 970 B5700 305, 948 R1 948, 970 B6700 305, 948 R4000 976 B7700 305, 948 R4400 976 BCC-500 948 RECOMP II 970 BRLESC 970 RS/6000 86, 817, 976, 977 Cyber 949 RT 86 D21 970 SDS 940 970 DASK 970 Sigma 948, 970 DECstation 976, 977 STAR-100 951, 952 DIGIAC 3800 970 System 85/86 970 Dolphin 954 System/360 viii, ix, xxix, 68, 86, 104, 155, 241, 254, 287, 305, 353, Domain 948 361, 365, 375, 478, 761, 855, 947, 948, 951, 954, 956, 959, 963, Eclipse 970 964, 967, 969, 970, 978 Eclipse S/200 948 System/370 x, 964, 1115 EDSAC 353, 970 System/390 146, 217, 370 EDVAC 970 TR440 970 1096 Subject index . . . N

X-MP 948, 952, 970, 971 myspell program 1115 Y-MP 948, 952, 970 z/Architecture x, 1115 N Z1 970 NAG package 826 z13 928 name keyword 991 Z2 970 name mangling 981, 982 Z22 970 namelist package 1115 Z23 970 NAMELIST statement 909, 910 Z25 970 namespace (programming construct) 2, 920, 921 Z26 970 naming conventions 4 Z3 970 NaN xxxv, 1, 69, 70, 114, 115, 133, 135–137, 139–143, 147, 148, 150, z9 936 152, 153, 155, 234, 595, 607, 950, 956, see also Indefinite ZEBRA 970 Lawrence Livermore National Laboratory S-1 965 zSeries 930 pair-precision number 355, 364 Model 1 (model) 463 quiet and signaling (binary) 63, 64 Model 4 (model) 463 quiet and signaling (decimal) 930 Model 5 (model) 463 testing 80 Modern Computer Arithmetic 104 nanf.c file 944 modf.h header file 130 Nanodata (vendor) 963 modfx.h header file 130 NaNQ 79 modified Bessel function 718 NaNS 79 modified Lentz algorithm for continued fractions 18 Napier, John (1550–1617) 282 Modula language vii Napierian logarithm 282 module (programming construct) 2 National Institute of Standards and Technology see NIST module statement 991 National Physical Laboratory (vendor) 970 modulus (k) of elliptic integral function 625 National Semiconductor (vendor) 970 Moivre, Abraham de (1667–1754) 194 native keyword 979, 982 Moler, Cleve Barry 228 NATO mil 305 Møller, Ole 326, 353, 354, 358, 365, 366, 369, 384, 385 natural logarithm 282 Monaco 203 nawk program 1115 monetary calculation 102 NCR (vendor) 949 mono program 919 nearpi.c file 251 Mono Project viii, 917, 919–921 nearpi.dat file 251 Monte Carlo quadrature 202, 203 NEC (vendor) 952, 963 Moon 7 negation Moreira, José E. 353 safe integer 76 mortgage 296 zero 135, 885 Moshier, Stephen Lloyd Baluk 133, 567, 644, 811, 821–823 negative epsilon 63 Motorola (vendor) 65, 71, 86, 124, 145, 146, 150, 216, 217, 251, 292, negative zero 58, 64, 69–71, 85, 135, 139, 234, 463, 478, 520, 841, 293, 338, 352, 363, 395, 823, 959, 970, 976 875, 885, 950, 951, 956, 965, see also signed zero move instruction 478 in pair-precision arithmetic 366 mp_t data type 250, 251 Neptune (planet) 630 MPC package 825, 826 nested Weyl sequence 177 mpcheck package 825 NETBSD operating system x, 71, 131 MPFI package 826 NetRexx language viii, 928, 968 MPFR package 401, 825, 826 Neumann function 694, 695 system header file 402 Neumann, John von (1903–1957) 157, 190, 193, 202, 212 MPFR: The Multiple Precision Floating-Point Reliable Library 401, 407 Neville theta functions 678 mpfr_t data type 402 Neville, Eric Harold (1889–1961) 678 mpfun90 package 4 New Century Dictionary vii, 215, 243, 521, 593, 619, 979, 1049 MS-DOS operating system 954 New York Stock Exchange 977 msbis0.c file 771 Newton method see Newton–Raphson iteration Muller, Jean-Michel 82, 251, 256, 265 Newton, Isaac (1643–1727) 8 multicol package 1115 Newton–Raphson iteration 8–11, 44, 215–217, 232, 234, 237, 373, MULTICS operating system 956, 958 375, 377, 379, 384, 605, 607, 608, 619, 624, 745, 748, 750, 787, Multiflow (vendor) 952 789, 792, 794, 808, 953 multiple recursive congruential generator 176 double 23, 218 multiplication, safe integer 75 higher-order 604 multiplicative congruential generator 169 Newton–Raphson–Simpson method 8 multiplicative inverse 180 NeXT (vendor) 71 MuPAD language viii, x, 21, 269, 537, 548, 561, 569, 583, 694 nibble 969 mupad program 1115 nine’s-complement 263 musl package 825 NIST 178, 200, 826 MWC1038 177 libraries 826 myprog.exe file 920 Statistical Test Suite 200 myprog.exe.config file 920 nm program 981 Subject index . . . O 1097

Nobel Prize in Physics 475 one’s-complement arithmetic 74, 263, 949–951, 954, 972 noisy mode 960 one-norm 223, 480, 500 nome q in elliptic functions 668 one-time pad 204, 206–208 nonlinear equation 7 opaque data type 108, 116, 120, 982 solution 8, 9 opcode see instruction nop instruction 230 Open Group (vendor) x NORC (model) 970 OPENBSD operating system x, 71, 131, 459, 825, 842 NORD-1 (model) 970 OPENSOLARIS operating system x NORD-5 (model) 970 operating system norm 4.3BSD 237, 273, 290 Euclidean 113, 223 AIX xxxv, 71, 87, 109, 218, 233, 355, 816, 817 infinity 48, 223 ALPINE 825 one 223, 480 CP/M 954 p 223 DRAGONFLYBSD x two 223 DRAGORA 825 normal distribution 192, 194 FREEBSD viii, x, 71, 124, 131, 459, 825 function 610 GHOSTBSD x normalization requirement GNU x dropped in significance arithmetic 966 GNU/LINUX viii, x, xxxv, 71, 78, 87, 93, 109, 123, 125, 127, 131, relaxed for gradual underflow 78 216, 218, 220, 235, 238, 239, 370, 399, 401, 459, 696, 811, normalized number 62 813–815, 817, 819, 825, 833, 834, 911, 956, 967 Norsk Data (vendor) 970 HAIKU x Not a Number see NaN HARDENEDBSD x notation 987 HP-UX xxxv, 58, 71, 100, 101, 131, 218, 233, 355, 388, 765, 815, note (financial) 297 816, 834, 877 Nova (model) 970 HURD 825 null-pointer check 117–119, 135, 152 IRIX 78, 131, 153, 355, 817 nullification 824 MAC OS X x, 71, 109, 131, 399, 697, 818, 920, 982 numapprox package 28, 29, 32, 47, 52, 270, 724, 726 MACH 71, 131 number base 62 MACOS x number data type 907 MIDNIGHTBSD x number history 59 MINIX 92 number of leading zero bits 166 MS-DOS 954 number of one bits 166 MULTICS 956, 958 number of trailing zero bits 166 NETBSD x, 71, 131 numeric_limits class 106 OPENBSD x, 71, 131, 459, 825, 842 Numerical Computation Guide 105 OPENSOLARIS x Numerical Computing with IEEE Floating Point Arithmetic 103 OSF/1 xxxv, 71, 79, 123, 131, 147, 153, 305, 320, 697, 812, 956 numerical integration see quadrature PAC BSD x Numerical Methods for Special Functions 827 PCBSD x Numerical Recipes 19 POSIX xxxv, 60, 120, 162, 163, 561, 694, 700, 702, 719, 755, 825 Numerische Mathematik 476 REACTOS x numtest.pas file 994 SOLARIS 71, 99, 110, 122, 124, 125, 127, 131, 294, 304, 305, 320, nybble 928, 969 388, 399, 459, 528, 697, 819, 820, 834, 943, 946, 967, 979, 989 SOLARIS 10 124, 216, 218, 811, 818–822 O SOLARIS 8 821 Oberon language vii SYSTEM V 896 OCaml language vii TOPS-20 ix, 71, 131, 763, 849, 1115 octal TRUEOS x base 283 UNIX x conversion specifier 874 UNIX ix, x, xxxv, 3, 4, 60, 66, 70, 74, 87, 106, 124, 147, 207, 223, notation 850, 908, 949, 950, 953, 955, 977 224, 233, 237, 251, 273, 290, 362, 408, 557, 694, 697, 825, 827, number system 977 850, 870, 873, 896, 899, 905, 909, 916, 920, 941–944, 946, 956, octal number 972, 980, 982, 1115 input conversion 894 UNIX V3 896 output conversion 850 UNIX V6 131, 896 octet 969 UNIX V7 896 odd series 23 VMS 957 Ogita, Takeshi 385 WINDOWS x, 125, 917, 920, 954, 982 Oishi, Shin’ichi 385 Opteron (CPU) 339 okay file 919, 924, 990 option OKI Electric (vendor) 970 -Dvolatile= 66 OKITAC 5090H (model) 970 -G 980 oldest algorithm 181 -I xxxv OMZ see order-of-magnitude-zero -L xxxv, 946 On-Line Encyclopedia of Integer Sequences 568, 671 -O3 218 1098 Subject index . . . P

-R/usr/local/lib 944 integer 72, 149 -Wl,-rpath,/usr/local/lib 944 LCG computation 173 -autodbl 968 premature 101, 113, 343, 348, 350, 362, 363, 414, 415, 449, 451, -classpath 980 456, 466, 528, 532, 595, 619, 621, 622, 635, 691, 768, 778, 804, 883 -fno-builtin xxxv, 216 preventing integer 74 -fpwidetypes 100, 101 random-number generation 167 -ftrap 946 overflow exception flag 71, 71, 111, 114, 124, 415, 778, 887 -g 218 overloaded function name 981 -gnaty 913 Overton, Michael 67 -ieee xxxv OVF (on Lawrence Livermore National Laboratory S-1) 965 -ieee_with_inexact xxxv Oxford English Dictionary 979, 995 -lc 825 -lc128 xxxv P -lfdm 811 P-code 989 -lfmcw 946 p-norm 223 -lm xxxv, 320, 765, 811, 825 PA-RISC (CPU) 68, 71, 86, 101, 131, 216, 218, 219, 240, 370, 383, -lmcr 811 388, 392, 816, 970 -lmcw 765, 771, 946 PAC BSD operating system x -lmf 811 package -lsunmath 294 ACRITH 967 -lultim 811 amsfonts 1115 -mfp-rounding-mode=d xxxv amsmath 1115 -mieee xxxv ansi2knr 2 -mieee-conformant xxxv APMathLib 811, 820, 827 -mieee-with-inexact xxxv arprec 4 -qlongdouble xxxv array 1115 -trapuv 931, 951 authidx 1115 -unsafe 921 BeEF 774 AspectRatio (Mathematica) 37 calligra 1115 AxesLabel (Mathematica) 37 Cephes 133, 521, 583, 644, 708, 811, 821–823 BaseStyle (Mathematica) 37 chebfun 57 Bias (Mathematica) 34 color 1115 Brake (Mathematica) 34 colortbl 1115 Derivatives (Mathematica) 34 decNumber 218, 387, 402, 403, 433, 867, 897, 928, 930–932, 936 Filling (Mathematica) 37 Diehard Battery 200, 202 FillingStyle (Mathematica) 37 EISPACK 227, 228, 232 MaxIterations (Mathematica) 34–36 ELEFUNT 61, 96, 98–100, 216, 338–340, 342, 412, 430, 436, 438, PerformanceGoal (Mathematica) 37 439, 763–765, 769, 770, 773, 774, 776, 811–822, 940 PlotFlag (Mathematica) 34 elliptic 659 PlotRange (Mathematica) 37 extbook 1115 PlotStyle (Mathematica) 37 fdlibm 133, 153, 274, 325, 349, 352, 595, 597, 598, 811, 821, 824, PrintFlag (Mathematica) 34 825, 940 WorkingPrecision (Mathematica) 34, 39 features 69 orbital eccentricity of planets 630 FNLIB xxxi, 341, 352, 823 Order global variable 11, 21 fontenc 1115 order-of-magnitude-zero (OMZ) 960 fptest 775 ORDVAC (model) 970 FunctionApproximations 34 Oresme, Nicole (ca. 1323–1382) 541 glibc 133, 274, 825 orthogonal polynomial GMP 402, 433, 825, 994 books about 59 graphicx 1115 Chebyshev 44 GSL 825 products of sums 59 hhmm 1115 relation to continued fraction 59 java.lang.math 57 research literature 59 LAPACK 223 Orthogonal Polynomials and Continued Fractions 59 libmcr 811, 821, 824 orthopoly package 48, 52, 53 LINPACK 223, 228 OSF/1 operating system xxxv, 71, 79, 123, 131, 147, 153, 305, 320, luximono 1115 697, 812, 956 makeidx 1115 Othello 7 MathCW 57 out keyword 914, 921, 922 mathcw xii, xxv, xxxv, xxxvi, 1, 2, 4–6, 20, 25, 28, 29, 33, 38, 43, out-of-range conversion 44, 50, 55, 57–62, 64–66, 70, 71, 77, 79, 80, 84, 85, 87, 89, 95, 96, hardware behavior 131 101–107, 109, 116, 117, 120, 123, 124, 130, 133, 147, 152, 155, overflow 71, 105, 113–115, 130–132, 137, 139, 144, 145, 153, 824 156, 166, 183, 184, 188, 206, 208, 210, 216, 219, 220, 224, 233, Cray systems 953 237, 247, 250, 251, 254, 255, 257, 260, 271, 275, 277, 283, 284, Alpha processors xxxv 288–290, 292–294, 315, 331, 338–341, 345, 346, 351–353, 355, detection on MIPS (CPU) 73 356, 359, 363, 365–367, 370, 385, 386, 388, 391, 401–403, Subject index . . . P 1099

406–408, 410–412, 414, 418, 427, 429, 430, 432, 434, 438, negation 358 440–442, 451, 459, 463, 464, 466, 478, 479, 484, 489, 492, 497, overflow in splitting 362 512, 521, 522, 525–529, 531, 537, 542, 548, 550, 554, 555, 557, product sum 386 558, 561, 562, 572, 573, 578, 583, 590–592, 595–598, 605, 608, retrospective 407 614, 616, 619, 620, 625, 628, 631–633, 643, 645, 649, 651, 653, splitting 359 657, 659, 662, 667, 669, 671, 672, 674, 676, 678, 681, 682, 685, square root 373 688, 690, 693, 694, 707, 709, 716, 719, 724, 734, 738, 740, 755, subtraction 367 762–765, 767–769, 771, 776, 779, 792, 798, 808, 811–819, 826, sum 358 830, 831, 848, 853, 856, 865, 867, 868, 871, 873–879, 897, 899, vector sum 384 902, 905–907, 910, 911, 913–925, 928, 931–933, 936, 937, 939, paircw.h header file 355 940, 942, 943, 945–947, 954, 967, 978, 979, 982, 989–991, 993, Panthéon 802 1115 Parallels (vendor) viii mathpazo 1115 parameter (m) of elliptic integral function 625 mod-mathpazo 1115 paranoia package 773, 774 MPC 825, 826 PARI/GP language viii, 269, 537, 548, 561, 569, 583, 620, 685, 694 mpcheck 825 Paris, France 802 MPFI 826 pascal file 989 MPFR 401, 825, 826 Pascal interface 989 mpfun90 4 building 989 multicol 1115 programming 990 musl 825 using 993 NAG 826 Pascal language 2, 70, 74, 130, 223, 341, 411, 763, 829, 870, 879, 949, namelist 1115 989–994 numapprox 28, 29, 32, 47, 52, 270, 724, 726 mathematical-library deficiencies 223, 341 orthopoly 48, 52, 53 numeric programming 994 paranoia 773, 774 Pascal’s Triangle 576 pifont 1115 Pascal, Blaise (1623–1662) 972, 989 PORT xxxi, 341, 343, 352, 823 Pascaline calculator 972, 989 resize-mathcw 1115 Patashnik, Oren xi rgb 1115 Paxson, Vern Edward 851 Scalable Parallel Random Number Generators (SPRNG) 158 Payne, Mary H. 250, 253, 259, 265 simpson 606 pcbrtx.h header file 379 student 606 PCBSD operating system x T 48, 53 PCL language 954 TestU01 200, 214 pdflatex program 1115 tuftest 200–202 PDP (model) 850 UCBTEST 774 PDP-1 (CPU) 970 url 1115 PDP-10 (CPU) v, viii, ix, 71, 72, 77, 107, 131, 147, 216, 251, 256, 257, varioref 1115 262, 305, 478, 608, 761, 763, 848, 849, 855, 908, 928, 947, 948, vpa 4 951, 953–956, 958, 965, 966, 969–971, 977, 978, 1115 widecenter 1115 PDP-11 (CPU) viii, ix, 66, 224, 478, 761, 850, 908, 928, 948, 953, 956, package (programming construct) 2 957, 970, 971, 977 packed-decimal data type 928 undefined variable 956 Packed_Decimal data type 928 PDP-12 (CPU) 948 pad see one-time pad PDP-15 (CPU) 970 Padé approximation 33 PDP-2 (CPU) 970 Padé, Henri Eugène (1863–1953) 33 PDP-3 (CPU) 970 pair-precision PDP-4 (CPU) 970 absolute value 358 PDP-5 (CPU) 970 accuracy 379 PDP-6 (CPU) 948, 954, 970 addition 365 PDP-7 (CPU) 850, 956 arithmetic 353 PDP-8 (CPU) 970, 971 comparison 368 PDP-9 (CPU) 970 copy 357 Pearson, Karl (1857–1936) 197 cube root 377 pendulum period 627 design considerations 355 Pentium (CPU) 339 division 371 percent conversion specifier 873 dot product 385 perf.adb file 916 elementary functions 777 perf.java file 982 evaluation 357 PerformanceGoal option (Mathematica) 37 fused multiply-add 388 perimeter of ellipse 619, 630 high part 357 period initialization 356 pendulum 627 limitations 354 random-number generator 157 low part 357 Perl language vii multiplication 368 Perlis, Alan Jay (1922–1990) 941 1100 Subject index . . . P pgamma.hoc file 556 coefficient formatting 29 pgammx.h header file 556–558 coefficients in Cody/Waite book 32, 939 PGM (model) 948 coefficients of constant sign 24 phi (golden ratio, φ) history 14, 59, 577 complete elliptic functions 643, 644, 690 Philco (vendor) 970 computation with symbolic-algebra programs 4 Philosophiae Naturalis Principia Mathematica 8 conditions for exact quadrature 560 photometer 802 convention for rational degrees 31 ( 1 π ) PHP language vii cos 4 x 318 PI global variable 408, 409, 850, 851, 955 cos(x) 308, 310, 321, 323 pi (π) history 59 cotan(πx) 320 pifont package 1115 cotan(x) 310 Pike, Rob 6 deficiency of Cody/Waite fit to log(x) 287 Pilot ACE (model) 970 difficulty in pair-precision arithmetic 777, 794, 797, 808 Pisano, Leonardo (1175?–1250) 575, see also Fibonacci difficulty of minimax vs. Chebyshev fit 52 PL/1 language vii, 763, 927, 928 documenting and reproducing coefficients 939 plaintext 203, 204, 206 eliminating quadratic term in cubic 682 planets, orbital eccentricity 630 evaluation accuracy 89 PLATO computer-assisted instruction system 949 evaluation with fused multiply-add (fma) 88 Plauger, Phillip James “Bill” 133 evaluation with IBM 7030 Stretch multiply-and-add 960 PlotFlag option (Mathematica) 34 even distribution of errors in Chebyshev and minimax fits 48 PlotRange option (Mathematica) 37 exact coefficients 42 PlotStyle option (Mathematica) 37 exp(x) 26, 269, 270, 272 Pluto (planet) 630 explicit root formulas for degree < 57 Pochhammer symbol 752 expm1(x) 279 Poincaré’s Prize 60 factoring in Mathematica 752 pointer conversion specifier 874 failure to find with symbolic-algebra systems 28 Poisson distribution 195 fit in Maple 28, 32 Poisson equation 693 fit in Mathematica 33, 42 Poisson, Siméon-Dénis (1781–1840) 195 from Taylor series 7 polar form of complex number 443 Γ(1 + x) 527 polyfit.mth file 38, 42 Γ(x) 524 polyfma.map file 488 Γ(x) in asymptotic region 528 polygamma function 62, 537, 555, 556, 558 hiding degree in source code 89 polynomial Horner form 24, 32, 37, 49, 54, 89, 97, 221, 275, 277, 285, 318, 1/Γ(x) 767 500, 526, 686, 718, 741, 745, 748 Abel’s proof for roots 7 improvement in rational form 32 absolute error vs. relative error 33 improving evaluation accuracy 86 accuracy with increasing degree 34, 428, 437 integer coefficients 751, 754 adjustment of leading coefficient 33 inverse error function 604 approximate log(x) 832 large base 254 approximation 23 large errors near roots 708, 713 asin(x) 324 large-argument modified Bessel functions 724 atan(x) 332, 765 large-argument ordinary Bessel functions 716 atanh(x) 350 limitations of Cody/Waite 28 bit precision P in mathcw library 2 log(1 − d) 670 bivariate 475 log(x) 284, 286, 286, 288, 422, 426, 438, 440 cbrt(x) 237 log1p(x) 290 Chebyshev minimax 28, 32, 33 closed forms 43 minimax vs. Chebyshev 51, 52 coefficient sorting 47 monotonicity guarantee is hard 824 conversion to rational form 52,55 near zeros of log(Γ(x)) 532 definitions 48 notation conventions 987 economization 43, 58, 526, 535, 604, 703, 704, 707, 709, 713, number representation 978 715, 724 (nw − 1)/w in power function 437, 440 equal extrema 44 nw − 1 in power function 437 error compensation 50 nw in power function 423 evaluation 48 obscure origin of Cody/Waite coefficients 28, 43, 939 fit improvement 51 orthogonal 59 flexibility and generality 46 precision needed to find coefficients 28 forms 45 problem of finding optimal fits 31 numerical stability 48 rational 43 orthogonal 44 rational vs. single 32 plots 46 rational vs. single 52, 306, 323 recurrence relation 45, 48 refactoring to reduce operation counts 89 summation formula 43 relation to transcendental numbers 16 zeros 56 relations between elliptic integrals 645 Subject index . . . P 1101

relative error vs. absolute error 33 using 126 reliability of Horner form 89 PRECISION global variable 43 replacement by duplication rule for elliptic functions 649 premature replacement with Newton–Raphson iteration 808 job termination 104, 381, 950, 976 reverse engineering 43 overflow 101, 113, 343, 348, 350, 362, 363, 414, 415, 449, 451, 456, roots of cubic 682 466, 528, 532, 595, 619, 621, 622, 635, 691, 768, 778, 804, 883 roots of Weierstrass cubic 682 underflow 101, 113, 414, 415, 449, 451, 456, 466, 532, 595, 598, rsqrt(x) 234 619, 621, 622, 634, 691, 768, 778, 883, 940 scaling rational 24, 41, 215 present value of an annuity 295 sin(x) 306, 321, 323 preventing macro expansion 112 sinh(x) 343, 345 Priest, Douglas M. 385, 407 size of polygamma coefficient tables 557 prime number 170, 303, 590, 591, 967 sqrt(x) 215 history 60, 590, 591 symmetry with complex variable and real coefficients 447 relatively prime 170 table-driven algorithms 827 Princeton University (vendor) 970 tan(πx) 319 principal value 476 tan(x) 311 Principles of Operation 963, 964 tan(x) 47, 310 print statement 622 tanh(x) 343, 345 printf program 251 testing all fits 763 printf statement 78, 830, 850, 851, 950, 955 tiny leading coefficient 55 PrintFlag option (Mathematica) 34 two variables 475 println statement 849–851 Popov, Bogdan A. 604 prism 801 population count (number of one bits) 166 private keyword 981 PORT package xxxi, 341, 343, 352, 823 PRNG (pseudo-random-number generator) 157 Portable Fortran language 823 program Portable Operating System Interface (POSIX) Standard 441 acroread 1115 positive epsilon 63 authidx 1115 POSIX (IEEE Portable Operating System Interface Standard) 441 bc 362, 408, 409, 1115 POSIX operating system xxxv, 60, 120, 162, 163, 561, 694, 700, 702, bibtex 1115 719, 755, 825 build-all ix, 1115 PostScript language vii, 36, 105 c89 816 pow keyword 992 c99 818, 819, 822 POWER (CPU) 65, 86, 87, 109, 218, 219, 370, 391, 410, 816, 825, 970, cc xxxv, 388, 812, 815–817, 820, 821, 905 976, 1035 cc128 xxxv power function 411 chkdelim 1115 power of two chktex 1115 nearest above 166 col 1115 nearest below 166 command 954 power-law distributions 196 cppcheck 870 PowerPC (CPU) vii, 68, 71, 79, 87, 109, 131, 216, 219, 233, 240, 355, cscc 919 370, 388, 392, 399, 438, 439, 459, 818, 878, 927, 936, 970, 976, deroff 1115 1035 detex 1115 powx.h header file 411, 430 dgcc 681, 938 pr program 1115 distill 1115 Pr1me (vendor) 947, 948 dv2dt 1115 Practical Cryptography 168, 214 dvips 1115 pragma 110, 113, 114, 124 dw 1115 pragma statement 110, 914 egrep 880, 1115 prec.h header file 85, 135, 256, 529 emacs 2, 954, 1115 precision f2c 763 HP-UX on IA-64 xxxv f77 941, 942 historical architectures 948 gcc xxxv, 87, 101, 153, 216, 292, 338, 391, 392, 401, 442, 813, 814, IEEE 754 binary arithmetic 28, 97 817, 818, 821, 825, 826, 912 IEEE 754 decimal arithmetic 97 gnat 911, 915 wobbling 24, 25, 27, 104, 155, 215, 234, 254, 283, 290, 302, 316, gnatbind 912 324, 342, 343, 345, 375, 423, 427, 428, 437, 596, 617, 632, 700, gnatlink 912 704, 708, 718, 723, 755, 763, 785, 788, 804, 805, 896 gnatmake 911–913 precision control 105, 106, 108, 124 gnuplot 223, 1115 AMD64 124 gp 1115 EM64T 124 gpc 989, 990, 993, 994 access to 123 groff 1115 in hardware 124 gs 1115 mathcw library 124 gv 1115 missing 126 gzip 1115 no access in Ada 914 Hercules x, 1115 1102 Subject index . . . Q

hoc 1, 29, 78, 87, 696 Project Stretch 959 hoc128 408, 766, 1115 protected keyword 990, 992 hoc32 220, 850, 851, 1115 Provo, Utah 961 hoc36 107, 849, 955, 1115 ps2pdf program 1115 hoc64 622, 1115 psi function 521, 536 hoc72 1115 psi( ) function hoc80 78, 950, 1115 testing 768 hocd128 1115 psiln function 536 hocd32 1115 psiln( ) function hocd64 1115 testing 768 icc 87, 388, 442, 814, 815 psix.h header file 543, 555 ispell 1115 PSL language 954 its4 870 pspli.h header file 365 java 980 psqrtx.h header file 376 javac 979 PSW see Program Status Word javah 979 ptrdiff_t * data type 907 javald 980 ptrdiff_t data type 877, 907, 908 kermit 954 PUB language 954 lacheck 1115 public-key cryptography 203 latex 1115 Pure_Function keyword 915 lcc 3 purification of argument 97–99, 237, 239, 240, 339, 597, 766, 768, lint 870, 908 811 ls 912 pxy*.c file 430 make 771, 911, 912, 916, 919, 924, 943, 944, 979, 980, 989, 990, pxy*.h header file 427 993, 1115 pxy.h header file 438 makeindex 1115 pxyx.h header file 411, 429, 430, 433, 434 makeinfo 1115 Pyramid (vendor) 952 man2html 1115 pythagn.c file 233 man2texi 1115 Pythagoras of Samos (ca. 580–572 BCE to 500–490 BCE) 222 maple 10, 26–28, 251, 408, 602, 1115 Pythagoras’ Theorem 113, 222, see also e2norm(), see also hypot(), math 601, 1115 see also pythag() mathcw 847 history 59 matlab 228, 1115 Pythagorean Triples 222 maxima 1115 Python language vii mcs 919 mono 919 Q mupad 1115 QEMU (Quick EMUlator) hypervisor x myspell 1115 QEMU program 129, 1115 nawk 1115 QNaN (Quiet Not-a-Number) 79 nm 981 qp_t data type 255–257, 263–265 pdflatex 1115 quad data type 58, 101, 877 pr 1115 quad_pair data type 355 printf 251 quadratic ps2pdf 1115 congruential generator 176 QEMU 129, 1115 convergence 8 R 1115 equation discriminant (Kahan style) 472 ranlib 943 equation solution 465, 465, 467 rats 870 quadrature reduce 1115 conditions for exact 560 sage 1115 Gauss–Chebyshev rule 702 sed 251, 771, 1115 Gauss–Laguerre rule 560 sh 1115 Gauss–Legendre rule 702 SIMH ix, 1115 Monte Carlo rule 202, 203 size 557 Simpson’s rule 606, 607, 702, 722 sort 1115 standard rule 202 spell 1115 trapezoid rule 570 splint 870, 908 quadruple factorial 523 Splus 1115 quadword 969 strings 981 quantization in decimal arithmetic 931 test 912 quantum cryptographic generator 178 true 943 quartal notation 977 xdvi 1115 quarterword 969 program statement 993 quartic convergence 23, 215 Program Status Word (PSW) 964 quasi-Monte Carlo quadrature 203 programming conventions 2 quiet NaN 64, 79, 123 programming language see language arithmetic does not set exception flag 80, 123 Subject index . . . R 1103

R inversive congruential generator (ICG) 180 R language 601, 616, 659 lagged Fibonacci generator 176 R program 1115 LCG and MCG in double-precision floating-point arithmetic R1 (model) 948, 970 173 R10000 (CPU) 131, 220, 392, 817 LCG and MCG in long integer arithmetic 173 R2000 (CPU) 86 Monte Carlo quadrature 202 R3000 (CPU) 86 NIST Statistical Test Suite 200 R4000 (model) 976 other generators 176 R4400 (model) 976 period 157 R4400SC (CPU) 131, 817 AES generator 178 R5000 (CPU) 392 KISS generator 177, 208, 210 radian 299 lagged Fibonacci generator 176 radix 62 linear congruential generator 169–171 Ramanujan, Srinivasa (1887–1920) 619 Mersenne Twister generator 177 rancw_state_t data type 212 modulus dependent in LCG and MCG 170 RAND (vendor) 970 multiple recursive congruential generator 176 randcw.h header file 209, 211 multiplicative congruential generator 169 randcw_state_t data type 211 multiply-with-carry (MCW1038) generator 177 random number 157, see also cryptography quadratic congruential generator 176 applications 202 Tausworthe generator 177 arithmetic pitfalls 157 XOR-shift generator 177 C89 generator 162 portability issues 163 chi-square test 197 POSIX Standard generator 162 combined generator 177 quantum cryptographic generator 178 add-with-carry 177 range 157 KISS 177 exponential distribution 190 Mersenne Twister 177 KISS generator 177, 208 multiply-with-carry (MCW1038) 177 linear congruential generator 169 subtract-with-borrow 177 logarithmic distribution 191 congruential generator lrand48() 162 computing 171 Mersenne Twister generator 177 deficiencies 170 multiplicative congruential generator 169 faster 174 multiply-with-carry (MCW1038) generator unspecified 177 linear (LCG) 169 normal distribution 194 lrand48() 162 rand() 162 multiple recursive 176 Tausworthe generator 177 multiplicative (MCG) 169 XOR-shift generator 177 quadratic 176 removing generator bias 178 cryptographic generator 178 routines in mathcw library 208 demonstration of Central Limit Theorem 196 seed denial-of-service attack against generator 207 access 157 Diehard Battery test suite 200 creation 158 distribution 189 shuffled nested Weyl sequence generator 177 continuous and discrete 195 software guidelines 157 exponential 189 Tausworthe generator 177 logarithmic 190 test suites 200 normal 192, 194 testing uniform 189 nonuniform generator 202 endpoint conventions 160 uniform generator 196 floating-point values 160 TestU01 suite 200 from Advanced Encryption Standard (AES) 178 tuftest suite 200 from cryptographic hardware accelerators 207 Weyl sequence generator 177 from /dev/random and /dev/urandom 207 Wichmann–Hill generator 177 from Secure Hash Algorithm (SHA-n) 178 XOR-shift generator 176 further reading 214 random numbers gcd relation 180 distribution generation 169 Gaussian 196 Gorilla test 200 Random Numbers Fall Mainly in the Planes 170 historical generator deficiencies 214 randu() test results 201 importance of long periods 179 range of random-number generator 157 improving a generator 178 ranlib program 943 infinite period generator 177 Raphson, Joseph (1648–1715) 8 integers rational number 62 ascending order 168 rational polynomial 43, see also polynomial from floating-point generator 165 rats program 870 from integer generator 166 Raytheon (vendor) 970 1104 Subject index . . . R

RCA (vendor) 963, 970 relative error see also machine epsilon, see also ulp (unit in the last REACTOS operating system x place) READ INPUT TAPE statement 962 computation 99 READ statement 904, 962 subtle bugs in computation 99, 940 READ TAPE statement 962 relatively prime 170 REAL (SELECTED_REAL_KIND(75)) data type 4 remainder 143 REAL data type 941, 948, 949, 962 base other than two 155 Real data type 990 computing one from another 152 REAL*16 data type 941 difficulty of computing 144 REAL*32 data type 4, 64 safe integer 76 REAL*4 data type 941 remqu.h header file 152 REAL*8 data type 941 reserved operand (VAX) 478, 948, 956, 957 reciprocal square root 233 resize-mathcw package 1115 almost-correct rounding 235 restrict keyword 868, 868, 871, 873, 901, 903, 904 improved rounding 234 Retrospective: How to Print Floating-Point Numbers Accurately 879 in hardware 240 return instruction 443 RECOMP II (model) 970 return statement 192, 711, 925, 944, 983 recurrence relation Revere, Paul (1734–1818) 206, 207 Bernoulli numbers 571, 572 Revolution, American 206 Bessel auxiliary P(ν, x) 698 Rexx language vii, viii, 928, 968 Bessel auxiliary Q(ν, x) 698 RFC 4086 214 rgb package 1115 Chebyshev Tn(u) 45 continued fraction 12 Riccati, Jacopo (1676–1754) 695 Euler numbers 573, 574 Riccati–Bessel function 695 Rice Institute (vendor) 948, 970 expansion of i1(z) 748 Rice, John Rischard 31 expansion of In(z) 723 Riemann Hypothesis 60, 303, 303, 521, 579, 590 expansion of in(z) 744, 752 Riemann sphere 460 expansion of is (z) 750 1 Riemann zeta function 57, 303, 542, 579, 826, 988 expansion of is (z) 747, 754 n computing 583 expansion of J (z) 703 n Greek relatives 587 expansion of j (z) 737 n relation to Catalan’s constant 587 expansion of K (z) 723 n Riemann zeta numbers 551 expansion of y (z) 737 n Riemann, Georg Friedrich Bernhard (1826–1866) 303, 521, 542, Fibonacci numbers 576, 576, 578 551, 579, 619 Γ(z + n) 522, 535 biography 59, 579, 590 Γ(z) 522, 524, 527, 539, 545, 566, 594, 766 RISC (Reduced Instruction Set Computer) processor 73, 85, 86, In(z) 720, 721, 729, 755, 759–761 ( ) 146, 148, 824, 952, 956, 974 in z 733, 734, 750, 753 rising factorial function 752 incomplete gamma G(a, x) 561, 563 ( ) Ritchie, Dennis MacAlistair (1941–2011) 2, 3 incomplete gamma g a, x 561 rndcb1.c file 238–240 ( ) J0 z 705 rndcb2.c file 240 ( ) Jn z 700, 701, 706, 710, 712, 717, 755, 759, 761 rndoff.c file 161 ( ) jn z 733, 738, 761 rndrs1.c file 235, 237 ( ) Kn z 720, 729, 755 rndrs2.c file 237 ( ) kn z 733, 754 rndsq1.c file 216, 220 |Γ( )| log z 766, 767 rndsq3.c file 217, 220 ψ(n)( ) polygamma x 552, 556, 557, 560 rndsq4.c file 217, 220 ψ( ± ) x n 546 rndsq5.c file 217, 220 ψ( ) x 539, 543, 544 rndsq6.c file 217, 220 ( ) psiln x 547 Rockett, Andrew Mansfield 12 ( ) sbin n, x 750, 753 Romeo and Juliet 987 sbkn(n, x) 755 ROMP (CPU) 86 tangent numbers 575 root 215 ( ) Yn z 700, 701, 716, 755, 761 cube 237 ( ) yn z 733, 739, 761 hardware instructions 240 Redheffer, Raymond Moos (1921–2005) 194 nonlinear equation 8, 9 REDUCE language viii, 28, 269, 537, 548, 569, 573, 620, 625, 628, quadratic equation 7, 465 659, 674, 694, 954 reciprocal square 233 reduce program 1115 square 215 reduction see argument reduction rounding 66 ref keyword 921 7030 Stretch 960 reflecting telescope 801 bit 67, 68, 882, 987 register 13 CDC systems 951 Regnecentralen (vendor) 970 control regularized incomplete gamma function 595 access 107 Subject index . . . S 1105

using 115 Scientific Subroutine Package 171 direction 67, 105, 108, 111, 115, 123, 124, 129, 132, 138, 139, 142 scpi4.h header file 318 extension for decimal 109, 927, 936 Scribe language 954 error in Cray divide 953 SDL language 977 function 137–139 SDS 940 (model) 970 IEEE 754 132, 967 sealed keyword 920 importance 968 secant 299, 300, 569 interval arithmetic 967 secant method 8 modes and integer conversion 132 second-order Taylor-series approximation 9 no access in Ada 914 Secrets and Lies 214 PDP-10 955 Secure Hash Algorithm (SHA-n) 178 peculiarity 848, 955 sed program 251, 771, 1115 S-1 965 seed of random-number generator 157 square root 216 Seki Kowa, Takakazu (1642–1708) 568 System/360 964 SEL Systems (vendor) 948, 970 System/370 964 self-correcting iteration 8 taxman’s 109 Sequent (vendor) 952 rphx.h header file 308 series see asymptotic series, see Taylor series rpx.h header file 306 series inversion 20 RS/6000 (model) 86, 817, 976, 977 seterr.h header file 96 RT (model) 86 system header file 91 Ruby language vii, 923 sexagesimal (base-60) number system 299 Rump, Siegfried M. 385 SGI see Silicon Graphics Runge, Carl David Tolmé (1856–1927) 969 SGI (vendor) 153 Russell, Bertrand Arthur William (1872–1970) 23 sh program 1115 Rust language vii SHA-n see Secure Hash Algorithm Ryad (vendor) 963 Shakespeare, William (ca. 1564–1616) 7, 215, 341, 411, 777, 987 Shannon, Claude Elwood (1916–2001) 969 S shared library xxxvi, 4, 911, 943, 944, 979, 980, 982 S-1 (CPU) 305, 463, 948, 965, 966 recording location 944 S-floating 956 shchx.h header file 348 S-Plus language 601, 616 Shepherd, Simon J. 606 safe integer arithmetic short int * data type 907 absolute value 74 short int data type 74, 116, 131, 829, 877, 907, 941, 990 addition 75 ShortInt data type 990 division 75 ShortReal data type 990 multiplication 75 shuffled nested Weyl sequence generator 177 negation 76 SIAM Journal on Mathematical Analysis 693 remainder 76 Siemens (vendor) 963 retrospective 77 Sigler, Laurence E. 575 subtraction 76 Sigma (model) 948, 970 Sage language 269 sign-magnitude integer 69, 74, 971 sage program 1115 system header file 90 SAIL language 954 signaling NaN 64 Saturn (planet) 630 arithmetic sets exception flag 80 sbinx.h header file 753, 754 signature sbis0x.h header file 747 digital cryptographic 204 sbis1x.h header file 750 function arguments 923, 981, 982 sbisnx.h header file 754 signed char * data type 874, 907 sbj1taylor.map file 740 signed char data type 257, 941, 990 sbj1x.h header file 738 signed zero 69, 104, 147, 527, 974, see also negative zero sbk0x.h header file 755 arc tangent argument 70 sbk1x.h header file 755 constant 69 sbknx.h header file 755 correct argument handling 622 sbks0x.h header file 755 creating 135, 975 sbks1x.h header file 755 detecting 69, 975 sbksnx.h header file 755 faulty compiler handling 135 sby1taylor.map file 740 older architectures 69 Scalable Parallel Random Number Generators (SPRNG) package pair-precision number 355, 364 158 power-function argument 412 scaled complementary error function 598 preserving 69 Scheme language vii problems in complex arithmetic 478 Schonfelder, Lawrie 4 signgam global variable 521, 534 Schryer, Norman L. 958 significance arithmetic 960, 966, 1017 Schrödinger, Erwin Rudolf Josef Alexander (1887–1961) 475 significance loss 89, 306, 342, 345, 348, 379, 437, 539, 595, 638, 641, Scientific Data (vendor) 970 767 1106 Subject index . . . S

detected by noisy mode 960 nonlinear equation 8, 9 in Bessel functions 712 quadratic equation 465 in complex arithmetic 449, 456 Solving a Quadratic Equation on a Computer 465 in gradual underflow 64 sort program 1115 in hexadecimal base 302 sorted random integers 168 in significance arithmetic 960 source_t data type 902, 904 significand 2, 63 Sources and Development of Mathematical Software 958 extraction 148, 155, 284, 769, 837, 937, 944, 981, 992 SPARC (CPU) 68, 71, 86, 99, 109, 122, 129, 131, 216, 218, 240, 242, hidden bit 63, 64, 67, 78, 956, 957, 965 383, 388, 392, 399, 439, 459, 697, 811, 818–821, 824, 867, 953, Infinity 63 956, 967, 970, 976, 990 NaN 63 SPELL language 954 Silicon Graphics (vendor) 71, 78, 355, 817, 976, 977 spell program 1115 SIMH program ix, 1115 spherical Bessel function see Bessel function simple continued fraction 13 splint program 870, 908 simpson package 606 split-base.map file 708 Simpson’s rule quadrature 606, 702, 722 split.map file 408 Simpson, Thomas (1710–1761) 8 split_t data type 396 Simson, Robert (1687–1768) 577 splitting floating-point number simulator see virtual machine conditions for exact representation 361 Simulink language 228 constants in symbolic-algebra system 408 sine 299 correctness proof 361 argument in degrees 313, 314 danger of higher intermediate precision 362 argument in units of fl(2π) 304 fraction and exponent 133 argument in units of π 315, 316 pair sums 359 argument reduction 304, 308 premature overflow 362 computing 306 product into pair sum 434 computing with cosine 320, 339 product of integer and power of base 253 definition 299 sum of exact high and approximate low parts 236, 318, 387, derivative 301 435, 708 error magnification 309 sum of exact rational and approximate correction 246, 279 identities for testing 301, 339 sum of integer and fractional parts 130, 132, 245, 286, 315, 781, in hardware 338 795 inverse 323 sunlight into separate colors 801 1 π of 2 304, 306 three-part sum 781 of angle sum 300 Splus program 1115 properties 299 sprintf statement 830 range of 299 sqrt.c file 3, 4 Taylor series 302 sqrt.h header file 3 Taylor series of inverse 323 sqrtf.c file 3, 4 Single class 100 sqrtl.c file 3, 4 SINGLE data type 962 sqrtx.h header file 3, 4, 87, 96, 219, 241 Single data type 990 square root 215 sinhx.h header file 348 correct rounding 217 sink_t data type 871, 902 IEEE 754 conventions 373 sinpix.h header file 318, 531 in hardware 240 sinx.h header file 309 reciprocal 233 six sigma (phrase in advertising) 616 almost-correct rounding 235 size program 557 improved rounding 234 size_t * data type 907 in hardware 240 size_t data type 257, 846, 872, 877, 907, 908 rounding considerations 216 sizeof keyword 50, 58, 159, 256, 257, 419, 846, 847, 854, 855, 858, Stallman, Richard Matthew 825 862, 863, 889, 907 standard deviation 194, 382–384, 681 Smalltalk language 954 Stanford University xi, 85, 952 Smith, Roger 251 STAR-100 (model) 951, 952 SNaN (Signaling Not-a-Number) 79 Stardent (vendor) 952, 976 software statement origin of word 969 break 219, 240, 264, 416, 566, 783, 842, 881 pipelining 241 case 416, 789, 873, 904, 940 Software Manual for the Elementary Functions viii, 763, 823 catch 90, 830, 918 Sokolnikoff, Ivan Stephen (1901–1976) 194 default 41, 419, 894 SOLARIS 10 operating system 124, 216, 218, 811, 818–822 DIMENSION 962 SOLARIS 8 operating system 821 else 135, 148, 240, 275, 276, 338, 373, 378, 384, 397, 398, 785, 842 SOLARIS operating system 71, 99, 110, 122, 124, 125, 127, 131, 294, EQUIVALENCE 962 304, 305, 320, 388, 399, 459, 528, 697, 819, 820, 834, 943, 946, export 991 967, 979, 989 external 991 solution FORMAT 829 Subject index . . . S 1107

FREQUENCY 962 C# 918 GO TO 962 IEEE 754 78 goto 2, 184 minimum 602 if 69, 85, 139, 140, 147, 150, 240, 260, 373, 395, 397, 399, 402, 413, Silicon Graphics IRIX 817 453, 562, 893, 940 testing for 78 import 993 subnormal exception flag 108, 123, 124 module 991 subtraction NAMELIST 909, 910 loss 144 pragma 110, 914 safe integer 76 print 622 sum-prime notation 46, 50 printf 78, 830, 850, 851, 950, 955 summation println 849–851 accurate with error estimate 275, 279, 281, 286, 289, 309, 347, program 993 455 READ 904, 962 exact 385 READ INPUT TAPE 962 Sun (vendor) 824 READ TAPE 962 Sun libraries 824 return 192, 711, 925, 944, 983 Sun Microsystems (vendor) viii, 71, 86, 99, 110, 124, 133, 153, 218, sprintf 830 274, 294, 304, 325, 349, 383, 388, 528, 595, 811, 818–822, 824, struct 441 967, 970, 973, 976, 977, 979, 989 switch 41, 309, 331, 416, 417, 419, 691, 873, 894, 904, 940 supercomputer 68, 949, 969, 974 throw 90, 830 Superset (vendor) 948 try 90, 830, 918 Supertek (vendor) 952 typedef 2, 101, 102, 159, 209, 442 Supnik, Robert ix union 829, 934 switch statement 41, 309, 331, 416, 417, 419, 691, 873, 894, 904, 940 use 915 Symbolics (vendor) 970 using 920, 924 symmetry relations with 915, 916 Bateman function 555 static keyword 3, 174, 396, 402, 439, 841, 853, 866 Carlson elliptic functions 645 static library 911 complementary inverse error function 608 Statistics on the Table 194 complex argument function 495 STC (vendor) 970 complex arithmetic operations 446 system header file 868, 870, 871, 901 complex conjugation 446 system header file 453 complex cube root 485 system header file 3, 131, 257 complex division 453 system header file 260, 978 complex exponential 488 system header file 92–95, 101, 868, 870, 902, 905 complex function of single variable 446 system header file 92, 94, 95, 100, 101, 163, 905 complex logarithm 495 Steed algorithm for continued fractions 17 complex polynomial with real coefficients 447 Steed, J. W. 17 complex square root 480 Stellar (vendor) 952 cosine 299, 316, 796 sticky bit 67, 67, 68, 882, 987 cylindrical Bessel function In(x) 719 sticky exception flag see exception flag cylindrical Bessel function Jn(x) 697 Stigler, Stephen Mack 194 cylindrical Bessel function Kn(x) 719 Stirling’s approximation for factorial of large numbers 525 cylindrical Bessel function Yn(x) 697 Stirling’s series 525 elliptic function E 628 Stirling, James (1692–1770) 525, 631 elliptic function F 624 stock (financial) 297 elliptic function K 632 stock market growth rate 297 elliptic nome q 668 storage precision 65, 133, 135, 139, 146 error function 593, 769 store instruction 960 exponential function 342 store root instruction 960 Fibonacci numbers 576 store rounded instruction 960 floating-point numbers 63 store.h header file 365 gamma function 522 Strecok, Anthony J. 603–605, 607 gcd and lcm 183 string conversion specifier 874 hyperbolic cosine 341, 512 String data type 981, 983 hyperbolic sine 341, 512 system header file 93 hyperbolic tangent 273, 341, 512 strings program 981 integer numbers 74 struct statement 441 inverse cosine 323, 504, 803 Structured Programming 947 inverse elliptic functions 667 Struve function 695 inverse error function 608 Struve, Karl Hermann (1854–1920) 695 inverse hyperbolic functions 504, 517 student package 606 inverse sine 323, 504, 803 Student’s t distribution 195 inverse tangent 331, 504, 803 subnormal 78, 100, 153, 154, 607, 940, see also MAXSUBNORMAL, Jacobian elliptic functions 659, 680 MINSUBNORMAL Jacobian theta functions 673 1108 Subject index . . . T

psi function 541, 768 argument in units of π 315, 318 remainder functions 144 argument reduction 304, 310 rounding direction 845 computing 310 sine 299, 316, 531, 796 continued fraction 17 spherical Bessel function i0(x) 744 definition 299, 299, 302 spherical Bessel function i1(x) 748 derivative 303 spherical Bessel function in(x) 732, 738 error magnification 310 spherical Bessel function isn(x) 749, 753 identities for testing 340 spherical Bessel function jn(x) 732, 738 in hardware 338 spherical Bessel function kn(x) 738 inverse 331 spherical Bessel function yn(x) 732, 738 inverse with two arguments 336 1 π tangent 302, 319, 545 of 2 303 Weierstrass elliptic function 683 of angle sum 302 Weierstrass sigma function 686 properties 302 Weierstrass zeta function 686 range of 299 zeta function 579 Taylor series 303 sys_errlist global variable 94 Taylor series of reciprocal 303 sys_nerr global variable 94 tangent numbers 575 System 85/86 (model) 970 tanhx.h header file 805 system header file see also file, see also header file tanpix.h header file 319, 545 3 tanx.h header file 313 441 tapered arithmetic 966 441, 442 tatanh.c file 99 xxxiii, 103, 252, 936, 937 Tausworthe generator 177 3, 91, 93, 94 taxman’s rounding 109 107–109, 113, 116, 120 Taylor series 7, 8–13, 17, 23, 25, 27, 58, 69, 79, 96–99, 126, 217, 221, 3, 62, 82, 100, 135, 252, 527, 598, 769, 785, 855, 859, 267, 270, 272–275, 277, 279, 281, 284, 285, 288, 290–292, 306, 867, 936, 994 309, 310, 321, 323, 324, 331, 332, 340, 342, 343, 345, 347, 535, 125 544, 563, 584, 594, 596, 602, 608, 609, 615, 637, 638, 640, 641, 402 644, 707, 712, 713, 716, 725, 735, 736, 744, 745, 747, 748, 750, 983 752–754, 758, 761, 766, 768, 769, 777, 780–782, 785, 787, 789, 3, 94, 130, 152, 159, 260, 994 √ 792–794, 797, 800–804, 808 xxxv, 2, 50, 57, 82, 91, 92, 94, 95, 100, 101, 108, 120, √1 − z2 507 130, 223, 336, 411, 816, 905 1 + r 224 402 arccosine function 11 91 arcsin function 11 90 arctangent function 11 868, 870, 871, 901 i0(x) 744 453 i1(x) 748 3, 131, 257 in(x) 752 260, 978 Iν(x) 722 92–95, 101, 868, 870, 902, 905 is0(x) 747 92, 94, 95, 100, 101, 163, 905 is1(x) 750 93 isn(x) 753 159 J0(x) 716 159 j1(x) 740 871 Jn(x) 702 SYSTEM V operating system 896 jn(x) 736 System/360 (model) viii, ix, xxix, 68, 86, 104, 155, 241, 254, 287, Jν(x) 702 305, 353, 361, 365, 375, 478, 761, 855, 947, 948, 951, 954, 956, k0(x) 754 959, 963, 964, 967, 969, 970, 978 k1(x) 754 System/370 (model) x, 964, 1115 Kn(x) 722 System/390 (model) 146, 217, 370 y1(x) 740 Systems Concepts (vendor) 954 Yn(x) 703 Szüsz, Peter 12 yn(x) 736 beta function 587 T coefficients 766, 768 Tn(u) (Chebyshev polynomial) 43, 43, 45 combined sine and cosine functions 321 T2n+1 (tangent number) 575 complementary error function 594 T package 48, 53 complex functions 447, 479 T-floating 956 convergence for Bessel in(x) 753 tail recursion 181 cosecant function 569 Tang, Ping Tak Peter 271, 827 cosine function 11, 302, 664 tangent 302 angle sum 310 argument in degrees 313 cotangent function 11, 569 argument in units of fl(π) 304 cube root function 238 Subject index . . . T 1109

cutoff 98 test00.pas file 991 elliptic integral functions 626, 629, 631 test01.cc file 925 elliptic modulus function 668 test01.pas file 991 elliptic nome functions 668 test02.cc file 925 error function 594 test02.pas file 991 evaluation 97, 768 test03.cc file 925 even series 25 test03.pas file 991 exponential function 10, 347 test05.pas file 993 exponential minus one expm1(x) 488 testing first-order approximation 8 erf( ) function 768 gamma function 524 erfc( ) function 768 general series 25 function implementations 96 hyperbolic cosecant function 569 lgamma( ) function 765 hyperbolic cosine function 11 library 763 hyperbolic cotangent function 569 nonuniform generator 202 hyperbolic secant function 572 psi( ) function 768 hyperbolic sine function 11 psiln( ) function 768 hyperbolic tangent function 11, 569 tgamma( ) function 765 hypotenuse function hypot() 225 uniform generator 196, 200 inverse complementary error function 603 TestU01 package 200, 214 inverse error function 602, 604 TEX 954 inverse hyperbolic functions 348 mishandling of integer overflow 73 Jacobian elliptic integrals 660, 661 TEX User Group xi log-gamma function 524 Texas Instruments (vendor) 963 logarithm function 10, 12 tfrexp.c file 769 logarithm log(x) 292 tgamm.h header file 527 logarithm of trigonometric cosine function 569 tgammx.h header file 525, 528, 529, 531, 534, 535 logarithm of trigonometric sine function 569 tgcd.c file 184 logarithm of trigonometric tangent function 569 The 8087 Primer 104 logarithm plus one log(1 + z) 498 The Art of Computer Programming 182, 184, 214 ( + ) logarithm-base-2 plus one log2 1 x 292 The C++ Standard Template Library 827 ( ) logn g/a 426, 429 The Calculus Wars 8 nw − 1 437 The Code Book 214 odd series 23 The Columbia Encyclopedia 441 reciprocal square root function 234 The Cult of Statistical Significance 196 Riemann zeta function 581 The Design of a Pascal Compiler 949 second-order approximation 9, 465 The Emperor’s Old Clothes 963 sine function 10, 302 The Equation That Couldn’t Be Solved 7 angle sum 310 The Fibonacci Quarterly 576 square root function 10 The Golden Ratio 8 subnormal arguments 79 The Lottery Book 297 tangent function 11, 303, 569, 574 The Mythical Man Month 963 angle sum 310 The New Hacker’s Dictionary 1049 term recurrence for asin(x) 803 The Practice of Programming 6 test of gamma function 766 The Standard C Library 827 trigonometric secant function 572 The Widespread Misinterpretation of p-Values as Error Probabilities 196 Taylor, Brook (1685–1731) 7, 801 Theta function (Jacobian) 679 Tcl language vii theta functions tcmul2.c file 459 Jacobian 673 tcmul3.c file 459 Neville 678 Technical Corrigendum 2 (2005) 144, 857 Thinking Machines (vendor) 952 Telefunken (vendor) 970 Thompson, Ken 956 template expansion 925 Thompson, William Jackson 595 terf.c file 768, 769 Thomson function 695 terfc.c file 768, 769 Thomson, William (Lord Kelvin) (1824–1907) 695 test thread NaN 80 access lock on shared variable 160 negative zero 841 definition 107 subnormal 78 global-variable problem 95, 132, 522, 897 Test Drive Laboratory at Hewlett–Packard ix internal state problem 211 test program 912 internal static buffer access problem 830, 853, 866 test*.cs file 919 rounding mode control problem 845 test*.pas file 989 trap-handler problem 107 test-* file 765, 769 throw statement 90, 830 test.adb file 912, 915 system header file 159 test.ali file 912 timred*.c file 265 1110 Subject index . . . T

Tiny Encryption Algorithm (TEA) 178 IEEE Micro 104 title of publication IEEE Transactions on Circuits and Systems 104 A Mathematical History of Golden Number 8 IEEE Transactions on Computers 104 A Short Account of the History of Mathematics 927 In Code 208 A Treatise on the Theory of Bessel Functions 693 Is Floating Point Really This Complicated? 947 Accuracy of Floating Point Arithmetic 366 Jacobian Elliptic Functions 678 ACM Algorithm 116 451, 452 Journal of Computational Physics 214, 693 ACM Collected Algorithms 583 Khoey Ho Tum Kahan 341 ACM Transactions on Mathematical Software 214 Leonhardi Euleri opera omnia 591 ACM Transactions on Mathematical Software (TOMS) 475, 583 Liber Abaci 575 ACM Transactions on Modeling and Computer Simulation 214 MacBeth 777 Ada 95 Reference Manual 914 Mathematical Methods for Physicists 8 Algorithms + Data Structures = Programs 3 Mathematics of Computation 476, 693 An Atlas of Functions 657 Mathematics of Physics and Modern Engineering 194 An Urchin in the Storm 1065 MathWorld 465, 569, 572, 576, 587, 591 Analytic Theory of Continued Fractions 19 Minimizing q × m − n 251 Anomalies in the IBM ACRITH Package 967 MIPS RISC Architecture 73 Applied Cryptography 214 Modern Computer Arithmetic 104 Applied Statistics 214, 583 MPFR: The Multiple Precision Floating-Point Reliable Library 401, Approximations for Digital Computers 827 407 Asymptotics and Special Functions 19 New Century Dictionary vii, 215, 243, 521, 593, 619, 979, 1049 Bernoulli Number 569 Numerical Computation Guide 105 Binary Floating-Point Arithmetic for Microprocessor Systems 133 Numerical Computing with IEEE Floating Point Arithmetic 103 Birds and Frogs (2008 AMS Einstein Lecture) 475 Numerical Methods for Special Functions 827 BIT 476 Numerical Recipes 19 Branch Cuts for Complex Elementary Functions or Much Ado About Numerische Mathematik 476 Nothing’s Sign Bit 476 On-Line Encyclopedia of Integer Sequences 568, 671 C Mathematical Function Handbook 827 Orthogonal Polynomials and Continued Fractions 59 C9X Rationale 223 Othello 7 Calculating Instruments & Machines 829 Oxford English Dictionary 979, 995 Common Lisp — The Language 476 Philosophiae Naturalis Principia Mathematica 8 Computational Aspects of Three-Term Recurrence Relations 693 Portable Operating System Interface (POSIX) Standard 441 Computer Approximations 827 Practical Cryptography 168, 214 Computer Architecture: Concepts and Evolution 104, 947, 978 Principles of Operation 963, 964 Computer Arithmetic II 966 Random Numbers Fall Mainly in the Planes 170 Computer Physics Communications 214, 693 Retrospective: How to Print Floating-Point Numbers Accurately 879 Conference on Computer Arithmetic 104 RFC 4086 214 Coriolanus 411 Romeo and Juliet 987 Cray 1 Computer System Hardware Reference Manual 952 Scientific Subroutine Package 171 Cryptography Engineering 214 Secrets and Lies 214 Cryptologia 214 SIAM Journal on Mathematical Analysis 693 Cymbeline 215 Software Manual for the Elementary Functions viii, 763, 823 Determination of Correct Floating-Point Model Parameters 958 Solving a Quadratic Equation on a Computer 465 Dictionnaire historique de la Suisse 568 Sources and Development of Mathematical Software 958 Digital Computer User’s Handbook 947, 978 Statistics on the Table 194 e: The Story of a Number 269 Structured Programming 947 Explication de l’Arithmétique Binaire 969 The 8087 Primer 104 Fibonacci’s Liber Abaci: A Translation into Modern English of The Art of Computer Programming 182, 184, 214 Leonardo Pisano’s Book of Calculation 575 The C++ Standard Template Library 827 Floating Point Computation 948 The Calculus Wars 8 FORTRAN Automatic Coding System for the IBM 704 EDPM 959 The Code Book 214 Fortran Version 3A/B Reference Manual 949 The Columbia Encyclopedia 441 Fun with Fibonacci 578, 978 The Cult of Statistical Significance 196 GNU MP: The GNU Multiple Precision Arithmetic Library 401, 407 The Design of a Pascal Compiler 949 GNU Scientific Library 583, 694, 825 The Emperor’s Old Clothes 963 Go To Statement Considered Harmful 962 The Equation That Couldn’t Be Solved 7 Good Ideas, Through the Looking Glass 959 The Fibonacci Quarterly 576 Hacker’s Delight 166, 176, 978 The Golden Ratio 8 Handbook of Continued Fractions for Special Functions 19, 827 The Lottery Book 297 Handbook of Elliptic Integrals 667, 682 The Mythical Man Month 963 Handbook of Floating-Point Arithmetic 104 The New Hacker’s Dictionary 1049 Handbook of Mathematical Functions 6, 59, 269, 562, 600, 643, 651, The Practice of Programming 6 652, 657, 682, 684, 693, 731, 826, 827 The Standard C Library 827 Hisab Al-Jabr wal Mugabalah 575 The Widespread Misinterpretation of p-Values as Error Probabilities How Cray’s Arithmetic Hurts Scientific Computation 953 196 IEEE 754 Standard for Binary Floating-Point Arithmetic vii, 63, 966 Twelfth Night 341 Subject index . . . U 1111

What Every Computer Scientist Should Know About Floating-Point undefined variable (PDP-11) 956 Arithmetic 103 underflow 77, 105, 113–115, 132, 137, 139, 145, 154, 595, 598, 607, What is a Satisfactory Quadratic Equation Solver? 472 824 Why Do We Need a Floating-Point Arithmetic Standard? 952 abrupt xxxv, 78 Why Most Published Research Findings Are False 196 Alpha processors xxxv tldexp.c file 769 gradual 64, 78, 940 tlgamm.c file 766 premature 101, 113, 414, 415, 449, 451, 456, 466, 532, 595, 598, TMI instruction 962 619, 621, 622, 691, 768, 778, 883, 940 TOMS (ACM Transactions on Mathematical Software) 826 threshold 153 TOP 500 supercomputer sites 952 underflow exception flag 78, 79, 106, 111, 114, 123, 124, 338, 415, TOPS-20 operating system ix, 71, 131, 763, 849, 1115 598, 778, 785 TPL instruction 962 UNF (on Lawrence Livermore National Laboratory S-1) 965 tpsi.c file 768 Unicode character set 921, 983 tpsiln.c file 768 uniform distribution 189 tqert.c file 473 union statement 829, 934 TR440 (model) 970 system header file 159 TRA instruction 962 Univac (vendor) 74, 353, 948, 949, 965, 966, 970, 972 traffic analysis 204 univariate distributions 196 transcendental number 16 University of California, Berkeley 85, 250, 952 trap University of Illinois (vendor) 948, 970 arithmetic exception 106 University of Manchester (vendor) 970 integer overflow 918 University of Minnesota Supercomputing Institute ix overflow 72 University of Pennsylvania (vendor) 970 signaling NaN 80 University of Utah thread problem in handler 107 Center for High-Performance Computing ix underflow 951 Department of Chemistry ix use before definition 931 Department of Electrical Engineering ix zero divide 70, 977 Department of Mathematics ix trapezoid rule 570 Department of Physics and Astronomy ix triangle inequality 222 School of Computing ix trigamma function 537 UNIX operating system x trigonometric functions 299 UNIX operating system ix, x, xxxv, 3, 4, 60, 66, 70, 74, 87, 106, 124, trigonometric secant function 572 147, 207, 223, 224, 233, 237, 251, 273, 290, 362, 408, 557, 694, triple factorial 523 697, 825, 827, 850, 870, 873, 896, 899, 905, 909, 916, 920, true program 943 941–944, 946, 956, 972, 980, 982, 1115 NIX TRUEOS operating system x U V3 operating system 896 truncation function 135 UNIX V6 operating system 131, 896 try statement 90, 830, 918 UNIX V7 operating system 896 Tsang, Wai Wan 200 unsafe keyword 921 unsigned char * tstkis.c file 177 data type 874 unsigned char data type 257, 873, 908 ttgamm.c file 766 tuftest package 200–202 unsigned int data type 152, 892 unsigned long int * Tukey, John Wilder (1915–2000) 969 data type 907 unsigned long int data type 896 Turing Award 763, 941, 959, 963 unsigned long long int * data type 907 Twain, Mark (1835–1910) 823 unsigned long long int data type 173, 896 Twelfth Night 341 unsigned short int * data type 907 two’s-complement arithmetic 73, 74, 132, 140, 142, 890, 896, 917, unsigned wchar_t data type 873 952, 954, 955, 958, 963, 972 Uranus (planet) 630 two-norm 223 url package 1115 typedef see also data type US mil 305 typedef statement 2, 101, 102, 159, 209, 442 US National Institute of Standards and Technology see NIST TZE instruction 962 use statement 915 using statement 920, 924 U Utah Supercomputing Institute ix UCBTEST package 774 UTF-16 format 921 UINT_LEAST32_T data type 209, 211, 260–262 UTF-8 format 983 uint_least32_t data type 209 UINT_LEAST64_T data type 209–211, 260 V uint_least64_t data type 209, 260 Van Eetvelt, P. W. J. 606 uintmax_t * data type 907 var keyword 991 uintmax_t data type 877, 896, 907 system header file 871 Ulam, Stanisław Marcin (1909–1984) 202 variance 158, 194 ulp (unit in the last place) 216, 217, 220, 597, 598, 608, 609, see also varioref package 1115 machine epsilon VAX (CPU) viii, ix, xxix, 71, 131, 146, 251, 271, 305, 365, 473, 478, computation 608 708, 761, 774, 855, 928, 947, 948, 951, 954, 956–958, 970, 974, definition 67 1115 1112 Subject index . . . V

reserved operand 478, 948, 956, 957 IBM vii–x, xxxv, 65, 68, 71, 79, 85–87, 104, 109, 146, 155, 171, VAX-11 (CPU) 956 217, 218, 233, 241, 254, 287, 305, 341, 353, 355, 361, 365, 370, vector sum (exact) 385 375, 402, 410, 433, 438, 478, 520, 761, 811, 816, 817, 820, 825, vendor 827, 848, 850, 855, 867, 896, 905, 927–930, 936, 942, 947–949, Adobe vii 951, 952, 954, 956, 959, 961–964, 967, 969–971, 976–978, 1035 Advanced Scientific 970 Intel vii–ix, xxxv, 63, 65, 71, 80, 86, 87, 100, 104, 105, 124, 146, AEI 970 148, 150, 283, 292, 293, 310, 338, 339, 350, 388, 395, 442, 716, Alliant 952 814, 815, 824, 867, 928–930, 953, 954, 959, 970, 971, 976 AMD 65, 293, 339, 1021 Interdata ix, 896, 948, 963, 965, 970 Amdahl 963 Itel 963 AMI 971 Kendall Square Research 952 Apollo 948 Lawrence Livermore National Laboratory 305, 463, 948, 965 Apple x, 71, 109, 818, 982 Librascope 970 Ardent 952 LMI 970 Autometrics 970 Los Alamos Scientific Laboratories 970 Ballistics Research Laboratory 970 Lyons 970 Bell Laboratories 463 Magnuson 963 Berkeley 237, 273, 290, 948 Manchester University 948 Bull 970 Matsushita 970 Burroughs 305, 948, 949, 969, 970, 977 Microsoft viii, x, 125, 867, 917, 920, 954, 982 MIPS 73, 78, 86, 146, 216, 219, 220, 355, 391, 392, 817, 970 Calcomp 970 Mitsubishi 970 Cambridge 970 Motorola 65, 71, 86, 124, 145, 146, 150, 216, 217, 251, 292, 293, CDC 74, 80, 85, 305, 353, 365, 396, 520, 948–953, 956, 963–965, 338, 352, 363, 395, 823, 959, 970, 976 969, 970, 972, 989 Multiflow 952 CITAC 970 Nanodata 963 Compaq 71, 79, 812 National Physical Laboratory 970 Control Data Corporation 949 National Semiconductor 970 Convex 952 NCR 949 Cray 68, 85, 256, 257, 305, 365, 948, 949, 951–953, 955, 957, 964, NEC 952, 963 965, 969–971, 977 NeXT 71 Cray Research Inc. 949 Norsk Data 970 Cydrome 952 OKI Electric 970 Data General 948, 963, 970 Open Group x Datasaab 970 Parallels viii DEC v, viii, ix, 66, 71, 86, 107, 146, 153, 216, 224, 250, 251, 256, Philco 970 305, 365, 478, 608, 761, 763, 774, 812, 850, 855, 928, 947, 948, Pr1me 947, 948 951–954, 956, 965, 969, 970, 974, 976–978, 1115 Princeton University 970 Denelcor 963 Pyramid 952 Digital Electronics 970 RAND 970 Digital Equipment Corporation 954 Raytheon 970 DSI 970 RCA 963, 970 El-tronics 970 Regnecentralen 970 Electrologica 970 Rice Institute 948, 970 Elliott 970 Ryad 963 ELXSI 952, 970, 977 Scientific Data 970 Encore 952 SEL Systems 948, 970 English Electric 948, 970 Sequent 952 English Electric LEO-Marconi 970 SGI 153 ETA 949, 952 Siemens 963 Ferranti 970 Silicon Graphics 71, 78, 355, 817, 976, 977 Ferranti–Packard 970 Stardent 952, 976 Floating-Point Systems 952 STC 970 Foonly 954 Stellar 952 Fujitsu 952, 963 Sun 824 General Electric 65, 305, 947, 948, 958, 959, 970 Sun Microsystems viii, 71, 86, 99, 110, 124, 133, 153, 218, 274, Gentoo 956 294, 304, 325, 349, 383, 388, 528, 595, 811, 818–822, 824, 967, GNU xxxv, 71, 87, 101, 133, 274, 320, 352, 391, 433, 442, 813, 814, 970, 973, 976, 977, 979, 989 817, 819, 821, 825, 860, 911, 928, 930, 936, 944, 989–991, 993, 994 Superset 948 Gould 948, 963, 970 Supertek 952 Harris 254, 396, 597, 947, 948, 970 Symbolics 970 Harvard University 970 Systems Concepts 954 Hewlett–Packard viii, xxxv, 4, 71, 86, 100, 101, 233, 355, 383, Telefunken 970 388, 765, 812, 815, 816, 824, 970 Texas Instruments 963 Hitachi 952, 963, 970 Thinking Machines 952 Honeywell 65, 305, 948, 949, 958, 959, 970 Univac 74, 353, 948, 949, 965, 966, 970, 972 Subject index . . . W 1113

University of Illinois 948, 970 Weyl, Hermann (1885–1955) 177 University of Manchester 970 What Every Computer Scientist Should Know About Floating-Point University of Pennsylvania 970 Arithmetic 103 Virtual Iron viii What is a Satisfactory Quadratic Equation Solver? 472 VirtualBox viii Why Do We Need a Floating-Point Arithmetic Standard? 952 VMware viii, ix, 1115 Why Most Published Research Findings Are False 196 Wang 963 Wichmann–Hill generator 177 Wolfram 465 widecenter package 1115 Xen viii WINDOWS operating system x, 125, 917, 920, 954, 982 Xerox 948, 954, 963, 970 wint_t * data type 907 XKL 954 wint_t data type 877, 907 Zilog 971 Wirth, Niklaus 949, 959 Zuse 948, 950, 970 with statement 915, 916 Venus (planet) 630 wobbling precision 24, 25, 27, 104, 155, 215, 234, 254, 283, 290, 302, versine function 301 316, 324, 342, 343, 345, 375, 423, 427, 428, 596, 617, 632, 700, video instruction set 86 704, 708, 718, 723, 755, 763, 785, 788, 804, 805, 964, 967 violation of C99 Standard 218, 238 Wolfram (vendor) 465 Virtual Iron (vendor) viii women in mathematics 59 virtual machine vii, viii, 65, 73, 80, 216, 917, 919, 947, 979 WorkingPrecision option (Mathematica) 34, 39 access to native code 979 World War II 202, 969 C# viii, 80, 917, 921 worst case CLI (Common Language Infrastructure) viii, 80, 917, 919, 921 argument reduction 15, 28, 251, 252, 265 Hercules x base conversion 852 IA-64 viii complex multiplication 458 Java viii, 80, 867 cylindrical Bessel function of second kind 714 KLH10 ix double rounding 265 P-code 989 floating-point powers 502 Parallels viii floating-point precision 287 PDP-10 viii gcd algorithm 182 PDP-11 viii integer powers 420 QEMU 129 near zeros of cylindrical Bessel functions 716 SIMH ix pair-precision arithmetic 64, 407 System/360 viii quadratic equations 472 VAX viii Virtual Iron viii X VirtualBox viii X-MP (model) 948, 952, 970, 971 VMware viii, ix x.h header file 3 Xen viii x86 see IA-32, Pentium VirtualBox (vendor) viii x86 (CPU) xxxv VMS operating system 957 x86_64 see AMD64, EM64T, Opteron, Xeon VMware (vendor) viii, ix, 1115 xdvi program 1115 void * data type 874 Xen (vendor) viii void data type 109, 125, 148, 355, 356, 442, 906 Xeon (CPU) 339 volatile keyword 65, 66, 121, 127, 135, 139, 163, 231, 245, 246, 250, Xerox (vendor) 948, 954, 963, 970 275, 326, 358, 359, 362–366, 369–371, 393, 404–406, 431–433, XKL (vendor) 954 436, 451, 471, 478, 598, 746, 749, 761, 780, 785, 849, 994 XOR-shift generator 176 von Neumann, John (1903–1957) 157, 190, 193, 202, 212 xp_t data type 854, 856, 857 vpa package 4 XTEA 178 vprtx.h header file 878 XXTEA 178 W Y Waite, William v, viii, xxv, 1, 2, 4, 10–12, 23–26, 28, 32, 42–44, 52, Y-MP (model) 948, 952, 970 57, 59, 61, 70, 79, 98, 102, 215, 245, 246, 270–272, 284, 285, 287, y0x.h header file 718 289, 290, 298, 306, 308, 310, 324, 325, 332, 336, 340, 343–345, y1x.h header file 718 349, 411, 412, 414, 421, 423–429, 433, 434, 438, 440, 714, 763, Youdon, William John (1900–1971) 194 765, 781, 797, 798, 804, 811, 823, 823, 826, 939, 940 Wang (vendor) 963 Z wchar_t * data type 874, 907 Z format modifier 463 wchar_t data type 877, 901, 906, 907 z-Series (CPU) 241, 438 Weber’s function 695 z/Architecture (model) x, 1115 Weber, Heinrich (1842–1913) 695 Z1 (model) 970 Weibull distribution 196 z10 (CPU) 927, 936 Weibull, Ernst Hjalmar Waloddi (1887–1979) 196 z13 (model) 928 Weierstrass, Karl Theodor Wilhelm (1815–1897) 619, 682, 682 Z2 (model) 970 Weisstein, Eric Wolfgang 465, 569, 579, 591 Z22 (model) 970 Weyl sequence generator 177 Z23 (model) 970 1114 Subject index . . . Z

Z25 (model) 970 Z26 (model) 970 Z3 (model) 970 Z80 (CPU) 971 z9 (CPU) 927, 936 z9 (model) 936 zbMATH database 59, 576, 591, 693 ZEBRA (model) 970 zero see also signed zero arc tangent 70 constant 69 creating signed 135, 975 detecting sign 69 dirty 963 division by 70 history 59 negative 58, 64, 69, 71, 366, 478, 520, 885, 950, 951 origin of 575, 927 zeta function 57, 303, 521, 579 Hurwitz generalization of Riemann 583 Zeta function (Jacobian) 679 zetax.h header ﬁle 583 zetm1x.h header ﬁle 583 Zhu, Yong-Kang 385 Zilog (vendor) 971 zoetrope 24 zSeries (model) 930 Zuse (vendor) 948, 950, 970 Zuse, Konrad (1910–1995) 950 Colophon

This book was typeset with LATEX2ε using the extended extbook document class, with limited customization of the layout. The book pages use Palatino text fonts, Palatino Italic and Computer Modern mathematical fonts, and De- jaVuSansMono typewriter fonts, with 9.7pt type on 11.64pt leading. The typographic features exploited in the design of this book were provided by several standard LATEX2ε packages, including at least these:

amsfonts color luximono pifont amsmath colortbl makeidx url array fontenc mathpazo varioref calligra graphicx multicol

These private packages supplied the remaining LATEX2ε extensions:

authidx mathcw namelist rgb hhmm mod-mathpazo resize-mathcw widecenter

Document and software development and production were managed on UNIX-like systems on a score of vendor/ hardware platforms, on the SIMH VAX and Hercules System/370, ESA/390, and z/Architecture simulators, on DEC TOPS-20 on the KLH10 PDP-10 simulator, and more than 100 operating systems running on QEMU and VMware virtual machines for IA-32 and AMD64 processor families, with the help of at least these external programs:

acroread emacs hocd128 myspell authidx gnuplot ispell nawk bc gp lacheck pdflatex bibtex groff latex pr build-all gs makeindex ps2pdf chkdelim gv makeinfo reduce chktex gzip make R col hoc32 man2html sage deroff hoc36 man2texi sed detex hoc64 maple sh distill hoc72 math sort dv2dt hoc80 matlab spell dvips hoc128 maxima Splus dw hocd32 mupad xdvi egrep hocd64