Michael B. Monagan

Maple V: programming guide

1. Introduction.- 1.1 Getting Started.- Locals and Globals.- Inputs, Parameters, Arguments.- 1.2 Basic Programming Constructs.- The Assignment Statement.- The for Loop.- The Conditional Statement.- The while Loop.- Modularization.- Recursive Procedures.- Exercise.- 1.3 Basic Data Structures.- Exercise.- Exercise.- A MEMBER Procedure.- Exercise.- Binary Search.- Exercises.- Plotting the Roots of a Polynomial.- 1.4 Computing with Formulae.- The Height of a Polynomial.- Exercise.- The Chebyshev Polynomials, Tn(x).- Exercise.- Integration by Parts.- Exercise.- Computing with Symbolic Parameters.- Exercise.- 2. Fundamentals.- 2.1 Evaluation Rules.- Parameters.- Local Variables.- Global Variables.- Exceptions.- 2.2 Nested Procedures.- Local or Global?.- The Quick-Sort Algorithm.- Creating a Uniform Random Number Generator.- 2.3 Types.- Types that Modify Evaluation Rules.- Structured Types.- Type Matching.- 2.4 Choosing a Data Structure: Connected Graphs.- Exercises.- 2.5 Remember Tables.- The remember Option.- Adding Entries Explicitly.- Removing Entries from a Remember Table.- 2.6 Conclusion.- 3. Advanced Programming.- 3.1 Procedures Which Return Procedures.- Creating a Newton Iteration.- A Shift Operator.- 3.2 When Local Variables Leave Home.- Creating the Cartesian Product of a Sequence of Sets.- Exercises.- 3.3 Interactive Input.- Reading Strings from the Terminal.- Reading Expressions from the Terminal.- Converting Strings to Expressions.- 3.4 Extending Maple.- Defining New Types.- Exercises.- Neutral Operators.- Exercise.- Extending Certain Commands.- 3.5 Writing Your Own Packages.- Package Initialization.- Making Your Own Library.- 3.6 Conclusion.- 4. The Maple Language.- 4.1 Language Elements.- The Character Set.- Tokens.- Token Separators.- 4.2 Escape Characters.- 4.3 Statements.- The Assignment Statement.- Unassignment: Clearing a Name.- The Selection Statement.- The Repetition Statement.- The read and save Statements.- 4.4 Expressions.- Expression Trees: Internal Representation.- The Types and Operands of Integers, Strings, Indexed Names, and Concatenations.- Fractions and Rational Numbers.- Floating-Point (Decimal) Numbers.- Complex Numerical Constants.- Labels.- Sequences.- Sets and Lists.- Functions.- The Arithmetic Operators.- Non-Commutative Multiplication.- The Composition Operators.- The Ditto Operators.- The Factorial Operator.- The mod Operator.- The Neutral Operators.- Relations and Logical Operators.- Arrays and Tables.- Series.- Ranges.- Unevaluated Expressions.- Constants.- Structured Types.- 4.5 Useful Looping Constructs.- The map, select, and remove Commands.- The zip Command.- The seq, add, and mul Commands.- 4.6 Substitution.- 4.7 Conclusion.- 5. Procedures.- 5.1 Procedure Definitions.- Mapping Notation.- Unnamed Procedures and Their Combinations.- Procedure Simplification.- 5.2 Parameter Passing.- Declared Parameters.- The Sequence of Arguments.- 5.3 Local and Global Variables.- Evaluation of Local Variables.- 5.4 Procedure Options and the Description Field.- Options.- The Description Field.- 5.5 The Value Returned by a Procedure.- Assigning Values to Parameters.- Explicit Returns.- Error Returns.- Trapping Errors.- Returning Unevaluated.- Exercise.- 5.6 The Procedure Object.- Last Name Evaluation.- The Type and Operands of a Procedure.- Saving and Retrieving Procedures.- 5.7 Explorations.- Exercises.- 5.8 Conclusion.- 6. Debugging Maple Programs.- 6.1 A Tutorial Example.- 6.2 Invoking the Debugger.- Displaying the Statements of a Procedure.- Breakpoints.- Watchpoints.- Error Watchpoints.- 6.3 Examining and Changing the State of the System.- 6.4 Controlling Execution.- 6.5 Restrictions.- 7. Numerical Programming in Maple.- 7.1 The Basics of evalf.- 7.2 Hardware Floating-Point Numbers.- Newton Iterations.- Computing with Arrays of Numbers.- 7.3 Floating-Point Models in Maple.- Software Floats.- Hardware Floats.- Roundoff Error.- 7.4 Extending the evalf Command.- Defining Your Own Constants.- Defining Your Own Functions.- 7.5 Using the Matlab Package.- 7.6 Conclusion.- 8. Programming with Maple Graphics.- 8.1 Basic Plot Functions.- 8.2 Programming with Plotting Library Functions.- Plotting a Loop.- A Ribbon Plot Procedure.- 8.3 Maples Plotting Data Structures.- The PLOT Data Structure.- A Sum Plot.- The PLOT3D Data Structure.- 8.4 Programming with Plot Data Structures.- Writing Graphic Primitives.- Plotting Gears.- Polygon Meshes.- 8.5 Programming with the plottools Package.- A Pie Chart.- A Dropshadow Procedure.- Creating a Tiling.- A Smith Chart.- Modifying Polygon Meshes.- 8.6 Example: Vector Field Plots.- 8.7 Generating Grids of Points.- 8.8 Animation.- 8.9 Programming with Color.- Generating Color Tables.- Adding Color Information to Plots.- Creating A Chess Board Plot.- 8.10 Conclusion.- 9. Input and Output.- 9.1 A Tutorial Example.- 9.2 File Types and Modes.- Buffered Files versus Unbuffered Files.- Text Files versus Binary Files.- Read Mode versus Write Mode.- The default and terminal Files.- 9.3 File Descriptors versus File Names.- 9.4 File Manipulation Commands.- Opening and Closing Files.- Position Determination and Adjustment.- Detecting the End of a File.- Determining File Status.- Removing Files.- 9.5 Input Commands.- Reading Text Lines from a File.- Reading Arbitrary Bytes from a File.- Formatted Input.- Reading Maple Statements.- Reading Tabular Data.- 9.6 Output Commands.- Configuring Output Parameters using the interface Command.- One-Dimensional Expression Output.- Two-Dimensional Expression Output.- Writing Maple Strings to a File.- Writing Arbitrary Bytes to a File.- Formatted Output.- Writing Tabular Data.- Flushing a Buffered File.- Redirecting the default Output Stream.- 9.7 Conversion Commands.- C or FORTRAN Generation.- LATEX or eqn Generation.- Conversion between Strings and Lists of Integers.- Parsing Maple Expressions and Statements.- Formatted Conversion to and from Strings.- 9.8 A Detailed Example.- 9.9 Notes to C Programmers.- 9.10 Conclusion.

A tutorial introduction to Maple

The Maple computer algebra system is described. Brief sample sessions show the user syntax and the mathematical power of the system for performing arithmetic, factoring, simplification, differentiation, integration, summation, solving algebraic equations, solving differential equations, series expansions, and matrix manipulations. Time and space statistics for each sample session show that the Maple system is very efficient in memory space utilisation, as well as in time. The Maple programming language is presented by describing the most commonly used features, using some non-trivial computations to illustrate the language features.

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.

Maximal quotient rational reconstruction: an almost optimal algorithm for rational reconstruction

Let n/d ∈ Q, m be a positive integer and let u = n/d mod m. Thus

Sparse polynomial division using a heap

u

A modular GCD algorithm over number fields presented with multiple extensions

is the image of a rational number modulo m. The rational reconstruction problem is; given u and m find n/d. A solution was first given by Wang in 1981. Wangs algorithm outputs n/d when m > 2 M2 where M = max(|n|,d). Because of the wide application of this algorithm in computer algebra, several authors have investigated its practical efficiency and asymptotic time complexity.In this paper we present a new solution which is almost optimal in the following sense; with controllable high probability, our algorithm will output n/d when m is a modest number of bits longer than 2 |n| d. This means that in a modular algorithm where m is a product of primes, the modular algorithm will need one or two primes more than the minimum necessary to reconstruct n/d; thus if |n| ⇐ d or d ⇐ |n| the new algorithm saves up to half the number of primes. Further, our algorithm will fail with high probability when m < 2 |n| d.

The first case of Fermat’s last theorem is true for all prime exponents up to 714,591,416,091,389

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.

Parallel sparse polynomial interpolation over finite fields

We consider the problem of computing the monic gcd of two polynomials over a number field L = ℚ(α1,…,αn). Encarnacion, Langemyr and McCallum have already shown how Browns modular GCD algorithm for polynomials over ℚ can be modified to work for ℚ(α).Our first contribution is an extension of Encarnacions modular GCD algorithm to the case n > 1 without converting to a single field extension. Our second contribution is a proof that it is not necessary to test if p divides the discriminant. This simplifies the algorithm; it is correct without this test.Our third contribution is the design of a data structure for representing multivariate polynomials over number fields with multiple field extensions. We have a complete implementation of the modular GCD algorithm using it. We provide details of some practical improvements.

Efficient Multivariate Factorization over Finite Fields

We show that if the first case of Fermat’s Last Theorem is false for prime exponent p then p2 divides qp — q for all primes q < Sq. As a corollary we state the theorem of the title.

Introduction to Gauss

We present a probabilistic algorithm to interpolate a sparse multivariate polynomial over a finite field, represented with a black box. Our algorithm modifies the algorithm of Ben-Or and Tiwari from 1988 for interpolating polynomials over rings with characteristic zero to characteristic p by doing additional probes. To interpolate a polynomial in n variables with t non-zero terms, Zippels (1990) algorithm interpolates one variable at a time using O(ndt) probes to the black box where d bounds the degree of the polynomial. Our new algorithm does O(nt) probes. It interpolates each variable independently using O(t) probes which allows us to parallelize the main loop giving an advantage over Zippels algorithm. We have implemented both Zippels algorithm and the new algorithm in C and we have done a parallel implementation of our algorithm using Cilk [2]. In the paper we provide benchmarks comparing the number of probes our algorithm does with both Zippels algorithm and Kaltofen and Lees hybrid of the Zippel and Ben-Or/Tiwari algorithms.