Application Center - Maplesoft

Quaternions, Octonions and Sedenions

You can switch back to the summary page by clicking here.

Hypercomplex Numbers from the Quaternions to the Sedenions

by Michael Tyrone Browning Carter

Purdue University, West Lafayette

January 18, 2010

Good mathematics is when you let the math guide you rather than you guiding the math. -- Michael T. Carter;

 Description This Hypercomplex package provides the algebra of the quaternion, octonion and sedenion hypercomplex numbers.;
 Disclaimer Feel free to utilize this package for academic, business, or personal use according to Maplesoft's license agreement. However, neither Maplesoft nor I are liable for any errors that may come from this package.  All I ask is that you give me credit.  Please do not reverse engineer this package; it is the ethical thing to do.

Quaternions

A Hamilton Quaternion is a hypercomplex number with one Real part (the scalar) and three imaginary parts (the vector).

This is an extension of the concept of numbers.  We have found that a Real number is a one-part number that can be represented on a number line, and a complex number is a two-part number that can be represented on a plane.  Extending that logic, we have also found that we can produce more numbers by doubling the parts.

Quaternion --> a + b*i + c*j + d*k, where the coefficients a, b, c, d are real numbers

The hypercomplex number-quaternion-is a non-commutative division ring.  This is what we call a four-dimensional number.  Here is an example of a quaternion:  5 + 2i + 3j + 4k.  The first term is called the scalar term; it is simply a real number.  The other terms consisting of, i, j, k. are called the imaginary terms.  As a group, they are called the vector of the quaternion.  Vector algebra uses the same name vector as the quaternion number, but with a different meaning.  Although vector algebra is an offspring of quaternions, vectors are not numbers.  Starting with complex numbers, we lose the permanence of trichotomy.  The permanencies we lose with quaternion numbers are the trichotomy property and the commutative property under multiplication. Additionally the imaginary units are anti-commutative under multiplication.  Anti-commutative means the sign of the imaginary unit changes when we transpose the two operands under multiplication, e.g., i*j = -(j*i).  The imaginary elements, i, j, and k, give cyclic permutations with each other.

If we set the coefficients of the imaginary elements j and k to zero, the quaternion number becomes an ordinary complex number.  We can create all of the other algebraic numbers and the transcendental numbers from the quaternions simply by setting all the coefficients of the imaginary elements to zero.

 History Sir William Rowan Hamilton was born in Dublin, Ireland either on August 3rd or August 4th, 1805. He was born at midnight, so there is some confusion about his birthday.  Hamilton was considered a prodigy.  For some years, he lived in Trim with his uncle, Reverend James Hamilton.  By the age of five, it is claimed that Hamilton knew Latin, Greek, and Hebrew, which he learned from his uncle.  Hamilton was exposed to mathematics at age twelve by an American, Zerah Colburn.  Colburn was able to impress Hamilton by performing amazing mental arithmetic operations. By age 13, Hamilton studied the algebra of the mathematician Alexis Claude Clairaut (Paris, France; 1713 - 1765).  Clairaut's Théorie de la Figure de la Terra (1743), a treatise dealing with the shape of rotating solid bodies, might have been the driving force for Hamilton's direction toward quaternions.  At age 17, Hamilton discovered an error in Laplace's Méchanique Céleste, which brought Hamilton a lot of recognition.  At age 18, Hamilton became a student at Trinity College, Dublin.  He earned an award called Optime in Classics--awarded once every twenty years.     Hamilton married Helen Maria Bayly in Ireland, and together they had two sons and a daughter.  In his publication Theory of System of Rays (1832), he predicted conical refraction via the characteristic function on Fresnel's wave surface.  Hamilton received great fame after Humphrey Lloyd, his physics professor, confirmed experimentally this theoretical prediction.  In 1835, Hamilton was knighted.     The Royal Irish Academy provided an audience for Hamilton's paper on complex numbers as algebraic couples (ordered pairs of Real numbers).  His paper was considered very difficult to understand; this was a curse that plagued all of Hamilton's publications.  However, his focus was expanding the algebra of the complex numbers to triplets.  He could add and subtract triplets, but could not multiply them.  For years his obsession even caught the attention of his children who would ask him every morning, "Well, Papa can you multiply triplets?"  On Monday, October 16, 1843, while Hamilton and his wife were walking along the Royal Canal on his way to a meeting with the Royal Irish Academy, the idea of the quaternions sparked in his mind.  He carved the idea on the surface of the Brougham Bridge:        i^2 = j^2 = k^2 = ijk = -1. Hamilton felt that his discovery of the quaternions in the 19th century was just as important as the fluxions (the calculus) were in the 17th century.  The rest of his life was devoted to elucidating the algebra of the quaternions. However, being plagued with alcoholism and cursed with the inability to communicate his ideas clearly, may have been why quaternions were not taken seriously.  The mathematician, William Thomson (Ireland; 1824 - 1907) wrote:                                            Quaternions came from Hamilton after his really good work had been                                          done, and  though beautifully ingenious, have been an unmixed evil                                          to those who have touched them in any way.
 Applications Rotating objects are probably quaternion numbers' most practical application.  We have an alternate way of rotating objects with another non-commutative algebra, called matrix algebra.  However, matrix algebra, coupled with trigonometric functions, has a defect.  Sometimes we get what one calls a singular matrix.      Mechanical devices, such as gyroscopes, tracking, robot arms, etc., cannot afford to have a singular matrix in the software.  A singular matrix can cause gimbal (or robot) lock.   Gimbal lock occurs when the mechanical device simply locks up (stops working) because one degree of freedom, among the three axes, is lost.  This would be very hazardous for an air force fighter navigation system!   In addition, it could be very costly for an automobile factory that uses robotic arms.  Rotations, via quaternion numbers, do not exhibit the problem of gimbal lock.  Quaternion numbers also will require fewer programming steps than matrix rotation.  Fewer programming steps equate to faster, more efficient and more cost-effective software.     Rotation is also used in computer animation.  As computers become faster, consumers need incentives to purchase the more expensive machines.  Video games offer strong incentives for those who take their leisure seriously.  Interactive video games need effective methods of rotating virtual objects.  For example, the three video games of Tomb Raider I, II, & III take advantage of quaternions.     Matrix algebra utilizes Euler angles.  Euler angles are the rotation angles of the Euclidean (rectangular) coordinate system.  Euler angles specify the rotation of the X, Y, and Z rotation axes.  The Euler angle is the culprit of the singularities in matrix algebra.  In addition, Euler angles produce a jerky and unnatural type of movement.  With quaternions, the rotations are smooth and natural.  This is why Microsoft's programming development software offers software engineers quaternion tools.  Remember quaternions are four dimensions; this is the reason quaternions are more effective and efficient than matrices.  Euler angles only work with the three dimensions of height, length, and width.  However, quaternions have the super ability to produce a rotation on any, of the infinite, axes of a sphere.  A matrix rotation of two axes, requires several operations and only one with quaternions.     Quaternions are also utilized in MRI (Magnetic Resonance Images) and CAT (Computed Axial Tomography), also known as CT (Computed Tomography).  MRI technology utilizes magnetic energy and radio waves in order to produce cross-sectional slice images of the human body.  CAT technology utilizes the x-ray principal.  As x-rays pass through the body, they are attenuated at different levels; this produces a profile of different slices.  MRI and CAT scans perform rigid transformations that are represented by quaternions.  Each quaternion is iterated as an interpolated change that is computed for position and orientation.  In addition, the interpolated rotation is a small-angle approximation of a rotation quaternion that is linear in three parameters.

Availabe Quaternion Functions

 type/quaternion * + - ^ Qabs Qadd Qamplitude Qangle Qarccos Qarccosh Qarccot Qarccoth Qarccsc Qarccsch Qarcsec Qarcsech Qarcsin Qarcsinh Qarctan Qarctanh Qargument Qaxial Qceil Qcolatitude Qconjugate QconvertToFrac Qcos Qcosh Qcot Qcoth Qcsc Qcsch Qdefine QdivLeft QdivRight Qdot Qeval Qsec Qsech Qsignum Qsin Qsinh Qsqrt Qsubtract Qexp Qfloor Qfrac Qicoeff Qinverse QisCommutable QisEqual QisPure QisScalar Qjcoeff Qkcoeff Qlength Qln Qlongitude Qmagnitude Qmodulus QmuPart Qmult Qnorm Qnormalize QphiPart QpolarPart QpolarToRect Qpower QpsiPart Qrand QrectToPolar Qround Qscalar Qtan Qtanh QthetaPart QtoMatrices QtoMatrix Qtrunc Qunit QunitVector Qvector

Getting Started

Getting Started

Here is one way to tell Maple where the package library is located.  This does not affect Maple's system library.  If you have an apple you will not have a C: drive.

In addition, you will use the forward slash and not two double back-slashes.

 > restart;
 > HypercomplexLib :=`C:\\Hypercomplex\\Hypercomplex.mla`;
 > libname:=HypercomplexLib,libname; ### now Maple will find the lib
 >
 (1)

Here we load the package.  Notice that the semi-colon is on the end of the command. The semi-colon forces the command to be verbosed.  If you do not want the verbose mode then use a colon for quiet mode for the command.

The package is displaying all functions available to the user.  In addition, the operators *, +, -, and ^ are overloaded by the package.  The user will know this by seeing the operators being displayed.

 > with(Hypercomplex);
 (2)

Quaternion Lesson

Quaternions Lession

The quaternions have four components. u, i, j and k.  These components are protected by the package so that the package can properly work.

You will get an error message if you try to assign values to these components.

Be advised that you will lose the values to your variables if you have values assigned to these components.

 > setHypercomplex(quaternion);
 (3)
 > getHypercomplex();
 (4)
 > i := 5;
 >
 > j := 5;
 >
 > k := 5;

The u component is the scalar component.  The i, j, and k components are the imaginary components.

You do not have to use the u component.  You may just use the Reals, instead.

 > u*u;
 (5)
 > i*i;
 (6)
 > j*j;
 (7)
 > k*k;
 (8)

The   u, scalar, component is always multiplicative commutative with the other components.  However, all three imaginary components are not multiplicative commutative.  In fact, they are anti-commutative.  Anti-commutative means when we change the order the sign will change.

In addition, noticed that the imaginary components are cyclic.  When we multiply i*j we get k.  When we multiply j*k we get i.  And, when we multiply k*i we get j.

 > u*i;
 (9)
 > i*u;
 (10)
 > i*j;
 (11)
 > j*i;
 (12)
 > j*k;
 (13)
 > k*j;
 (14)
 > k*i;
 (15)
 > i*k;
 (16)
 > QisCommutable(2,-5);
 (17)
 > QisCommutable(i,-17);
 (18)
 > QisCommutable(i,j);
 (19)
 > QisCommutable(u,k);
 (20)
 > QisCommutable(4+5*i+6*j+10*k, Qconjugate(4+5*i+6*j+10*k));
 (21)

Another way to see that the imaginary components are cyclic, is to raise then each to an increased power.  The scalar component behaves like the number one.  Raisng one to any power is still one. We can interchange the u component with the number one, eventhough the calculations do not show it. The u remains there.  The pretty print is just converting it to number one.

When we are working only with one imaginary component at a time notice, that when you raised the imaginary component to zero it is equal to one, but, for every mutiple of 4*n power it will also be one.  For ever 4*n + 1 power we will always get the positve imaginary component back.  For ever 4*n+2 power we will get aways get the -1 back.  Finally, for evey power 4*n+3 we will always get the negative imaginary component back.

 > u^0; i^0; j^0; k^0;
 (22)
 > u^1; i^1; j^1; k^1;
 (23)
 > u^2; i^2; j^2; k^2;
 (24)
 > u^3; i^3; j^3; k^3;
 (25)
 > u^4; i^4; j^4; k^4;
 (26)
 > u^5; i^5; j^5; k^5;
 (27)
 > u^6; i^6; j^6; k^6;
 (28)
 > u^7; i^7; j^7; k^7;
 (29)
 > u^8; i^8; j^8; k^8;
 (30)

We can take any quaternion and make our own special component.  This is called the unit vector.  The unit vector is also cyclic.  Except for the precision error, we are also getting a similar cyclic behavior that we were receiving with the indiviual imaginary components.

 > q  := 1*u + 2*i + 3*j + 4*k;
 (31)
 > qu := QunitVector(q);
 (32)
 > QconvertToFrac(qu^1);
 (33)
 > QconvertToFrac(qu^2);
 (34)
 > QconvertToFrac(qu^3);
 (35)
 > QconvertToFrac(qu^4);
 (36)
 > QconvertToFrac(qu^5);
 (37)

Another example to see anti-commutative is noticed when we multiply the imaginary unit i by a unit vector of obitrary quaternion--notice that the sign on the scalar does not change.  However, on the imaginary components, their signs reverse when we reverse the order of multiplication.

 > q  := 1*u + 2*i + 3*j + 4*k;
 (38)
 > qu := QunitVector(q);
 (39)
 > i*qu;
 (40)

 > qu*i;
 (41)

Here, we are only testing the ln and exp functions.  We are checking to see if the results make good sense.

 > I*3;
 (42)
 > I+3*I;
 (43)
 > q := Qrand(-100,100);
 (44)
 > Qexp(Qln(q));
 (45)
 > Qln(Qexp(q));
 (46)

If we used only one scalar and one imaginary unit,   these components will behave like the ordinary complex numbers.  The ordinary complex numbers are comutative.

However, if we treat them as quaternions, we cannot use the division symbol.  Division is different for left division or for right division for quaternions.  It is this way because quaternions are not commutative.

 > complexI := 1/(23.5 + 15*I);
 (47)
 > complexi := 1/(23.5 + 15*i);
 (48)
 > complexj := 1/(23 + 15*j);
 (49)
 > complexk := 1/(23 + 15*k);
 (50)
 > QdivLeft(complexi,complexj);
 (51)
 > QdivRight(complexi,complexj);
 (52)
 > Qinverse(eval(complexi))*complexj;
 (53)
 > complexi*Qinverse(eval(complexj));
 (54)

Here, we are testing to see if the imaginary components make good sense.

 > i*j*k;
 (55)
 > (i*j)*k;
 (56)
 > i*(j*k);
 (57)
 > j*k*i;
 (58)
 > k*i*j;
 (59)
 > (2+i+j)*(3-j+k)*(-4+i+25*j+12*k);
 (60)
 > ((2+i+j)*(3-j+k))*(-4+i+25*j+12*k);
 (61)
 > (2+i+j)*((3+j+k)*(-4+i+25*j+12*k));
 (62)
 > i*j*k;
 (63)
 > k*j*i;
 (64)

In maple you can test to see what type an element is.

Here,we test to see what a quaternion is.

 > type(2,complex);
 (65)
 > type(I,complex);
 (66)
 > type(2+I,complex);
 (67)
 > type(2, quaternion);
 (68)
 > type(I, quaternion);
 (69)
 > type(2+I+j+k, quaternion);
 (70)
 > type(2+i+j+k, quaternion);
 (71)
 > type(2+i+j+k, complex);
 (72)
 > type([1,2,3],quaternion);
 (73)
 > type({1,2,3}, quaternion);
 (74)
 > type(2*u, quaternion);
 (75)
 > type(2, quaternion);
 (76)
 > type(i, complex);
 (77)
 > type(j, complex);
 (78)
 > type(1-k, complex);
 (79)
 > type(VARIABLE, quaternion);
 (80)
 > type(QtoMatrix(i), quaternion);
 (81)
 > type( Qeval(QtoMatrix(i)), quaternion);
 (82)
 > variable := Qln(1 + 15*i + 23.5*j + 16*k);
 (83)
 > type(variable,quaternion);
 (84)
 > is(5-i+2*j-8*k, quaternion);
 (85)
 > is(5+i+2*j+8*k, quaternion);
 (86)

Now it is time to look under the hood.  What does a quaternion look like in matrix form?

 > q := Qrand(-50,100);
 (87)
 > qm := QtoMatrix(q);
 (88)
 > Qeval(qm);
 (89)
 > Qconjugate(q);
 (90)
 > QtoMatrix( Qconjugate(q));
 (91)
 > Qeval( QtoMatrix( Qconjugate(q)));
 (92)
 > q;
 (93)
 > QtoMatrices(q);
 (94)

Finally, we need to test to see if the trigonmetric functions for quaternions make good sense.  Note, because quaternions are not commutative, we can get different values.  It is always better to do a test to see which composite function is the correct solution.  In this case, the compositive of cos with arccos and sin with arcsin are the correct solutions.

 > q := Qdefine(23.45, 72.45, 98.3, 0.5);
 (95)
 > q := QconvertToFrac(q);
 (96)
 > Qsin(Qarcsin(q));
 (97)
 > Qarcsin(Qsin(q));
 (98)
 > Qcos(Qarccos(q));
 (99)
 > Qarccos(Qcos(q));
 (100)
 > Qsqrt(q);
 (101)
 > evalf(Qsqrt(q)*Qsqrt(q));
 (102)

Octonions

Availabe Octonion Functions

 The following octonion operators and functions are defined in this hypercomplex package type/octonion * + -Ovector Oadd Oconjugate Odefine OdivLeft OdivRight Orand Oeval Oinverse Omult Osubtract OtoMatrices OtoMatrix Oscalar

Octonion Lession

We have components that are protected.  These components are:

i0, i1, i2, i3, i4, i5, i6, and i7.

These are the components that represent the octonions.

 > i0 := 2;
 > i0 := 2;
 > i1 := 2;
 > i7 := 2;

You must be in octonion mode before you can caculate with octonions.

 > i2*i7;
 > setHypercomplex(octonion);
 (103)
 > i2*i7;
 (104)
 > 3*i0;
 (105)
 > i0;
 (106)
 > 5*4*i0;
 (107)
 > 5*4;
 (108)
 >

Notice that the octonions are also cyclic in sets, just like the quaternions.  By being cyclic, it assures that each system is a closed system.

 > i1*i2; i2*i1;
 (109)
 > i2*i3; i3*i2;
 (110)
 > i3*i1; i1*i3;
 (111)
 > i1*i2; -i1*i2; i1*(-i2);
 (112)
 > i4*i5; i5*i4;
 (113)

It is a requirement that all Cayley-Dickson imaginary units equal -1 when squared.

 > i0*i0;
 (114)
 > i1*i1;
 (115)
 > i2*i2;
 (116)
 > i3*i3;
 (117)
 > i4*i4;
 (118)
 > i5*i5;
 (119)
 > i6*i6;
 (120)
 > i7*i7;
 (121)

Just like the Reals, ordinary complex numbers, quaternions, and the octonions are all division algebras.

When you multiply an octonion by its inverse you will get 1.

However, because octonion division is also non-commuative, we have both a left and right division.

 > i2*Oinverse(i2);
 (122)
 > Oinverse(i2)*i2;
 (123)
 > OdivLeft(i2,i2);
 (124)
 > OdivRight(i2,i2);
 (125)
 > OdivRight(i2,i3);
 (126)
 > OdivLeft(i2,i3);
 (127)
 > OdivLeft(2,3);
 (128)
 > OdivRight(2,3);
 (129)
 > 4*Oinverse(5);
 (130)
 > Oinverse(5)*4;
 (131)

Here, we are testing the dot product.  The dot product is made from multiplication, addition and conjugate operators.

The dot product has a longer delay.

 > Odot(2,3);
 (132)
 > Odot(i2,i3);
 (133)
 > Odot(i2,i2);
 (134)
 > o1 := Orand(-100,100);
 (135)
 > Odot(o1,o1);
 (136)
 > evalf( Odot(o1,o1) );
 (137)
 > o2 := Orand(1,1);
 (138)
 > Odot(o2,o2);
 (139)

Now, it is time to look under the hood.  The octonions are hypermatrices. The members are not scalars, but quaternions.

 > o3 := Odefine(1,2,3,4, 5,6,7,8);
 (140)
 > OtoMatrix(o3);
 (141)
 > OtoMatrices(o3);
 (142)
 > o4 := Orand(-10,10);
 (143)
 > OtoMatrix(o4);
 (144)
 > OtoMatrices(o4);
 (145)
 > OtoMatrices( Oconjugate(o4) );
 (146)

Octonions also have a type.

 > type(4,octonion);
 (147)
 > type(i2, octonion);
 (148)
 > type(-3*i7, octonion);
 (149)
 > type(j, octonion);
 (150)
 > type(i8, octonion);
 (151)
 > type(e15, octonion);
 (152)
 > type(I, octonion);
 (153)

Octonions are not generally commutative like the quaternions, but, they are also not generally associative unlike the quaternions.  Notice, that it is possible to get a different value based on how we grouped our multiplication.

 > i1*i2*i3;
 (154)
 > i1*(i2*i3);
 (155)
 > (i1*i2)*i3;
 (156)
 > i1*(i4*i7);
 (157)
 > (i1*i4)*i7;
 (158)
 > i1*i4*i7;
 (159)

We have the ability to isolate the scalar value and vector value from an octonion.  The quaternion has means to isolate all four components.  In this package, we can only isolate the scalar value and the vector value of an octonion at this time.

 > o5 := Orand(-10000,10000);
 (160)
 > Oscalar(o5);
 (161)
 > Ovector(o5);
 (162)

Sedenions

Availabe Sedenion Functions

 The following octonion operators and functions are defined in this hypercomplex package type/sedenion * + - Svector Sadd Sconjugate Sdefine Sdot Srand Seval Smult Ssubtract StoMatrix Sscalar

Sedenion Lession

Components e0 to e15 and O are protected.  In addition, for future work components e0r to e15r are also protected and held reserved.

 > O := 2;
 > e0 := 4;
 > e7 := 15;
 > e15 := 23;

You must be in sedenion mode before you can caculate with the sedenions.

 > e3*e7;
 > setHypercomplex(sedenion);
 (163)
 > e3*e7; e7*e3;
 (164)
 > e15*e7; e7*e15;
 (165)
 > e15*e8; e8*e15;
 (166)
 > e15*e9; e9*e15;
 (167)
 > e15*e10; e10*e15;
 (168)
 > e15*e11; e11*e15;
 (169)
 > e15*e12; e12*e15;
 (170)
 > -(e7*e3); e7*(-e3);
 (171)
 > e1*e2*e3;
 (172)
 > e3*e2*e1;
 (173)
 > s1 := Srand(-5,5);
 (174)
 > s1 + (1/5)*e15;
 (175)

e0 is the component that represents 1, however, it is in matrix form.  Hence, e0 is the same as 1 and 5*e0 is the same as 5.

The square of the imaginary units is equal to negative one.

 > e0*e0;
 (176)
 > e1*e1;
 (177)
 > e2*e2;
 (178)
 > e3*e3;
 (179)
 > e4*e4;
 (180)
 > e5*e5;
 (181)
 > e6*e6;
 (182)
 > e7*e7;
 (183)
 > e8*e8;
 (184)
 > e9*e9;
 (185)
 > e10*e10;
 (186)
 > e11*e11;
 (187)
 > e12*e12;
 (188)
 > e13*e13;
 (189)
 > e14*e14;
 (190)
 > e15*e15;
 (191)

The sedenion is not a divsion algerba.  It is that way because it has zero-divisors.  A zero divsior  is when a does not equal zero and b does not equal zero; however, a times b may be equal to zero.  See the two trivial examples.

 > (e2+e7)*(e4-e14);
 (192)
 > (e3 + e10)*(e6 - e15);
 (193)
 > (e1 + e10)*(e13 - e6);
 (194)
 > a := e3 + e10;
 (195)
 > b := e6 - e15;
 (196)
 > evalb(a = 0);
 (197)
 > evalb(b = 0);
 (198)
 > evalb(a*b = 0);
 (199)

Here, we are testing the dot product function.

The dot product has a longer delay.  You may now have that coffee-break.

 > s1 := Srand(1,1);
 (200)
 > sconj := Sconjugate(s1);
 (201)
 > Sdot(s1,s1);
 (202)
 > Sdot(sconj,sconj);
 (203)

Here, we are testing the scalar and vector functions.

 > s2 := Srand(-100,100);
 (204)
 > Sscalar(s2);
 (205)
 > Svector(s2);
 (206)

Let us look under the hood.  Here, we see that matrices are the elements of the sedenions' hypermatrix.  Actually, we are using octonions for the elements.  But, it is difficult to see this from the current hypermatrix representation.

 > s3 := Srand(-100,100);
 (207)
 > StoMatrix(s3);
 (208)
 > s4 := Srand(1,1);
 (209)
 > StoMatrix(s4);
 (210)

Yes, the sedenion has a type as well.

 > s4 := Srand(-100,100);
 (211)
 > type(s4,sedenion);
 (212)
 > type(5,sedenion);
 (213)
 > type(5*e0, sedenion);
 (214)
 > type(4*e1 - 18*e15,sedenion);
 (215)

 References Maxfield, John E., and Maxfield, Margaret W.  Abstract Algebra and Solution by Radicals.  New York:  Dover, 1971.     Meserve, Bruce E.  Fundamental Concepts Of Algebra.  New York:  Dover, 1981.     Parker, Sybil P.  Dictionary of Mathematics.  New York:  McGraw, 1997.     Rucker, Rudy.  The Fourth Dimension:  A Guided Tour of the Higher Universes.   Boston:          Houghton, 1984.     Russell, Bertrand.  Introduction to Mathematical Philosophy.  New York:  Dover, 1933.     Sanchez, Julio, and Maria Canton.  DirectX 3D Graphics Programming Bible.  Foster City, CA:  IDG Books Worldwide, 2000.                  Shapiro, Max S.  Mathematics Encyclopedia.  Garden City:  Doubleday, 1977.     Smith, D. E.  History of Mathematics.  2 vols.  New York:  Dover, 1958.     Sweetser, Doug.  Doing Physics with Quaternions.  n.p., n.d.  Online.  Internet.  12 December 2000. Available http://world.std.com/~sweetester/quarternions/qindex.html.     Taylor, Edwin F., and John Archibald Wheeler.  Spacetime Physics:  Introduction to Special Relativity.  2nd ed.  New York:  W. H. Freeman, 1996.     Wright, Richard S., Jr., and Sweet, Michael.  OpenGL Super Bible.  2nd ed.  Indianapolis:  Waite Group, 2000.     Wunsch, David A.  Complex Variables with Applications.  2nd ed.  Massachusetts: Addison-Wesley, 1994.   Culbert, Craig.  Cayley-Dickson algebras and loops.  Journal of Generalized Lie Theory and Applications.  Vo1. 1, No. 1, 1-17, 2007.   de Marrais, Robert P. C.  Flying Higher Than a Box-Kite:   Kite-Chain Middens, Sand Mandalas, and Zero-Divisor Patterns in the 2n-ions Beyond the Sedenions. 0207003.pdf

 About the Author School:.........................Purdue University, West Lafayette   Department:.................Computer Science   Course:........................CS-590 - Visualization of Cayley-Dickson Hypercomplex Numbers   Professor:....................Xavier Tricoche, PhD   Student:........................Michael Tyrone Carter   Project:........................Hypercomplex Package   Computer Algebra:......Maple 13   Date:............................Monday, January 18, 2010   Purpose:......................To gain more knowledge on hypercomlex algebra   Email:..........................Laureice@wideopenwest.com     I received a bachelor of science in biology (minor in chemistry) from Lewis University, and am now pursuing a PhD. in Computer Science at Purdue University West Lafayette.  Years ago, I received a certificate in computer programming from the College of Automation in Chicago.  In addition, I received a post-bachelor certificate in information systems, with the programming option, at Purdue University Calumet.  I have completed several projects.  To name a few, I designed an assembler language computer emulator as two applications--one in C/C++ and the other in C#`.  Here, I coded both the assembler and the emulator. Next, I designed an animated mechanical man in Java3D (using quaternions).  Finally, in two of my courses, I had to design a linear programming package and a grammar analyzer package, both of which were written in C#.  I was exposed to quaternions, octonions, and sedenions at the University of Aalborg in Denmark a few years back.  During the spring of 2003, I enrolled in a Maple programming course, and designated quaternions as my project.  The quaternion package was originally written for Maple 8.  Two years later I updated it to Maple 9.5.  My favorite languages are Microsoft Macro Assembler, C#, Java, python, C/C++ with OpenGL and the Maple programming language.  My current hypercomplex package is the first of two projects for a visualization course, which is an independent study that lasted over a year.  It is now completed.