Glad you’re enjoying the book – the book went through several very different forms before settling on this presentation (see the Class Notes section on stepanovpapers.com). Alex frequently fills his lectures with great references to the history of mathematics (and history in general) – and they can be very obscure. Several individuals gave feedback that on the lecture notes that led Alex and Paul to settle on the more traditional form of a math text. If you enjoy the stories – make sure you watch his GCD lecture http://www.stepanovpapers.com/stepanov_gcd.mov. (There are also more recent slides on the site and a very recent video but the latest is in Russian).

I found this sentence doubly confusing:

1. the lack of any formatting on “codomain” and “domain” led me to believe that they were being used in their normal mathematical sense – which further led me to believe (due to making a long break between reading chapt 1 and chapt 2) that Codomain and Domain type functions were also defined in the same mathematical vein – an immediate inspection of the presented examples proved me false to assume that.

2. and more importantly, I was surprised that the definition of the Operation concept was made so strong, again departing from the usual mathematical definition. For example,

double ScalarProduct(Vector v1, Vector v2);

doesn’t qualify as an operation, whereas

double ScalarProduct(double x1, y1, x2, y2);

does, even though both function represent the same idea. In my opinion, the “troublesome” sentence would read much better if “operation” was replaced with “HomogeneousOperation”, “domain” with “Domain” and “codomain” with “Codomain”, and all three appropriately formatted. At this point, I’m also surprised that Domain and Codomain are defined for homogeneous functions only – just ads up to the overall confusion.

Also, the definition of Operation as it stands, checks three times whether Op is homogeneous if it in fact is. I’m not sure if this is necessarily a bad thing, as I’ve not yet seen or compiled actual C++ code using these concepts.

Anyhow, a great book thus far! Though, after going through Alex’s lecture notes that this book was based upon, I was expecting a bit more flavor (in form of his amusing reflections) to the text.

Ad 5. Yes, often times preconditions cannot be checked (or cannot be checked without violating the time complexity of the function).

Ad 7. From page 3 of the errata:

Page 24, fourth line: Change \q > 0″ to \q > 0″ and \when slow enters the cycle” to \when it collides with slow”. (Reported by Bob English and John Banning.)

See theorem 3.1.

Ad 8. The distance between any point and itself is always 0. But the distance between the first 0 and the second is 1, the first 0 and the third is 2… etc. If you start at the collision point and advance one step you are at the start of the orbit, and you are back to where you started.

Ad 1. I don’t think the intention was to allow precondition to return not-bool. But if so, few words of comment would help to avoid confusion.

Ad 2. Mathematicians usually say “direct product” when they mean Cartesian product empowered with default structure, like direct product of two groups, linear spaces, manifolds.

Ad 5. Precondition is expressed only in comment, instead of explicit procedure.

Ad 6. Sorry, I don’t see any virtue in considering impossible case. In my opinion, chapter would become clearer if infinite orbit would be removed, with appropriate comment.

Ad 7. Sorry, I don’t see in this errata any definition correction for chapter 2. What do you mean?

Ad 8. No, it cannot. Consider for example int f(int i) {return 0;} with starting x = 0. It produces constant orbit (0, 0, 0, …), which is circular and distance between any two points of this orbit is 0. This is counterexample for last paragraph on pg 24, which says “In the case of a circular orbit, h = 0, r = 0, and the distance from the collision point to the beginning of the orbit is e = 1″.

According to chapter 2.4, I was wrong; it is ok in case c = 1

I also remembered that I had already implemented a better random number generator. It uses the linear congruential method described in Section 3.2.1 of Donald Knuth’s The Art of Computer Programming. The modulus m is 2^32 – 5 as suggested by Section 3.2.1.1 and the table in Section 4.5.4. Unlike the behavior of rand(), this one has a fixed cycle size of 421,412,441 regardless of the seed.

int random(int x) {
    srand(x);
    return rand();
}