## Monday, September 22, 2014

### A couple more homographic function tricks

A generalized continued fraction is an expression of the form:You can partly apply a homographic function to a generalized continued fraction if you have a stream of the ai and bi
```(define (partly-apply-general hf nums dens)
(let ((a (first  hf))
(b (second hf))
(c (third  hf))
(d (fourth hf)))
(if (empty-stream? nums)
(values (list a a
c c)
nums
dens)
(values (list (+ (* a den) (* b num)) a
(+ (* c den) (* d num)) c)
(tail nums)
(tail dens))))))

(define (print-hf-general hf nums dens)
(call-with-values (lambda () (partly-evaluate hf))
(lambda (term hf*)
(if (not term)
(call-with-values (lambda () (partly-apply-general hf nums dens))
print-hf-general)
(begin
(display term)
;; take reciprocal and multiply by 10
(let ((a (first hf*))
(b (second hf*))
(c (third hf*))
(d (fourth hf*)))
(print-hf-general (list (* c 10) (* d 10)
a        b)
nums dens)))))))
```
For example, we can compute pi from this generalized continued fraction:
```(print-hf-general (list 0 4 1 0)
;; [1 1 4 9 16 25 ...]
(cons-stream 1
(let squares ((i 1))
(cons-stream (* i i) (squares (1+ i)))))
;; [1 3 5 7 9 11 ...]
(let odds ((j 1))
(cons-stream j (odds (+ j 2)))))

314159265358979323846264338327950^G
; Quit!
```
A bi-homographic function is a function of the form:
```(define (bi-homographic a b c d e f g h)
(lambda (x y)
(/ (+ (* a x y) (* b x) (* c y) d)
(+ (* e x y) (* f x) (* g y) h))))
```
Like a homographic function, you can partly evaluate a bi-homographic function and generate a continued fraction. You can also partly apply a bi-homographic function to a pair of continued fractions. When you do this, you have a choice of which continued fraction to be the object of the partial application. There's about twice as much nasty math involved, but the gist is that a bi-homographic function takes two continued fractions as arguments and produces one continued fraction as a result.

It turns out that addition, subtraction, multiplication and division are bi-homographic functions, so one can incrementally compute sums and products of continued fractions.

## Thursday, September 18, 2014

### A useful, if somewhat pointless, trick with homographic functions

In my previous posts I showed that if you are applying a homographic function to a continued fraction, you can partly evaluate the answer before you completely apply the function. Instead of representing homographic functions as lambda expressions, I'll represent them as a list of the coefficients `a`, `b`, `c`, and `d` in `(lambda (t) (/ (+ (* a t) b) (+ (* c t) d)))`. I'll represent a simple continued fraction as a stream of the integer terms in the denominators.
Here is how you partly apply a homographic function to a continued fraction:
```(define (partly-apply hf cf)
(let ((a (first  hf))
(b (second hf))
(c (third  hf))
(d (fourth hf)))
(if (empty-stream? cf)
(values (list a a
c c)
cf)
(values (list (+ (* a term) b) a
(+ (* c term) d) c)
(tail cf))))))```
Partly evaluating a homographic function involves looking at the limits of the function as `t` starts at 1 and goes to infinity:
```(define (partly-evaluate hf)
(let ((a (first hf))
(b (second hf))
(c (third hf))
(d (fourth hf)))

(if (and (same-sign? c (+ c d))
(let ((limit1 (quotient      a       c))
(limit2 (quotient (+ a b) (+ c d))))
(= limit1 limit2)))
(let ((term (quotient a c)))
(let ((new-c (- a (* c term)))
(new-d (- b (* d term))))
(values term (list c d new-c new-d))))
(values #f #f))))
```
We can combine these two steps and make something useful. For example, we can print the value of applying a homographic function to a continued fraction incrementally, printing the most significant digits before computing further digits.
```(define (print-hf-cf hf cf)
(call-with-values (lambda () (partly-evaluate hf))
(lambda (term hf*)
(if (not term)
(call-with-values (lambda () (partly-apply hf cf))
print-hf-cf)
(begin
(display term)
;; take reciprocal and multiply by 10
(let ((a (first hf*))
(b (second hf*))
(c (third hf*))
(d (fourth hf*)))
(print-hf-cf (list (* c 10) (* d 10)
a        b)
cf)))))))```
But how often are you going to apply a homographic function to a continued fraction? Fortunately, the identity function is homographic (coefficients are 1 0 0 1), so applying it to a continued fraction doesn't change the value. The square root of 2 is a simple continued fraction with coefficients [1 2 2 2 ...] where the 2s repeat forever. We apply the identity homographic function to it and print the results:
```(printcf (list 1 0 0 1) sqrt-two)
14142135623730950488016887242096980785696718^G
; Quit!```
As you can see, we start printing the square root of two and we don't stop printing digits until the user interrupts.

A fancier version could truncate the output and print a decimal point after the first iteration.

## Friday, September 5, 2014

### Another stupid homographic function trick

In my last post I showed that if you take a homographic function and apply it to a fraction, you can partly apply the function to the integer part of the fraction and get a new homographic function. The new function can be applied to the non-integer part of the fraction to generate an answer equivalent to the original function applied to the original fraction.

It turns out that you can go in the other direction as well. You can partly evaluate a homographic function. For example, consider this homographic function:
```((lambda (t)
(/ (+ (* 70 t) 29)
(+ (* 12 t)  5))) n)```
Which we intend to apply to some positive number `n`. Even if all we know is that `n` is positive, we can deduce that the value of the homographic function is between 29/5 (when `t` is 0) and 70/12 (as `t` goes to infinity). The integer part of those values are the same, so we can factor that out:
```(+ 5 (/ 1 ((lambda (t)
(/ (+ (* 12 t) 5)
(+ (* 10 t) 4))) n)))```
The partial answer has an integer value of 5 and a fractional part that contains a new homographic function applied to our original `n`. We can do it again:
```(+ 5 (/ 1
(+ 1 (/ 1
((lambda (t)
(/ (+ (* 10 t) 4)
(+ (* 2 t) 1))) n)))))```
The fractional part of the answer can itself be factored into another integer and a new homographic function applied to our original `n`.

## Wednesday, September 3, 2014

### Stupid homographic function trick

A function of the form
is called a homographic function.  Here is one in Scheme:
```(lambda (t)
(/ (+ (* 3 t) 4)
(+ (* 5 t) 2)))```
And here is what it's graph looks like:If you multiply all the coefficients (`a`, `b`, `c`, and `d`) by the same number, it doesn't change the function. For instance, this homographic function:
```(lambda (t)
(/ (+ (* 21 t) 28)
(+ (* 35 t) 14)))```
is the same as the one above. If one of your coefficients isn't an integer, don't worry, you can multiply everything by the denominator and get an equivalent homographic function. On the other hand, you can divide all your coefficients by their greatest common divisor and get an equivalent homographic function with smaller coefficients. We'll keep our homographic functions in smallest integer form.

A rational number can be written as the sum of an integer and a fraction less than one. For example, 23/5 = 4 + 3/5.

Let's apply a homographic function to a rational number:
```((lambda (t)
(/ (+ (* a t) b)
(+ (* c t) d))) (+ x y/z))

;; substitute
(/ (+ (* a (+ x y/z)) b)
(+ (* c (+ x y/z)) d))

;; distribute the multiplication
(/ (+ (* a x) (* a y/z) b)
(+ (* c x) (* c y/z) d))

;; multiply top and bottom by z/y
(/ (* z/y (+ (* a x) (* a y/z) b))
(* z/y (+ (* c x) (* c y/z) d)))

;; distribute the multiplication
(/ (+ (* a x z/y) (* a y/z z/y) (* b z/y))
(+ (* c x z/y) (* c y/z z/y) (* d z/y)))

;; simplify
(/ (+ (* a x z/y) a (* b z/y))
(+ (* c x z/y) c (* d z/y)))

;; rearrange terms
(/ (+ (* a x z/y) (* b z/y) a)
(+ (* c x z/y) (* d z/y) c))

;; factor out z/y
(/ (+ (* (+ (* a x) b) z/y) a)
(+ (* (+ (* c x) d) z/y) c))

```
Now we do something tricky. We abstract out the `z/y` term:
```((lambda (t)
(/ (+ (* (+ (* a x) b) t) a)
(+ (* (+ (* c x) d) t) c))) (/ z y))
```
If introduce a `let` form, we can see something interesting:
```((lambda (t)
(let ((a1 (+ (* a x) b))
(b1 a)
(c1 (+ (* c x) d))
(d1 c))
(/ (+ (* a1 t) b1)
(+ (* c1 t) d1)))) (/ z y))
```
We find a new homographic function being applied to a new rational number. The new homographic function has coefficients related to the original one, and the new rational number is the reciprocal of the fractional part of the original rational number. So if we have a homographic function `hf` applied to a fraction of the form `x + y/z`, we can easily find a new homographic function `hf'` that when applied to `z/y` will produce the same answer as the original. Applying a homographic function to a fraction has the effect of "eating" the integer part of the fraction, which generates a new homographic function that is applied to the reciprocal of the fractional part.