The binary representation of 1/3 is infinite. Floating-point numbers, our standard tool for working with reals, cannot even handle numbers a young child could understand.

In contrast, every rational can be uniquely and exactly represented by a finite continued fraction (provided we forbid those with last term 1). Continued fractions are immune from oddities such as 1/3 = 0.333… and 1 = 0.999…, living in a realm free from the tyranny of binary, or any other base.

Every irrational number can also be uniquely expressed as an infinite continued fraction. Many frequently encountered algebraic and transcendental numbers have easily computable continued fraction expansions which can be truncated to yield approximations with built-in error bounds, unlike floating-point approximations, which must be accompanied at all times with their error bounds.

Furthermore, suppose we use floating-point to compute some answer to 100 decimal places. What if we now want 200 decimal places? Even if we possess the first 100 digits and carefully preserve the program state, we must start from scratch and redo all our arithmetic with 200 digit precision. If we had used continued fractions, we could arbitrarily increase the precision of our answer without redoing any work, and without any tedious error analysis.

But we must pay a price for these advantages. We have a representation from which we can instantly infer error bounds. A representation for which we may arbitrarily increase precision without repeating any calculations. A representation which in some sense is the closest we can hope to get to an exact number using rationals. Is it any wonder therefore that binary operations on continued fractions, whose output must also uphold these high standards, are clumsy and convoluted?

These drawbacks are almost certainly why these fascinating creatures remain obscure. Yet surely there are some problems that scream for continued fractions. How about a screen saver that computes more and more digits of pi, each time picking up where it left off? Or imagine a real-time application where all continued fractions simply output the last computed convergent on a timer interrupt. Under heavy system load, approximations are coarser but the show goes on.

Design

// e = [2; 1, 2, 1, 1, 4, 1, ...]
static void *e_expansion(cf_t cf) {
  int even = 2;
  cf_put_int(cf, even);

  while(cf_wait(cf)) {
    cf_put_int(cf, 1);
    cf_put_int(cf, even);
    even += 2;
    cf_put_int(cf, 1);
  }

  return NULL;
}