Some notes on GA rotors. This isn't trying to explain them particularly hard, so you
probably need to already know what they are to understand it.

Rotation by a rotor:
	v' = R v ~R

	That is, the rotated vector is the result of multiplying it by the rotor R and its reverse.

A rotor is:
	A unit bivector indicating the plane within which the rotation occurs and the direction.
	A scalar indicating how much rotation to perform. (Specifically, the cosine of the radian angle of rotation.)

One view of a rotor is as:

	R = cos(t/2) + B sin(t/2)

	Where B is a bivector indicating the plane of rotation and the direction of rotation

Another view is as:

	R**2 = (from 'dot' to) + (from ^ to)

	Where from and to are unit vectors.

	This is evident from the following view of the inner and outer product:

		from 'dot' to = ||from|| ||to|| cos(theta)
		||from ^ to|| = ||from|| ||to|| |sin(theta)|

	Note that the rotor is squared, since theta in dot and ^ are not divided by 2.

It may be interesting to note that given a rotor that rotates by angle q, you can construct a rotor that rotates by angel 2q by squaring the rotor

	R' = R**2

	This is derived straight-forwardly by trig identities:

		R = cos(a/2) + sin(a/2) B

		R**2 = (cos(a/2) + sin(a/2) B)**2

			Expand

		R**2 = cos2(a/2) + 2 cos(a/2) sin(a/2) B + sin2(a/2) B**2

			Note that B is a unit bivector, and unit bivectors square to -1

		R**2 = cos2(a/2) - sin2(a/2) + 2 cos(a/2) sin(a/2) B

			Finally, by the double angle identities

		R**2 = cos(a) + sin(a) B

To construct a rotor given two vectors 'from' and 'to' which rotates 'from' into 'to', you must construct it such that theta is properly divided by 2.

	R = sqrt((from 'dot' to) + (from ^ to))

		This yields two possible rotors, one that rotates by half as much as R through the same path,
		and one which rotates through a 360 degree loop to the same position as the first.

		This is due to the double-cover space that rotors lie on.

		Taking the positive root will yield the rotor you expect.

	Or, equivalently.

		Q = 1 + (from 'dot' to) + (from ^ to)
		R = Q / ||Q||

			where ||Q|| is the magnitude of the rotor Q

You can construct a reverse rotation from a rotor R by negating the bivector component

	~R = (from 'dot' to) - (from ^ to)

	Or, equivalently:

		R = s + t B
		~R = s - t B

	Or, equivalently:

		R = cos(t/2) + sin(t/2) B
		~R = cos(t/2) - sin(t/2) B

To multiply a rotor by a vector, expand the multivector forms of each

	v = v.x e1 + v.y e2 + v.z e3

	R = s + r1 e12 + r2 e23 + r3 e13 <- note the choice of e13 rather than e31. This is what gives rise to a right-handed vs left-handed coordinate system

	R v =
		s v.x e1 + s v.y e2 + s v.z e3
		+ r1 e12 v.x e1 + r1 e12 v.y e2 + r1 e12 v.z e3
		+ r2 e23 v.x e1 + r2 e23 v.y e2 + r2 e23 v.z e3
		+ r3 e13 v.x e1 + r3 e13 v.y e2 + r3 e13 v.z e3

	Simplification is possible, but left as an exercise to the masochistic.


The full, simplified piece-wise computation in R3 is.

	v' =
		v'.x = v.x (r1 r1 + r2 r2 - r3 r3 - r4 r4) + v.y 2 (r2 r3 - r1 r4) + v.z 2 (r2 r4 + r1 r3)
		v'.y = v.x (r2 r3 + r1 r4) + v.y 2 (r1 r1 - r2 r2 + r3 r3 - r4 r4) + v.z 2 (r2 r3 + r1 r4)
		v'.z = v.x (r2 r4 - r1 r3) + v.y 2 (r3 r4 + r1 r2) + (r1 r1 - r2 r2 - r3 r3 + r4 r4)