Roman Pearce

Parallel sparse polynomial multiplication using heaps

We present a high performance algorithm for multiplying sparse distributed polynomials using a multicore processor. Each core uses a heap of pointers to multiply parts of the polynomials using its local cache. Intermediate results are written to buffers in shared cache and the cores take turns combining them to form the result. A cooperative approach is used to balance the load and improve scalability, and the extra cache from each core produces a superlinear speedup in practice. We present benchmarks comparing our parallel routine to a sequential version and to the routines of other computer algebra systems.

Sparse polynomial division using a heap

In 1974, Johnson showed how to multiply and divide sparse polynomials using a binary heap. This paper introduces a new algorithm that uses a heap to divide with the same complexity as multiplication. It is a fraction-free method that also reduces the number of integer operations for divisions of polynomials with integer coefficients over the rationals. Heap-based algorithms use very little memory and do not generate garbage. They can run in the CPU cache and achieve high performance. We compare our C implementation of sparse polynomial multiplication and division with integer coefficients to the routines of the Magma, Maple, Pari, Singular and Trip computer algebra systems.

Rational simplification modulo a polynomial ideal

We present two algorithms for simplifying rational expressions modulo an ideal of the polynomial ring <i>k[x</i>₁, . . . , <i>x_n</i>]. The first method generates the set of equivalent expressions as amodule over <i>k[x</i>₁, . . . , <i>x_n</i>] and computes a reduced Gröbner basis. From this we obtain a canonical form for the expression up to our choice of monomial order for the ideal. The second method constructs equivalent expressions by solving systems of linear equations over <i>k</i>, and conducts a global search for an expression with minimal total degree. Depending on the ideal, the algorithms may or may not cancel all common divisors. We also provide some timings comparing the efficiency of the algorithms in Maple.

Parallel sparse polynomial division using heaps

We present a parallel algorithm for exact division of sparse distributed polynomials on a multicore processor. This is a problem with significant data dependencies, so our solution requires fine-grained parallelism. Our algorithm manages to avoid waiting for each term of the quotient to be computed, and it achieves superlinear speedup over the fastest known sequential method. We present benchmarks comparing the performance of our C implementation of sparse polynomial division to the routines of other computer algebra systems.

Sparse polynomial multiplication and division in Maple 14

We demonstrate new routines for sparse multivariate polynomial multiplication and division over the integers that we have integrated into Maple 14 through the expand and divide commands. These routines are currently the fastest available, and the multiplication routine is parallelized with superlinear speedup. The performance of Maple is significantly improved. We describe our polynomial data structure and compare it with Maples. Then we present benchmarks comparing Maple 14 with Maple 13, Magma, Mathematica, Singular, Pari, and Trip.

POLY: a new polynomial data structure for Maple 17

We demonstrate how a new data structure for sparse distributed polynomials in the Maple kernel significantly accelerates a large subset of Maple library routines. The POLY data structure and its associated kernel operations (degree, coeff, subs, has, diff, eval, ...) are programmed for high scalability, allowing polynomials to have hundreds of millions of terms, and very low overhead, increasing parallel speedup in existing routines and improving the performance of high level Maple library routines.

Sparse polynomial powering using heaps

We modify an old algorithm for expanding powers of dense polynomials to make it work for sparse polynomials, by using a heap to sort monomials. It has better complexity and lower space requirements than other sparse powering algorithms for dense polynomials. We show how to parallelize the method, and compare its performance on a series of benchmark problems to other methods and the Magma, Maple and Singular computer algebra systems.

Fermat benchmarks for rational expressionals in maple

We employ two techniques to dramatically improve Maples performance on the Fermat benchmarks for simplifying rational expressions. First, we factor expanded polynomials to ensure that gcds are identified and cancelled automatically. Second, we replace all expanded polynomials by new variables and normalize the result. To undo the substitutions, we use a C routine for sparse multivariate division by a set of polynomials. The resulting times for the first Fermat benchmark are a factor of 17x faster than Fermat and 39x faster than Magma.

A compact parallel implementation of F4

We present a compact and parallel C implementation of the F4 algorithm for computing Gröbner bases which uses Cilk. We give an easy way to parallelize the sparse linear algebra which is the main cost in practice. To obtain more speedup we attempted to parallelize the generation of sparse matrices as well. We present timings to assess the effectiveness of our approach and to compare our implementation to others.

An Algorithm For Spliting Polynomial Systems Based On F4

We present algorithms for splitting polynomial systems using Gröbner bases. For zero dimensional systems, we use FGLM to compute univariate polynomials and factor them, placing the ideal into general position if necessary. For positive dimensional systems, we successively eliminate variables using F4 and use the leading co-efficients of the last variable to split the system. We also present a known optimization to reduce the cost of zero-reductions in F4, an improvement for FGLM over the rationals, and an algorithm for quickly detecting redundant ideals in a decomposition.