## 2009-06-05

### Euler's Power Riffs

Ed Sandifer is an exegete of Euler's methods. In his latest "How Euler Did It", he shows the method through which he arrived at closed polynomials for the sums of n-th powers of the first x integers:

In general, Euler has us multiply the terms of Σxn by (n + 1)/(n + 2) x, (n + 1)/(n + 1) x, (n + 1)/n x, … (n + 1)/2 x and (n + 1)/1 x, respectively, and add the appropriate linear term and to get the formula for Σxn+1.

where Σxn is Euler's notation for the sum in question. The algorithm is very easily translated to a short OCaml function. First, I'll need a way to generate an integer range:

```let range i j =
let rec go l j =
if j < i then l else
go (j :: l) (pred j)
in go [] j
```

Simple, eager, tail-call; almost imperative, definitely dirty. With that, Sandifer's rendition of Euler's method is simply:

```open Num

let rec eusum n =
if n = 0 then [Int 0; Int 1] else
let l = eusum (pred n)
(* n/1 n/2 n/3 ... n/(n+1) *)
and k = List.map (fun d -> Int n // Int d) (range 1 (n + 1)) in
(* the lowest coefficient is that of x^1 and always 0 *)
let _ :: xs = List.map2 ( */ ) k l in
(* normalize the sum of coefficients to 1 *)
let x = List.fold_left ( -/ ) (Int 1) xs in
Int 0 :: x :: xs
```

I want to clarify a couple of subtleties in the implementation. First, I use lists of `Num`s representing dense polynomials, least-order coefficient first. The base case is that for the sum of x ones (with exponent n = 0), namely x itself. As the article points out, the constant term is always zero, because a sum of zero powers is zero.

Then, the general case is built out of Σxn (called `l`) and the terms with which to multiply it (called `k`, in reverse order to that reported by Sandifer, which follows Euler in putting the highest power first). Both polynomials are multiplied term by term with `map2`; however, the degree is not yet raised at this stage. Also, the lowest term is always zero by the previous observation and I disregard it with an irrefutable pattern match (I could've used `List.tl`, but I prefer not to, in general). A simple `fold_left` computes the coefficient α for the linear term, and the polynomial is completed with it and the zero linear term, thus raising the degree by one (one term discarded, two added).

That's it, seven lines of code. Regrettably, it is not of much use as it is:

```# eusum 4 ;;
- : Num.num list =
[Int 0; Ratio <abstr>; Int 0; Ratio <abstr>; Ratio <abstr>; Ratio <abstr>]
```

Bummer, abstract data types. It turns out, pretty-printing polynomials is surprisingly tedious to get right:

```let pp_print_poly pp l =
let pow = ref 0
and any = ref false in
Format.pp_open_box pp 1;
List.iter (fun k ->
if k <>/ Int 0 then begin
if !any then Format.pp_print_space pp ();
Format.pp_open_hbox pp ();
(* Print coefficient *)
if k </ Int 0 then Format.pp_print_char pp '-' else
if !any then Format.pp_print_char pp '+';
if !any then Format.pp_print_space pp ();
let n = Num.abs_num k in
if n <>/ Int 1 || !pow = 0 then Format.pp_print_string pp (Num.string_of_num n);
(* Print formal power *)
if n <>/ Int 1 && !pow > 0 then Format.pp_print_char pp '*';
if !pow > 0 then Format.pp_print_char pp 'x';
if !pow > 1 then Format.fprintf pp "^%d" !pow;
Format.pp_close_box pp ();
any := true
end;
incr pow
) l;
Format.pp_close_box pp ()
```

I follow some very general rules for writing pretty printers. First, always accept the pretty printing channel `pp` as a parameter for maximum generality (you can then use it with #install_printer in the top-level). Second, always box everything. In this case I use a vertical-or-horizontal box around the entire polynomial, with one space for continuation lines, and a horizontal-only box around monomials.

As it is evident here, the usual rules for polynomials make the function logic-heavy: the first term uses the sign of the coefficient, but subsequent monomials are added or subtracted with the operation sign offset with spaces, and the coefficient is taken in absolute value. If the coefficient or the variable are 1 they are not shown, unless it is the constant term. If both the coefficient and the power are shown, they are separated by the multiplication sign.

With this it is easy to recreate the table in page 2 of the paper:

```# let () =
Format.open_box 1;
List.iter (fun i ->
pp_print_poly Format.std_formatter (eusum i);
Format.print_newline ()) (range 0 8);
Format.close_box ()
;;
x
1/2*x + 1/2*x^2
1/6*x + 1/2*x^2 + 1/3*x^3
1/4*x^2 + 1/2*x^3 + 1/4*x^4
-1/30*x + 1/3*x^3 + 1/2*x^4 + 1/5*x^5
-1/12*x^2 + 5/12*x^4 + 1/2*x^5 + 1/6*x^6
1/42*x - 1/6*x^3 + 1/2*x^5 + 1/2*x^6 + 1/7*x^7
1/12*x^2 - 7/24*x^4 + 7/12*x^6 + 1/2*x^7 + 1/8*x^8
-1/30*x + 2/9*x^3 - 7/15*x^5 + 2/3*x^7 + 1/2*x^8 + 1/9*x^9
```

As noted by Euler, the coefficient of the linear term is a Bernoulli number. There are more efficient ways to compute them, but in a pinch this serves:

```let bernoulli n = let _ :: b :: _ = eusum n in b
```

ChriS said...

I recommend you put
#use "topfind";;
in your ~/.ocamlinit file. Then to load the num library you simply issue
#require "num";;