Recipes for Continuation by Harry Dankowicz and Frank Schilder is, in one sense, a user's manual for the software package Computational Continuation Core or COCO. But it is also much more and much less than this.

COCO is an open source project of Dankowicz and Schilder that is analogous to AUTO or MatCont: it allows one to compute bifurcation diagrams, or more generally, to solve – using continuation – for submanifolds defined by a set of functions, a "zero problem" of the form \(\Phi : \mathbb{R}^n \to \mathbb{R}^m \) that may depend upon some set of parameters and may have added constraints. COCO is built as a MATLAB plugin, like MatCont. It fully utilizes object oriented ideas and MATLABs vectorization. It can be freely downloaded from the Sourceforge site cocotools. An extensive set of example projects are included with the project that coincide with the examples in Recipes for Continuation.

To introduce you to COCO, consider the rather trivial example of finding points on a circle defined by \( \Phi(u) = u_1^2 + (u_2-1)^2 -1 . \) This is encoded in a MATLAB function

function [data,y] = circ(prob,data,u)
y=u(1)^2+(u(2)-1)^2-1;
end

Here "prob" is a COCO structure created by the command

prob = coco_prob();

The structure "data" can contain (modifiable) auxiliary data needed to evaluate the function at its argument, the vector \(u\). The function "circ" is added to the problem by

prob = coco_add_func(prob, 'fun1', @circ, [], 'zero', 'u0', [0.9; 1.1]);

This inserts the function handle @circ into the problem and gives it the designation "zero" to indicate that the goal is to zero this function (as opposed to acting as a constraint or monitor function). The final arguments above give an initial guess for the solution. The "add_func" paradigm in COCO allows for the flexibility to build more complex problems from simpler ones and modify problems once they are constructed. Here we just add one more function to the problem:

prob = coco_add_pars(prob, 'pars', 1:2, {'x', 'y'});

This defines and adds the "monitor" function \( (x,y) = \Psi(u) = u \) and will cause COCO to output columns labeled by "x" and "y". Finally, the continuation is executed with

cp = coco(prob, 'run1', [], 1,{'x','y'},[-2 2]);

The fourth argument indicates that this is a one-dimensional continuation, and the final argument gives the maximal range over which \(x \) is to be continued. Much like AUTO, the run creates a number of data files in a subdirectory "data/run1". The solution can be read into MATLAB with the command "coco_bd_read", or plotted directly, column by column, as:

x = plot(coco_bd_col(cp, 'x'), coco_bd_col(cp, 'y'), '-');

This example, of course, is not a bifurcation problem. COCO is built for the latter and includes a number of toolboxes, including a collocation toolbox for differential equations and a number of manifold generating or atlas algorithms.

But that is about COCO: what about the book? The book has an interesting structure – it is simultaneously more and less than a user manual. It certainly contains many examples and the input/output of many runs are shown. But nowhere is there a list of COCO commands with details of every argument; for this the MATLAB help facility can be used (alas, it seems that many functions are not yet documented, and those that are, are rather tersely so). The book is more than a user manual because it discusses many of the design decisions used to build the COCO framework. For example, how does one design an extensible software package that is flexible enough for the addition of new algorithms (e.g., for atlas construction or collocation), and at the same time maintain a coherent, mathematically sound structure? This is a major topic of the book. At the same time, there is much discussion of the theoretical nature of continuation problems. However, the authors note that this book should not be thought of as a text on bifurcation theory, and they recommend some of the standard texts, e.g., Kuznetsov's fine text Elements of Applied Bifurcation Theory, etc., as appropriate for this.

One difficulty that this reviewer had with the text is that the concepts discussed are not often well motivated. The authors adopt a more mathematical presentation, stating, e.g., "Let \( E_1\) be an extended continuation problem" in an abstract way, when I would have preferred to see more concrete examples before the abstraction. Then there are those thorny statements "It follows that", that we always make in mathematics, but that sometimes leave the reader with a serious desire for extensive head-scratching.

Thus, this is not a text for beginners in the field: readers need to be familiar both with bifurcation theory and with continuation methodology. They also need to be familiar with MATLAB constructs. Given these elements of preparation, a reader who has an interest in designing bifurcation algorithms and/or simply using a well-designed framework like COCO will be well-served by this book. I certainly am intrigued enough to continue to explore COCO as a framework for continuation problems in my research.

James Meiss