To save content items to your account,
please confirm that you agree to abide by our usage policies.
If this is the first time you use this feature, you will be asked to authorise Cambridge Core to connect with your account.
Find out more about saving content to .
To save content items to your Kindle, first ensure no-reply@cambridge.org
is added to your Approved Personal Document E-mail List under your Personal Document Settings
on the Manage Your Content and Devices page of your Amazon account. Then enter the ‘name’ part
of your Kindle email address below.
Find out more about saving to your Kindle.
Note you can select to save to either the @free.kindle.com or @kindle.com variations.
‘@free.kindle.com’ emails are free but can only be saved to your device when it is connected to wi-fi.
‘@kindle.com’ emails can be delivered even when you are not connected to wi-fi, but note that service fees apply.
We describe how the Hardy–Ramanujan–Rademacher formula can be implemented to allow the partition function p(n) to be computed with softly optimal complexity O(n1/2+o(1)) and very little overhead. A new implementation based on these techniques achieves speedups in excess of a factor 500 over previously published software and has been used by the author to calculate p(1019), an exponent twice as large as in previously reported computations. We also investigate performance for multi-evaluation of p(n), where our implementation of the Hardy–Ramanujan–Rademacher formula becomes superior to power series methods on far denser sets of indices than previous implementations. As an application, we determine over 22 billion new congruences for the partition function, extending Weaver’s tabulation of 76 065 congruences. Supplementary materials are available with this article.
This is a short, focused introduction to MATLAB, a comprehensive software system for mathematical and technical computing. It contains concise explanations of essential MATLAB commands, as well as easily understood instructions for using MATLAB's programming features, graphical capabilities, simulation models, and rich desktop interface. Written for MATLAB 7, it can also be used with earlier (and later) versions of MATLAB. This book teaches how to graph functions, solve equations, manipulate images, and much more. It contains explicit instructions for using MATLAB's companion software, Simulink, which allows graphical models to be built for dynamical systems. MATLAB's new "publish" feature is discussed, which allows mathematical computations to be combined with text and graphics, to produce polished, integrated, interactive documents. For the beginner it explains everything needed to start using MATLAB, while experienced users making the switch to MATLAB 7 from an earlier version will also find much useful information here.
Given an elliptic curve E over a field of positive characteristic p, we consider how to efficiently determine whether E is ordinary or supersingular. We analyze the complexity of several existing algorithms and then present a new approach that exploits structural differences between ordinary and supersingular isogeny graphs. This yields a simple algorithm that, given E and a suitable non-residue in 𝔽p2, determines the supersingularity of E in O(n3log 2n) time and O(n) space, where n=O(log p) . Both these complexity bounds are significant improvements over existing methods, as we demonstrate with some practical computations.
From power series expansions of functions on curves over finite fields, one can obtain sequences with perfect or almost perfect linear complexity profile. It has been suggested by various authors to use such sequences as key streams for stream ciphers. In this work, we show how long parts of such sequences can be computed efficiently from short ones. Such sequences should therefore be considered to be cryptographically weak. Our attack leads in a natural way to a new measure of the complexity of sequences which we call expansion complexity.
The chromatic polynomial P(G,λ) gives the number of ways a graph G can be properly coloured in at most λ colours. This polynomial has been extensively studied in both combinatorics and statistical physics, but there has been little work on its algebraic properties. This paper reports a systematic study of the Galois groups of chromatic polynomials. We give a summary of the Galois groups of all chromatic polynomials of strongly non-clique-separable graphs of order at most 10 and all chromatic polynomials of non-clique-separable θ-graphs of order at most 19. Most of these chromatic polynomials have symmetric Galois groups. We give five infinite families of graphs: one of these families has chromatic polynomials with a dihedral Galois group and two of these families have chromatic polynomials with cyclic Galois groups. This includes the first known infinite family of graphs that have chromatic polynomials with the cyclic Galois group of order 3.
We prove that under any projective embedding of an abelian variety A of dimension g, a complete set of addition laws has cardinality at least g+1, generalizing a result of Bosma and Lenstra for the Weierstrass model of an elliptic curve in ℙ2. In contrast, we prove, moreover, that if k is any field with infinite absolute Galois group, then there exists for every abelian variety A/k a projective embedding and an addition law defined for every pair of k-rational points. For an abelian variety of dimension 1 or 2, we show that this embedding can be the classical Weierstrass model or the embedding in ℙ15, respectively, up to a finite number of counterexamples for ∣k∣≤5 .
Modern Computer Arithmetic focuses on arbitrary-precision algorithms for efficiently performing arithmetic operations such as addition, multiplication and division, and their connections to topics such as modular arithmetic, greatest common divisors, the Fast Fourier Transform (FFT), and the computation of elementary and special functions. Brent and Zimmermann present algorithms that are ready to implement in your favourite language, while keeping a high-level description and avoiding too low-level or machine-dependent details. The book is intended for anyone interested in the design and implementation of efficient high-precision algorithms for computer arithmetic, and more generally efficient multiple-precision numerical algorithms. It may also be used in a graduate course in mathematics or computer science, for which exercises are included. These vary considerably in difficulty, from easy to small research projects, and expand on topics discussed in the text. Solutions to selected exercises are available from the authors.
This first book on greedy approximation gives a systematic presentation of the fundamental results. It also contains an introduction to two hot topics in numerical mathematics: learning theory and compressed sensing. Nonlinear approximation is becoming increasingly important, especially since two types are frequently employed in applications: adaptive methods are used in PDE solvers, while m-term approximation is used in image/signal/data processing, as well as in the design of neural networks. The fundamental question of nonlinear approximation is how to devise good constructive methods (algorithms) and recent results have established that greedy type algorithms may be the solution. The author has drawn on his own teaching experience to write a book ideally suited to graduate courses. The reader does not require a broad background to understand the material. Important open problems are included to give students and professionals alike ideas for further research.
This book is devoted to some mathematical methods that arise in two domains of artificial intelligence: neural networks and qualitative physics. Professor Aubin makes use of control and viability theory in neural networks and cognitive systems, regarded as dynamical systems controlled by synaptic matrices, and set-valued analysis that plays a natural and crucial role in qualitative analysis and simulation. This allows many examples of neural networks to be presented in a unified way. In addition, several results on the control of linear and nonlinear systems are used to obtain a 'learning algorithm' of pattern classification problems, such as the back-propagation formula, as well as learning algorithms of feedback regulation laws of solutions to control systems subject to state constraints. This book will be of value to anyone with an interest in neural networks and cognitive systems.
Given a prime q and a negative discriminant D, the CM method constructs an elliptic curve E/Fq by obtaining a root of the Hilbert class polynomial HD(X) modulo q. We consider an approach based on a decomposition of the ring class field defined by HD, which we adapt to a CRT setting. This yields two algorithms, each of which obtains a root of HD mod q without necessarily computing any of its coefficients. Heuristically, our approach uses asymptotically less time and space than the standard CM method for almost all D. Under the GRH, and reasonable assumptions about the size of log q relative to ∣D∣, we achieve a space complexity of O((m+n)log q)bits, where mn=h(D) , which may be as small as O(∣D∣1/4 log q) . The practical efficiency of the algorithms is demonstrated using ∣D∣>1016 and q≈2256, and also ∣D∣>1015 and q≈233220. These examples are both an order of magnitude larger than the best previous results obtained with the CM method.
We describe an effective algorithm to compute a set of representatives for the conjugacy classes of Hall subgroups of a finite permutation or matrix group. Our algorithm uses the general approach of the so-called ‘trivial Fitting model’.
We present an improved algorithm for the computation of Zariski chambers on algebraic surfaces. The new algorithm significantly outperforms the currently available method and therefore allows us to treat surfaces of high Picard number, where huge numbers of chambers occur. As an application, we efficiently compute the number of chambers supported by the lines on the Segre–Schur quartic.
We introduce the computer algebra package PyCox, written entirely in the Python language. It implements a set of algorithms, in a spirit similar to the older CHEVIE system, for working with Coxeter groups and Hecke algebras. This includes a new variation of the traditional algorithm for computing Kazhdan–Lusztig cells and W-graphs, which works efficiently for all finite groups of rank ≤8 (except E8). We also discuss the computation of Lusztig’s leading coefficients of character values and distinguished involutions (which works for E8 as well). Our experiments suggest a re-definition of Lusztig’s ‘special’ representations which, conjecturally, should also apply to the unequal parameter case. Supplementary materials are available with this article.
From its earliest days, the Fortran programming language has been designed with computing efficiency in mind. The latest standard, Fortran 2008, incorporates a host of modern features, including object-orientation, array operations, user-defined types, and provisions for parallel computing. This tutorial guide shows Fortran programmers how to apply these features in twenty-first-century style: modular, concise, object-oriented, and resource-efficient, using multiple processors. It offers practical real-world examples of interfacing to C, memory management, graphics and GUIs, and parallel computing using MPI, OpenMP, and coarrays. The author also analyzes several numerical algorithms and their implementations and illustrates the use of several open source libraries. Full source code for the examples is available on the book's website.
I have been programming in Fortran for more than 25 years, first in FORTRAN IV and somewhat later in FORTRAN 77. In the last decade of the 20th century, I attended, together with a number of colleagues, a course on Fortran 90, given by the late Jan van Oosterwijk at the Technical University of Delft. It was also around this time that I came to know the comp.lang.fortran newsgroup, and I have learned a lot by participating in that friendly community.
In a way, I am a typical Fortran programmer. My background is physics and I learned the task of programming partly during my study, but mostly on the job. In other ways, I am not because I took a fancy to the more esoteric possibilities of programming in general and sought means to apply them in Fortran. I also began writing articles for the ACM Fortran Forum. These articles are the groundwork for this book.
This book will not teach you how to program in Fortran. There are plenty of books dedicated to that ([22], [65]). Instead, the purpose of this book is to show how modern Fortran can be used for modern programming problems, such as how techniques made popular in the world of object-oriented languages like C++ and Java fit neatly into Fortran as it exists today. It even shows some techniques for solving certain programming problems that are not easily achieved in these languages.
Interaction with the user via graphical presentation or graphical interfaces is an extremely important aspect of computing. It is also an area that depends heavily on the available hardware and the operating system. While much effort has been put into the various operating environments to hide the hardware aspect, programming a graphical user-interface (GUI) on MS Windows is completely different from doing so on Linux or Mac OS X.
Hardly any programming language defines how you can display results graphically or how to build a graphical user-interface. The common approach is to use a library that hides – if possible or desirable – the specifics of the operating system, so that a portable program results. Some libraries, however, have been designed to take advantage of exactly one operating system, so that the program fits seamlessly in that environment, at the cost of not being portable anymore. At the same time, you should not underestimate the effort and skills required for designing and building a useful and usable GUI [3].
For a Fortran programmer, the situation is a bit complicated: most GUI libraries are written with C, C++, and similar languages in mind. Furthermore, a GUI for a long-running computation should have different properties than one for filling in a database form. This chapter examines a variety of solutions.
Plotting the Results
The first type of graphical interaction to examine is the presentation of the results of a computation. The responses from the user are simple: leaf through the collection of plots – in many cases sequentially – and maybe change a display parameter here and there.
Computer programs sometimes exhibit unexpected behavior. They may function correctly for years and then, suddenly, they fail. Computer programs that solve numerical problems are no exception. The unexpected behavior, perhaps a division by zero, is often the consequence of input that does not conform to the hidden assumptions and restrictions ofthe program. For example, a Gauss elimination procedure to solve systems oflinear equations requires the matrix to be non-singular. If the matrix is numerically singular or ill-conditioned, the mathematical problem of solving the system is still well-defined, but the numerical counterpart may have a hard time delivering a decent approximation to the exact solution. The conclusion that the matrix is ill-conditioned is only drawn while solving the system.
Sometimes there is a mismatch between the specification and the actual implementation. The part of the program that reads the data accepts input that conforms to the specification, but there are a few tacit assumptions, like line-endings for a text file containing the coefficients of the matrix for the Gauss elimination program.
Subtle bugs may lurk in an otherwise well-written and well-behaved program. Can you avoid them altogether? The unsatisfying answer is probably not, but that does not mean you cannot make an effort to understand the source of these bugs. That is the intention of this chapter – to examine three simple mathematical algorithms and their implementation in Fortran.
The idea is that a straightforward implementation contains all manners of hidden assumptions about the problem that needs solving.
Quite often the public interface of a library that you are interested in is written in a different programming language than the one you use. You will need an interface library that bridges the gap between both languages. This is the case with SQLite, a lightweight database management system [44]. It is written in C and there is a host of libraries to communicate with SQLite in all manner of languages.
For Fortran, there is the fsqlite library that I developed. It was inspired by the work of Al Danial [27], but focused on FORTRAN 77, that was mainly an example of how you could interface to the SQLite library. I wanted a generic solution instead.
The design decisions and the implementation of fsqlite illustrate a more general question: how to combine Fortran and other programming languages? Each time you need to consider:
■ Low-level aspects of the combination:
- How do the basic types of the two languages relate to each other?
- What are the naming and calling conventions?
■ High-level aspects relating to the actual library: What is a good “model” for the interface? Should you simply write wrapping routines that merely translate the routine interfaces or should you build a higher-level interface, molding the original interface into something that is a better fit for the library's use?
This chapter will cover both types of issues in the context of interfacing with C (an intermediate layer in C is often a convenient way to communicate with any other language) and of the interface to SQLite.