Contents - Student subdomain for University of Bath

2.1. WHAT ARE POLYNOMIALS? 33
MULTIPLY-POLY by O(m 2 n) ((m(m + 3)/2 − 1)n to be exact). 4 There are multiplication
algorithms which are more efficient than this one: roughly speaking,
we ought to sort the terms of the product so that they appear in decreasing
order, and the use of ADD-POLY corresponds to an insertion sort. We know that
the number of coefficient multiplications in such a ‘classical’ method is mn, so
this emphasises that the extra cost is a function of the exponent operations
(essentially, comparison) and list manipulation. Of course, the use of a better
sorting method (such as “quicksort” or “mergesort”) offers a more efficient multiplication
algorithm, say O(mn log m) [Joh74]. But most systems have tended
to use an algorithm similar to the procedure given above: [MP08]shows the
substantial improvements that can be made using a better algorithm.
Maple’s representation, and methods, are rather different. The terms in a
Maple sum might appear to be unordered, so we might ask what prevents 2x 2
from appearing at one point, and −2x 2 at another. Maple uses a hash-based
representation [CGGG83], so that insertion in the hash table takes amortised 5
constant time, and the multiplication is O(mn).
In a dense representation, we can use radically different, and more efficient,
methods based on Karatsuba’s method [KO63, and section B.3], which takes
time O ( max(m, n) min(m, n) 0.57...) , or the Fast Fourier Transform [AHU74,
chapter 8], where the running time is O(n log n).
There is a technical, but occasionally important, difficulty with this procedure,
reported in [ABD88]. We explain this difficulty in order to illustrate
the problems which can arise in the translation of mathematical formulae into
computer algebra systems. In MULTIPLY-POLY, we add a 0 b 1 to a 1 b. The order
in which these two objects are calculated is actually important. Why, since this
can affect neither the results nor the time taken? The order can dramatically
affect the maximum memory space used during the calculations. If a and b are
dense of degree n, the order which first calculates a 0 b 1 should store all these
intermediate results before the recursion finishes. Therefore the memory space
needed is O(n 2 ) words, for there are n results of length between 1 and n. The
other order, a 1 b calculated before a 0 b 1 , is clearly more efficient, for the space
used at any moment does not exceed O(n). This is not a purely theoretical remark:
[ABD88] were able to factorise x 1155 − 1 with REDUCE in 2 megabytes
of memory 6 , but they could not remultiply the factors without running out of
memory, which appears absurd.
Division is fairly straight-forward: to divide f by g, we keep subtracting
appropriate (meaning c i = (lc(f)/lc(g))x degf−degg ) multiples of g from f until
the degree of f is less than the degree of g. If the remaining term (the remainder)
is zero, then g divides f, and the quotient can be computed by summing the
4 It is worth noting the asymmetry in the computing time of what is fundamentally a
symmetric operation. Hence we ought to choose A as the one with the fewer terms. If this
involves counting the number of terms, many implementors ‘cheat’ and take A as the one of
lower degree, hoping for a similar effect.
5 Occasionally the hash table may need to grow, so an individual insertion may be expensive,
but the average time is constant.
6 A large machine for the time!