Roman E. Maeder

Performance analysis of the parallel Karatsuba multiplication algorithm for distributed memory architectures

Abstract We present three parallel implementations of the Karatsuba algorithm for long integer multiplication on a distributed memory architecture and discuss the experimental results obtained on a Paragon computer. The first two implementations have both time complexity O ( n ) on n log 2 3 processors, but present different behavior for inputs of practical size. The third algorithm has complexity O ( n log 2 n on n processors, offering therefore better asymptotic efficiency. A refinement of the asymptotic analysis for the important case of a constant number of processors takes into account sequential parts of the algorithm and communications overhead. It is shown that the theoretically best speed-up and efficiency can be obtained with two of the algorithms for sufficient problem size. The experimental results confirm the analysis.

Storage Allocation for the Karatsuba Integer Multipliation Algorithm

The Karatsuba (or 3-for-4) integer multiplication algorithm needs some amount of auxiliary memory (in addition to the memory needed to store the result). We give sharp upper and lower bounds for the amount of auxiliary storage required and discuss implementation issues. Since we must never allocate too few memory cells, an asymptotic formula is not sufficient. The bounds are 2(n−4 + 3⌈log2(n−3)⌋) and 2(n−6 + 2⌈log2(n−2)⌋), respectively. The formula for the amount of auxiliary storage is obtained by an exact closed-form solution of a recursion formula involving the floor and ceiling functions. Comparing the upper and lower bounds shows that this simple allocation formula does not waste much memory for any input size.

Visualizations for mathematics courses based on a computer algebra system

Abstract This paper discusses the introduction of a computer-algebra system to perform visualizations in mathematics education. With the Illustrated Mathematics project, we provide a comprehensive collection of graphics and animations for various topics in mathematics, which can directly be used for teaching. Because the programs (written in Mathematica ) we used for the creation of this collection are included, it is easy to design new examples by modifying parameters in existing examples. Therefore, Illustrated Mathematics can be used as a first step of the introduction of a computer-algebra system in mathematics education. In the second part, we report on the development of a workbench and learning environment, with which the students can discover the mathematical concepts by themselves. For that, the given examples have to be didactically enriched and processed. By creating their own visualizations of increasing complexity, the students improve their knowledge about the underlying computer-algebra system.

AlgBench: An Object-Oriented Symbolic Core System

AlgBench is a workbench for the design, implementation and performance measurement of algorithms for symbolic computation, including computer algebra. It provides an interpreter for a symbolic language and a skeleton for implementing data types and algorithms in all areas of symbolic computation. An object-oriented design makes incorporation of new code easy. A compiled implementation language was chosen to allow measurements of efficiency of algorithms and data structures down to machine level.

Parallel 3-Primes FFT Algorithm

Multiple precision arithmetic forms the core of symbolic computation systems. A speedup of the basic algorithms can therefore improve all higher-level algorithms. Several packages have been developed for sequential processors. Although they were implemented carefully, they are unsatisfactory for large inputs. Performance can be improved by chosing algorithms with better asymptotic behavior or by using other computing models such as parallel machines.

Matching and Unification for the Object-Oriented Symbolic Computation System AlgBench

Term matching has become one of the most important primitive operations for symbolic computation. This paper describes the extension of the object-oriented symbolic computation system AlgBench with pattern matching and unification facilities. The various pattern objects are organized in subclasses of the class of the composite expressions. This leads to a clear design and to a distributed implementation of the pattern matcher in the subclasses. New pattern object classes can consequently be added easily to the system. Huets and our simple mark and retract algorithm for standard unification as well as Stickels algorithm for associative commutative unification have been implemented in an object-oriented style. Unifiers are selected at runtime. We extend Mathematicas type-constrained pattern matching by taking into account inheritance information from a user-defined hierarchy of object types. The argument unification is basically instance variable unification. The improvement of the pattern matching operation of a rule- and object-based symbolic computation system with unification in an object-oriented way seems to be very appropriate.

Fibonacci on the Fast Track

This chapter discusses the computational mathematics and programming involving Fibonacci numbers. The sequence of Fibonacci numbers is easily defined in the terms of fn and these definitions can be programmed directly into Mathematica through Fibonacci .m. This method of computing Fibonacci numbers is very inefficient. This inefficiency can be overcome by employing dynamic programming. The disadvantage of this method is that all intermediate Fibonacci numbers are stored as rules; entering these rules into the system and subsequent lookup is slow and uses a lot of storage space. As fn is of size n, the measure to use is n; the loop that computes fibc[n] is executed n times. Thereafter, using a closed formula for this purpose though slow in symbolic expansion is still a fast way of computing fn; to get all the digits right, the computation with a precision equal to the size of fn must be performed. Another way to compute fnis using the matrix method; the improvements derived by finding better formulae for matrix multiplications are specific to the computing of Fibonacci numbers. Finally, there is a range of variance in between the computational power of the above methods; the fastest algorithm being one involving the compute fn asymptotically.

Polymorphism and Message Passing

Polymorphic functions are functions that can handle several different types of arguments. We look at ways of implementing such functions. First we present three LlSP-like implementations using dispatch tables, data-driven programming, and message passing. Then we look at various ways of implementing objects, that is, data elements that have built in all the functions that can be applied to them. This concept provides for a high degree of modularity and lays the groundwork for a discussion of object-oriented programming in Chapter 4.

Chapter Four – Object-Oriented Programming

The object-oriented programming style is becoming increasingly popular. It promises code reuse and easier maintenance of larger projects than is possible with traditional procedural languages. Its use of methods and message passing instead of procedure calls shifts the programmers view toward close integration of data and operations. An interactive object-oriented language can easily be implemented in Mathematica. In the last chapter we discussed two important tools, message passing and objects. We now present the other tools, classes and inheritance. To illustrate the programming style we expand the example developed in the last chapter and give an implementation of collections.

Chapter Ten – System Programming

System programming refers to procedures and tools for maintaining the computer system itself, as opposed to application programming. Mathematica is mainly used for programming applications, i.e., solving mathematical problems. In this article we develop tools for looking at Mathematica itself. Such tools are useful in program development. For example, we can find all symbols in a context having no documentation, revealing possible omissions or possibly bad package design. As usual when a system is used to look upon itself, problems of self-referentiality arise. One example is the difficulty of writing a manual for a text-formatting language in that very language. Printing special characters (such as the backslash \ in TEX) requires careful quotation or escape mechanisms to prevent them from acting in the usual way. In Mathematica the main problem is unwanted evaluation of expressions we want to treat as data.