Richard J. Fateman

Comparing the speed of programs for sparse polynomial multiplication

How should one design and implement a program for the multiplication of sparse polynomials? This is a simple question, necessarily addressed by the builders of any computer algebra system (CAS). To examine a few options we start with a single easily-stated computation which we believe represents a useful benchmark of medium difficulty for CAS designs. We describe a number of design options and their effects on performance. We also examine the performance of a variety of commercial and freely-distributed systems. Important considerations include the cost of high-precision (exact) integer arithmetic and the effective use of cache memory.

Optical character recognition for typeset mathematics

There is a wealth of mathematical knowledge that could be potentially very useful in many computational applications, but is not available in electronic form. This knowledge comes in the form of mechanically typeset books and journals going back more than a hundred years. Besides these older sources, there are a great many current publications, filled with useful mathematical information, which are difficult if not impossible to obtain in electronic form. What we would like to do is extract character information from these documents, which could then be passed to higher-level parsing routines for further extraction of mathematical content (or any other useful 2-dimensional semantic content). Unfortunately, current commercial OCR (optical character recognition) software packages are quite unable to handle mathematical formulas, since their algorithms at all levels use heuristics developed for other document styles. We are concerned with the development of OCR methods that are able to handle this specialized task of mathematical expression recognition.

Searching techniques for integral tables

We describe the design of data structures and a computer program for storing a table of symbolic inde nite or de nite integrals and retrieving user-requested integrals on demand. Typical times are so short that a preliminary look-up attempt prior to any algorithmic integration approach seems justi ed. In one such test for a table with around 700 entries, matches were found requiring an average of 2.8 milliseconds per request, on a Hewlett Packard 9000/712 workstation.

Branch cuts in computer algebra

Most computer algebra systems provide little assistance in working with expressions involving functions with complex branch cuts. Worse, by their ignorance of the existence of branch cuts, algebra systems sometimes simplify complex expressions incorrectly. We propose a computer representation for branch cuts; we show how a complex expressions branch cuts may be mechanically computed, and how an expression with branch cuts may sometimes be algebraically simplified within each of its branches.

Honest plotting, global extrema, and interval arithmetic

A computer program to honestly plot curves y =

Fast floating-point processing in Common Lisp

(x) must locate maxima and minima in the domain of the graph. To do so it may have to solve a classic problem in computation – global optimization. Reducing an easy problem to a hard one is usually not an advantage, but in fact there is a route to solving both problems if the function can be evaluated using interval arithmetic. Since some computer algebra systems supply a version of interval arithmetic, it seems we have the ingredients for a solution. In this paper we address a particular problem how to compute and display “honest” graphs of 2-D mathematical curves. By “honest” we mean that no significant features (such as the location of poles, the values at maxima or minima, or the behavior of a curve at asymptotes) are misrepresented, By “mathematical” we mean curves like those generally needed in scientific disciplines where functions are represented by composition of common mathematical operations: rational operations (+, –, *, /), exponential and log, trigonometric functions as well as continuous and differentiable functions from applied mathematics.

Software Fault Prevention by Language Choice: Why C is Not My Favorite Language

Lisp, one of the oldest higher-level programming languages, has rarely been used for fast numerical (floating-point) computation. We explore the benefits of Common Lisp, an emerging new language standard with some excellent implementations, for numerical computation. We compare it to Fortran in terms of the speed of efficiency of generated code, as well as the structure and convenience of the language. There are a surprising number of advantages to Lisp, especially in cases where a mixture of symbolic and numeric processing is needed.

Evaluation of the heuristic polynomial GCD

How much does the choice of a programming language influence the prevalence of bugs in the resulting code? It seems obvious that at the level at which individuals write new programs, a change of language can eliminate whole classes of errors, or make them possible. With few exceptions, recent literature on the engineering of large software systems seems to neglect language choice as a factor in overall quality metrics. As a point of comparison we review some interesting recent work which implicitly assumes a program must be written in C. We speculate on how reliability might be aected by changing the language, in particular if we were to use ANSI Common Lisp.

A lisp-language Mathematica-to-lisp translator

The Heuristic Polynomial GCD procedure (GCDHEU) is used by the Maple computer algebra system, but no other. Because Maple has an especially efficient kernel that provides fast integer arithmetic, but a relatively slower interpreter for non-kernel code, the GCDHEU routine is especially effective in that it moves much of the computation into “bignum” arithmetic and hence executes primarily in the kernel. We speculated that in other computer algebra systems an implementation of GCDHEU would not be advantageous. In particular, if all the system code is compiled to run at ‘[full speed” in a (presumably more bulky) kernel that is entirely written in C or compiled Lisp, then there would seem to be no point in recasting the polynomial GCD problem into a bignum GCD problem. Manipulating polynomials that are vectors of coefficients would seem to be equivalent computationally to manipulating vectors of big digits. Yet our evidence suggests that one can take advantage of the GCDHEU in a Lisp system as well. Given a good implementation of bignums, for most small problems and many large ones, a substantial speedup can be obtained by the appropriate choice of GCD algorithm, including often enough, the GCDHEU approach. Another major winner seem to be the subresultant polynomial remainder sequence algorithm. Because more sophisticated sparse algorithms are relatively slow on small problems and only occasionally emerge as superior (on larger problems) it seems the choice of a fast GCD algorithm is tricky.

Network servers for symbolic mathematics

Wide distribution of the computer algebra system Mathematica has encouraged numerous programmers, researchers and educators to produce libraries of programs in its special language, for incorporation as packages into Mathematica systems. Although some features of the language are quite interesting, some authors have found that for their purposes the Mathematica proprietary computer program has problematical and difficult-to-alter semantics. Therefore certain kinds of experiments and developments are necessarily inconvenient. An initial step in opening up such user-written libraries to re-use is an independent re-implementation of the language via a non-proprietary parser. In principle, this allows other implementations of semantics, as well as experiments in data representation, while still using the language basically as described in the Mathematica references. We describe a parser written in Common Lisp, a language which is appropriate for three reasons: (1) It is a standard and has wide distribution; (2) It supports numerous useful features including automatic storage allocation and garbage collection, arbitrary-precision integers, and tools for lexical scanning of languages; and (3) Lisp is the host language for several algebraic manipulation systems whose subroutines may be of some interest for programmers implementing alternative semantics.