Question

By primitive expressions, I mean + - * / sqrt, unless there are others that I am missing. I’m wondering how to write a Scheme expression that finds the 6th root using only these functions.

I know that I can find the cube root of the square root, but cube root doesn’t appear to be a primitive expression.

Answer 1

Consider expt, passing in a fractional power as its second argument.

But let’s say we didn’t know about expt. Could we still compute it?

One way to do it is by applying something like Newton’s method. For example, let’s say we wanted to compute n^(1/4). Of course, we already know we can just take the sqrt twice to do this, but let’s see how Newton’s method may apply to this problem.

Given n, we’d like to discover roots x of the function:

f(x) = x^4 - n

Concretely, if we wanted to look for 16^(1/4), then we’d look for a root for the function:

f(x) = x^4 - 16

We already know if we plug in x=2 in there, we’ll discover that 2 is a root of this function. But say that we didn’t know that. How would we discover the x values that make this function zero?

Newton’s method says that if we have a guess at x, call it x_0, we can improve that guess by doing the following process:

x_1 = x_0 - f(x_0) / f'(x_0)

where f'(x) is notation for the derivative of f(x). For the case above, the derivative of f(x) is 4x^3.

And we can get better guesses x_2, x_3, … by repeating the computation:

x_2 = x_1 - f(x_1) / f'(x_1)
x_3 = x_2 - f(x_2) / f'(x_2)
...

until we get tired.

Let’s write this all in code now:

(define (f x)
  (- (* x x x x) 16))

(define (f-prime x)
  (* 4 x x x))

(define (improve guess)
  (- guess (/ (f guess)
              (f-prime guess))))

(define approx-quad-root-of-16
  (improve (improve (improve (improve (improve 1.0))))))

The code above just expresses f(x), f'(x), and the idea of improving an initial guess five times. Let’s see what the value of approx-quad-root-of-16 is:

> approx-quad-root-of-16
2.0457437305170534

Hey, cool. It’s actually doing something, and it’s close to 2. Not bad for starting with such a bad first guess of 1.0.

Of course, it’s a little silly to hardcode 16 in there. Let’s generalize, and turn it into a function that takes an arbitrary n instead, so we can compute the quad root of anything:

(define (approx-quad-root-of-n n)
  (define (f x)
    (- (* x x x x) n))

  (define (f-prime x)
    (* 4 x x x))

  (define (improve guess)
    (- guess (/ (f guess)
                (f-prime guess))))

  (improve (improve (improve (improve (improve 1.0))))))

Does this do something effective? Let’s see:

> (approx-quad-root-of-n 10)
1.7800226459895
> (expt (approx-quad-root-of-n 10) 4)
10.039269440807693

Cool: it is doing something useful. But note that it’s not that precise yet. To get better precision, we should keep calling improve, and not just four or five times. Think loops or recursion: repeat the improvement till the solution is “close enough”.

This is a sketch of how to solve these kinds of problems. For a little more detail, look at the section on computing square roots in Structure and Interpretation of Computer Programs.