I no longer remember what led me to this page of synthetic division implemented in various languages. The author provides a common lisp implementation for taking a list representing the coefficients of a polynomial in one variable and a number and returning the result of dividing the polynomial by .

The author states: I’m very sure this isn’t considered Lispy and would surely seem like an awkward port from an extremely Algol-like mindset in the eyes of a seasoned Lisper. In the mood for the exercise, I reworked his code snippet into slightly more canonical lisp while leaving the basic structure the same:

(defun synthetic-division (polynomial divisor)                                  
  (let* ((result (first polynomial))                                            
         (quotient (list result)))                                              
    (dolist (coefficient (rest polynomial))                                     
      (setf result (* result divisor))                                          
      (incf result coefficient)                                                 
      (push result quotient))                                                   
    (let ((remainder (pop quotient)))                                           
      (list :quotient (nreverse quotient) :remainder remainder))))

From there, I went on to implement it using tail recursion to get rid of the #'setf and #'incf and #'push:

(defun synthetic-division-2 (polynomial divisor)                                
  (labels ((divide (coefficients remainder quotient)                            
             (if coefficients                                                   
                 (divide (rest coefficients)                                    
                         (+ (* divisor remainder) (first coefficients))         
                         (list* remainder quotient))                            
               (list :quotient (reverse quotient) :remainder remainder))))      
    (divide (rest polynomial) (first polynomial) nil)))

What I didn’t like about this was the complexity of calling the tail-recursive portion. If I just called it like I wished to (divide polynomial 0 nil) then I ended up with one extra coefficient in the answer. This wouldn’t do.

The Joke

There’s an old joke about a physicist, a biologist, and a mathematician who were having lunch at an outdoor café. Just as their food was served, they noticed a couple walk into the house across the street. As they were finishing up their meal, they saw three people walk out of that very same house.

The physicist said, We must have miscounted. Three must have entered before.

The biologist said, They must have pro-created.

The mathematician said, If one more person enters that house, it will again be empty.

The Anti-Cons

What I needed was a more-than-empty list. I needed a negative cons-cell. I needed something to put in place of the nil in (divide polynomial 0 nil) that would annihilate the first thing it was cons-ed to.

I haven’t come up with the right notation to make this clear. It is somewhat like a quasigroup except that there is only one inverse element for all other elements. Let’s denote this annihilator: . Let’s denote list concatenation with .

Only having one inverse-ish element means we have to give up associativity. For lists and , evaluating equals , but equals .

Associativity is a small price to pay though for a prettier call to my tail-recursive function, right?

The Basic Operations

For basic operations, I’m going to need the anti-cons itself and a lazy list of an arbitrary number of anti-conses.

(defconstant anti-cons 'anti-cons)
 
(defclass anti-cons-list ()
  ((length :initarg :length :reader anti-cons-list-length))
  (:default-initargs :length 1))
 
(defmethod print-object ((obj anti-cons-list) stream)
  (print-unreadable-object (obj stream)
    (prin1 (loop :for ii :from 1 :to (anti-cons-list-length obj)
              :collecting 'anti-cons)
           stream)))

Then, I’m going to make some macros to define generic functions named by adding a minus-sign to the end of a Common Lisp function. The default implementation will simply be the common-lisp function.

(defmacro defun- (name (&rest args) &body methods)
  (let ((name- (intern (concatenate 'string (symbol-name name) "-"))))
    `(defgeneric ,name- (,@args)
       (:method (,@args) (,name ,@args))
       ,@methods)))

I’m even going to go one step further for single-argument functions where I want to override the body for my lazy list of anti-conses using a single form for the body:

(defmacro defun1- (name (arg) a-list-form &body body)
  `(defun- ,name (,arg)
     (:method ((,arg anti-cons-list)) ,a-list-form)
     ,@body))

I need #'cons- to set the stage. I need to be able to cons an anti-cons with a normal list. I need to be able to cons an anti-cons with a list of anti-conses. And, I need to be able to cons something other than an anti-cons with a list of anti-conses.

(defun- cons (a b)
  (:method ((a (eql 'anti-cons)) (b list))
    (if (null b)
        (make-instance 'anti-cons-list)
        (cdr b)))
 
  (:method ((a (eql 'anti-cons)) (b anti-cons-list))
    (make-instance 'anti-cons-list :length (1+ (anti-cons-list-length b))))
 
  (:method (a (b anti-cons-list))
    (let ((b-len (anti-cons-list-length b)))
      (when (> b-len 1)
        (make-instance 'anti-cons-list :length (1- b-len))))))

Now, I can go on to define some simple functions that can take either anti-cons lists or regular Common Lisp lists.

(defun1- length (a) (- (anti-cons-list-length a))
 
(defun1- car (a) :anti-cons)
 
(defun1- cdr (a)
  (let ((a-len (anti-cons-list-length a)))
    (when (> a-len 1)
      (make-instance 'anti-cons-list :length (1- a-len)))))
 
(defun1- cadr (a) (when (> (anti-cons-list-length a) 1) :anti-cons))
(defun1- caddr (a) (when (> (anti-cons-list-length a) 2) :anti-cons))

To give a feel for how this all fits together, here’s a little interactive session:

ANTI-CONS> (cons- anti-cons nil)
#<(ANTI-CONS)>
 
ANTI-CONS> (cons- anti-cons *)
#<(ANTI-CONS ANTI-CONS)>
 
ANTI-CONS> (cons- :a *)
#<(ANTI-CONS)>
 
ANTI-CONS> (length- *)
-1

Denouement

Only forty or fifty lines of code to go from:

(divide (rest polynomial) (first polynomial) nil)

To this:

(divide polynomial 0 (cons anti-cons nil))

Definitely worth it.

What are Complex Numbers

Say you’re playing around with polynomials. You start playing with the equation . WIth a little fiddling, you find this is equivalent to . Then, you take the square root of both sides to find that . We started with a polynomial equation in one variable in which the highest exponent was two and we found two answers.

Pounding your chest and sounding your barbaric yawp, you move on to . This should be easy, right? With the same fiddling, we find and then .

Uh-oh. What do we do now? We can’t think of any number that when multiplied by itself gives us a negative number. If we start with zero, we end with zero. If we multiply a positive number by itself, we get a positive number. If we multiply a negative number by itself, we get a positive number. Again!

So, how do we get around this? We pull an ace out of our sleeve. We just run with the idea that there is such a number and see where it takes us. We say, There is a number such that . Everything else is going to stay the same.

Where does this take us? It turns out, it takes us very, very far. For starters, our equation , a polynomial equation in one variable where the highest exponent is two, now has two answers: .

What about ? It is a polynomial equation in one variable where the highest exponent is two. It’d be pretty spiffy if there were two answers. With the same manipulation as before, we find that .

Now, we need to remember that if and are positive numbers, then . Let’s see what happens if we extend this to allow our new number . If we said that , then . What happens if we multiply ? When we multiply real number , , and , we can do it in any order. We could do or or (or three other orders). Well, let’s assume for now that when we multiply by a real number, we can do it in either order. Then . That’s exactly what we were hoping it would be.

Good. Our equation is a polynomial equation in one variable where the highest exponent is two and it has two solutions .

As it turns out, by adding in (and real number multiples of ) to our real numbers, we have the complex numbers. These complex numbers are an algebraic completion of the real numbers. That’s just a fancy way of saying that if you make a polynomial equation in one variable where all of the coefficients are real numbers and the highest exponent is , then there will be solutions to the equation all in the complex numbers.

[It turns out that the complex numbers are algebraically complete themselves. If you make a polynomial equation in one variable where all of the coefficients are complex numbers and the highest exponent is , then there will be solutions to the equation in the complex numbers.]

A Quick Review of Complex Arithmetic

Above, we decided to say that is and go from there. We also used the idea that to find square roots of all negative numbers. And, we already played around a little bit with multiplying some numbers together. Let’s take a step back for a moment though and just add.

We still want the rest of our algebra to work. Because of that, we don’t have much choice for how imaginary numbers add together. If we take any number and add it to itself, we get . We still want that to be true when or . In general, then, we will need for any numbers , , and .

Earlier, we multiplied . What if we add one to ? Well, we can definitely write this as just like we can add one to two by just writing . In the latter case, we already have a name for . We could instead write .

We don’t already have a name for . How do we know? Well, let us assume that is some real number or some real number times . If it is some real number, we should get a positive real number when we square it. If it is a real number times , we should get a negative real number when we square it. But, if we multiply (using the old Firsts, Outers, Inners, Lasts method), we get which is not a positive real number or a negative real number.

As it happens, all of our complex numbers will have the form: for some real numbers and . When we go to add two numbers together, we just add the corresponding pieces: .

For a complex number , we call the real part and the imaginary part. When we add two complex numbers, we add the real parts together and we add the imaginary parts together. Subtraction, likewise, goes by part. If we want , we subtract the real parts and subtract the imaginary parts to obtain .

When we multiply two numbers together, we do it like we did with above with the FOIL method. . We rearrange the orders of some of the bits as we did with above to get: . And since , we have:

Transforming the Plane

You’ll notice above that a complex number is made up of two real numbers (and, of course, ). Every point in the plane has two real numbers as coordinates. We can co-opt the real numbers in the complex number to use as coordinates for points in the plane. If our points are: , , , , then we can represent them as complex numbers with , , , .

We can plot these just as we would their normal coordinates if we put the real part on the x-axis and the imaginary part on the y-axis. This is called an Argand Diagram.

Suppose now we want to translate all of our points by five units along the x-axis and negative two units along the y-axis. We can simply let and then add this to each of our points so that .

Imagine instead that we want to scale the plane radially out from the origin by a factor of three. We can simply multiply each of our points by so that . If we want to scale outward from instead, we could translate by , scale by , and then translate back.

Suppose now that we’d like to rotate the plane by some angle around the origin. For that rotation, a point should get rotated to the point . That is to say: the complex number should get rotated to the complex number .

Let’s look back to our equation for multiplying two complex numbers:

We can see the similarity to the rotation. If we take , then we get precisely: .

The points are the points on the unit circle centered at the origin. So, if we want to rotate all of our points by an angle around the origin, we simply have to multiply them by the point on the unit circle that is at angle around the origin from the x-axis: so that . Again, if we want to rotate around the point , we simply translate by , rotate by , and translate back again.

So, now we can translate points in the plane with complex addition (or subtraction). We can scale points in the plane by multiplying by a real number. We can rotate the plane by multiplying by a complex number.

Conformal maps

There are some other transformations that naturally arise from complex arithmetic. A conformal transform is one that keeps angles constant. All of the transformations we’ve done above are conformal. If you translate the whole plane, the angles between lines are unchanged. If you scale the whole plane, the angles between lines are unchanged. If you rotate the whole plane, the angles between lines are unchanged.

As it happens, a transformation of the complex plane is a conformal map if and only if the transformation has a (complex) derivative everywhere and that derivative is non-zero everywhere. Without getting into complex derivatives here, suffice it to say, they’re pretty much just like real derivatives for simple polynomials. Let’s look at our cases above. The derivative of translating by is which exists everywhere and is non-zero everywhere. The derivative of multiplying by (or ) is (or ). This exists everywhere and is non-zero everywhere (if anywhere).

Another conformal transformation of the complex plane is the Möbius transformation. The Möbius transformations preserve angles where lines meet, but they generally turn lines into curves. The Möbius transformations are of the form: for complex numbers , , , and (so long as ). You can see the Möbius transform in action on YouTube.

What’s next

Next, we’re going to see how Clifford algebras can represent all we have done here. But, that is for another day.

My post yesterday about the Mandelbrot set got me thinking again about iterated functions. With the Mandelbrot set, you start with some complex number and with . Then, you generate by doing .

Here’s another way to write this iteration. Let . Let and and . In general, we write to mean when there are copies of . It is easy to verify then that .

The Jam

For that post, I generated the image linked at the right here. Each level of that image represents one iteration of with each strand made up of four different functions with neighboring ‘s.

One of the annoying things about that image is that I went directly from one iteration to the next. I had pondered using conventional splines or other polynomials to interpolate between iterations in an effort to smooth out the transitions. I didn’t go to the trouble for it though because any straightforward interpolation would be every bit as fake as the linear version. There is no provision in the iteration for unless is a non-negative integer.

Now the question is, can we fake one? Can we make some other function so that ?

Faking easy functions

Let’s start with an easier function. In fact, let’s start with the easiest function: . It is obvious that for all positive integers . As such, if we let , it is trivially true that . But, that was too easy.

Maybe will be harder? No. Again, .

Faking translations

Let’s move up to something a little trickier. Let’s say that for some constant . Now, we see that . What are we going to try for then? Let’s try the obvious: . Hooray! . So, it makes sense then to think of as . Similarly, we can think of as for all positive integers . In this way, we can make values for any positive rational number .

Faking translations with scaling

Now, we’re cooking. Let’s up the ante. Let’s try . What are we going to try for then? Let’s guess we can still use roughly the same form: . Then, . If we want , then we need and . This means that and . In particular, notice that if and are both real numbers with less than zero, then is pure imaginary and is complex.

TTFN

I have much more to say about iterated functions, but I will save some for the next iteration. Next time, I will start with that last case and calculate for rational .

It occurred to me shortly after writing that code that I could easily extend it to include the value of its integral over a certain range. I didn’t get to tackling that right away, and that was a Good Thing. In the intervening time, it occurred to me that I could extend it to moments as well.

So, are you looking for a polynomial that is zero at both zero and one, has a derivative of zero at one, has a second derivative of negative one at one, whose integral from zero to one is one, and whose mean (first moment centered at zero) on the interval zero to one is one fourth?

(polynomial-to-string
  (calculate-polynomial-subject-to
    (value :at 0 :equals 0)
    (value :at 1 :equals 0)
    (derivative :at 1 :equals 0)
    (nth-derivative 2 :at 1 :equals -1)
    (integral :from 0 :to 1 :equals 1)
    (mean :from 0 :to 1 :equals 1/4)))

Well, that would be . (For some reason though, gnuplot thinks , so no graph for you…)

Here is the source file.

Edit: I realized that gnuplot was off by one because it was truncating the fractions. So, I just changed the 4′s in the denominators to 4.0′s and Bob’s your uncle.

The easiest way to do this is to just warp it to where it’s supposed to go. This isn’t very visually pleasing. The next best thing is to set up a time-interval on which it moves into place. Then, linearly interpolate from where it is to where it’s going (here with normalized to range between zero and one):

That’s much better than just warping, but it doesn’t have any sort of fade-in or fade-out. It instantaneously has its maximum velocity and then instantaneously stops at the end.

Typically, then one uses a cubic spline to scale the value before interpolating to get a speed up in the beginning and then slow down in the end.

I might like to decelerate faster than I accelerate though so I might employ a fancier (higher-order) polynomial like:

But, in this case, I wanted the tile to overshoot the target a bit and then nestle/wiggle into place. So, I experimented with a bunch of different polynomials. I was having real trouble getting them to behave in a way that felt right. So, I went back to the physics of it.

What I wanted was pretty similar to damped spring motion. Imagine you’ve tied a heavy weight to a spring and suspended it all in a jar of oil. If you perturb the weight, it will bounce up and down but
each bounce is closer to the equilibrium point than the previous bounce. (Actually, it’s more complicated than that. If the spring is too weak or the oil too viscous, the weight will just slowly return to the equilibrium point without ever going past it. That’s called overdamped harmonic oscillation. What I want is called underdamped harmonic oscillation and that’s all I will concern myself with here.) The equation for this motion is:

To get it to wiggle an appropriate amount, I was using and effectively making the cosine into a sine.

This is all well and good, but to really scale my t, I need this to start at zero and approach one. So, I was really using:

Well, now it starts zig-zagging on the way to its destination. It already starts cutting back long before it makes it to where it’s going. I needed to get close to the destination much sooner. So, I jiggered the term:

This looks terrible though. I hit the destination is less than a tenth of a second and then not again until about half a second. The reason for this is that the oscillations happen at a fixed rate. never changes and moves steadily along so that keeps the same frequency throughout my interval. So, I jiggered the going into the sine function to make my oscillations start out slowly and really speed up toward the end.

This is much better, but it still didn’t give the feeling of settling in because the second oscillation was almost as high as the first. I could up the value of and get somewhere. But, I wanted it to be even more dramatic. So, I changed the in the exponent to (and used a slightly higher : was 3 and is now 4):

This was pretty decent, but I felt the initial attack was a bit strong. So, I dropped down the exponent on my base curve from 4 to 2:

This is pretty nice. It looks pretty natural (despite making an entire mess out of damped harmonic motion). It doesn’t ease in at all though so I might still need to replace the with something of a higher order. But, I might not mind the tile achieving instant velocity. It gives it that I’m really supposed to be over there sort of urgency.

Today, I was having trouble getting the conditions specified enough to get the sort of polynomial that I was expecting. After finding the coefficients for several sixth degree polynomials in a row, I figured I should instead be able to do something like this with the proper lisp:

(calculate-polynomial-subject-to
    (value :at 0 :equals 0)
    (derivative :at 0 :equals 0)
    (nth-derivative 2 :at 0 :equals 0)
    (value :at 1 :equals 1)
    (derivative :at 1 :equals 0)
    (nth-derivative 2 :at 1 :equals 0)
    (value :at 1/2 :equals 3/4))

That’s all done now (polynomials.lisp). So, for the record, the above is: . That is still not quite the polynomial I want for this application, but it’s close. A few minutes of Lisp saved me hours of whiteboard work.