./geoma1.0.2000.05.17/004075500007730000024000000000000711060273300132065ustar00patarg00001250000004./geoma1.0.2000.05.17/nw/004075500007730000024000000000000711060023700136275ustar00patarg00001250000004./geoma1.0.2000.05.17/nw/geoma.nw010064400007730000024000000633760711057502500153070ustar00patarg00001250000004\section{Introduction} The geometric algebras or Clifford algebras are very useful in a variety of areas. There are some packages out there to deal with them in Maple and Java and such. But, to our knowledge, this is the only publically available C++ template class to implement them. The Clifford algebra $\clifford_{p,q}$ is an algebra generated by vectors from a quadratic space. The first $p$ unit vectors contribute positively to the norm and the other $q$ unit vectors contribute negatively to the norm. For unit vectors $\vec{e}_i$ and $\vec{e}_j$, \begin{equation} \label{eq:unit_multiplication} \vec{e}_i\vec{e}_j = \vec{e}_{ij} = \left\{ \begin{array}{rl} 1 & \quad 1 \leq i=j \leq p \\ -1 & \quad p < i=j \leq p+q \\ -\vec{e}_j\vec{e}_i = -\vec{e}_{ji} & \quad i\neq{}j \end{array} \right. \end{equation} In other words, a vector $\vec{r} = \sum_{i=1}^{p+q} a_i\vec{e}_i$ obeys \begin{equation} \label{eq:vector_squared} \vec{r}\vec{r} = \vec{r}^2 = \left<\vec{r},\vec{r}\right> = \sum_{i=1}^{p}a_i^2 - \sum_{i=p+1}^{p+q} a_i^2 \end{equation} All of the cross terms here cancel out because $\vec{e}_{ij} = -\vec{e}_{ji}$ when $i \neq j$. In a general multiplication of two vectors $\vec{a}$ and $\vec{b}$, these terms do not cancel out. But, because of the anticommutativity of the cross-terms, we can always sort the order of the subscripts and only affect the sign of the coefficient. For example: \begin{eqnarray*} \vec{e}_{3142} & = & -\vec{e}_{3124} \\ & = & \vec{e}_{1324} \\ & = & -\vec{e}_{1234} \end{eqnarray*} And, identical subscripts annihilate each other when adjacent. For example, in $\clifford_{1,3}$ \begin{eqnarray*} \vec{e}_{2142} & = & -\vec{e}_{2124} \\ & = & \vec{e}_{1224} \\ & = & -\vec{e}_{14} \end{eqnarray*} and \begin{eqnarray*} \vec{e}_{2141} & = & -\vec{e}_{2114} \\ & = & -\vec{e}_{24} \end{eqnarray*} \pagebreak[2] There are some excellent introductions to Clifford algebras available on the web. Some of these are:\nopagebreak \begin{itemize} \item [[http://www.mrao.cam.ac.uk/~clifford]]---The Geometric Algebra Group at Cambridge \item [[http://www.hit.fi/~lounesto]]---Pertti Lounesto whose excellent book \textit{Clifford Algebras and Spinors} got me started with Clifford algebras. \item [[http://www.clifford.org]]---The International Clifford Algebra Society (though this page is fairly out of date). \end{itemize} The class implemented in this document is a template class that requires three template parameters: the data type for scalars, the value of $p$, and the value of $q$. The data type for scalars must support addition, subtraction, multiplication, assignment from another member of the same type, and assignment from the integer $0$. The multiplication need not be commutative. \section{The [[GeometricAlgebra]] Template Class} This is the main template class generated in this document. It implements addition of a multivector and scalar, subtraction of a scalar from a multivector, and (left or right) multiplication of a multivector by a scalar. It implements the negation, addition, subtraction, multiplication, coefficient access, grade-involution, reversion, and conjugation of arbitrary elements of $\clifford_{p,q}$. \subsection{Data Members} \label{indices} The coefficients of the various $k$-forms are stored in an array. The array has to contain $2^{p+q}$ coefficients. These are the ${p+q} \choose k$ $k$-forms for all $0 \leq k \leq p+q$. The binary digits of the index specify which unit vectors make up this $k$-form. A $k$-form will have $k$-bits set in the index. Because every $k$-form can be reordered with transpositions (with a possible change of sign), we only need to track which unit vectors compose a given $k$-form. We do not need to track the order in which they appear. The $n$-th bit of the index will specify the unit vector $\vec{e}_{n+1}$. Here are some examples of $k$-forms from $\clifford_{1,3}$ and their indices in base $2$ and base $10$. \begin{equation} \label{eq:sample_k-forms} \begin{array}{rcccr} \vec{1} & = & \texttt{0000}_2 & = & 0_{10} \\ \vec{e}_{2} & = & \texttt{0010}_2 & = & 2_{10} \\ \vec{e}_{23} & = & \texttt{0110}_2 & = & 6_{10} \\ \vec{e}_{14} & = & \texttt{1001}_2 & = & 9_{10} \\ \vec{e}_{134} & = & \texttt{1101}_2 & = & 13_{10} \\ \vec{e}_{1234} & = & \texttt{1111}_2 & = & 15_{10} \end{array} \end{equation} So, the array of coefficients must hold $2^{p+q}$ elements of the data type [[Type]] given to the template. <>= Type coef[ 1U << (P+Q) ]; @ \subsection{Methods} Herein lie the implementations of the constructor, the coefficient accessor, the addition, subtraction, multiplication, and various involutions. \subsubsection{Constructor} In the constructor for the [[GeometricAlgebra]] template class, we simply initialize all of the coefficients to zero if the [[init]] parameter is [[true]]. The [[init]] parameter defaults to [[true]]. But, we allow one to skip initialization in order to allow one to optimize out the initialization of things that will just be assigned over immediately. This is especially useful if assigning the integer $0$ to an element of type [[Type]] is expensive. <>= GeometricAlgebra( bool init = true ) { if ( init ) { for ( unsigned int ii=0; ii < ( 1U << (P+Q) ); ++ii ) { coef[ii] = 0; } } } @ \subsubsection{Copy Constructor} In the copy constructor for the [[GeometricAlgebra]] template class, we employ the use of the assignment operator. <>= inline GeometricAlgebra( const GeometricAlgebra& b ) { *this = b; } @ \subsubsection{Assignment Operator} In the assignment operator for the [[GeometricAlgebra]] template class, we employ the use of the assignment operator for [[Type]] and simply copy the coefficients. <>= inline GeometricAlgebra& operator =( const GeometricAlgebra& b ) { for ( unsigned int ii=0; ii < ( 1U << (P+Q) ); ++ii ) { coef[ii] = b.coef[ii]; } return *this; } @ \subsubsection{Coefficient Accessors} In the coefficient accessor, we make sure that the index is within the valid range. If it is too big, we huck an exception. Otherwise, we return the requested coefficient. <>= inline Type& operator [] ( const unsigned int index ) { if ( index >= ( 1U << (P+Q) ) ) { throw out_of_range( "index" ); } return coef[ index ]; } @ And, we made a [[const]] version of the same thing. <>= inline const Type& operator [] ( const unsigned int index ) const { if ( index >= ( 1U << (P+Q) ) ) { throw out_of_range( "index" ); } return coef[ index ]; } @ \subsubsection{Addition} The addition of a multivector and a scalar is quite simple. We simply add the scalar to the zero-th coefficient of the multivector. <>= template inline GeometricAlgebra operator + ( const GeometricAlgebra& a, const Type& b ) { GeometricAlgebra c = a; c[0] = a[0] + b; return c; } @ And, left-addition of a scalar is basically the same thing. <>= template inline GeometricAlgebra operator + ( const Type& a, const GeometricAlgebra& b ) { GeometricAlgebra c = b; c[0] = a + b[0]; return c; } @ The addition of two multivectors is fairly straightforward. We simply add the corresponding components. <>= template inline GeometricAlgebra operator + ( const GeometricAlgebra& a, const GeometricAlgebra& b ) { GeometricAlgebra c(false); for ( unsigned int ii=0; ii < ( 1U << (P+Q) ); ++ii ) { c[ii] = a[ii] + b[ii]; } return c; } @ \subsubsection{Subtraction} The subtraction of a scalar from a multivector is quite simple. We simply subtract the scalar from the zero-th coefficient of the multivector. <>= template inline GeometricAlgebra operator - ( const GeometricAlgebra& a, const Type& b ) { GeometricAlgebra c = a; c[0] = a[0] - b; return c; } @ At this point, we have opted not to subtract multivectors from scalars. If you want this functionality, you will just have to employ left-scalar addition and multivector negation. The subtraction of two multivectors is fairly straightforward. We simply subtract the corresponding components. <>= template inline GeometricAlgebra operator - ( const GeometricAlgebra& a, const GeometricAlgebra& b ) { GeometricAlgebra c(false); for ( unsigned int ii=0; ii < ( 1U << (P+Q) ); ++ii ) { c[ii] = a[ii] - b[ii]; } return c; } @ \subsubsection{Negation} The negation of a multivector is quite straightforward. We simply negate each coefficient of the multivector. Rather than require the [[Type]] of the coefficients to support unary negation, we will just subtract from a zero scalar. <>= template inline GeometricAlgebra operator - ( const GeometricAlgebra& a ) { GeometricAlgebra b(false); Type zero = 0; for ( unsigned int ii=0; ii < ( 1U << (P+Q) ); ++ii ) { b[ii] = zero - a[ii]; } return b; } @ \subsubsection{Grade Involution} The grade involution of a multivector is a bit funky. It toggles the sign of every coefficient of an odd-graded element. In code, this amounts to wheter the bottom bit of the grade is set. Rather than require the [[Type]] of the coefficients to support unary negation, we will just subtract it from a zero scalar. <>= inline GeometricAlgebra GradeInvolution( void ) const { GeometricAlgebra a(false); Type zero = 0; for ( unsigned int ii=0; ii < ( 1U << (P+Q) ); ++ii ) { if ( ( GetGrade( ii ) & 1 ) != 0 ) { a[ii] = zero - coef[ii]; } else { a[ii] = coef[ii]; } } return a; } @ \subsubsection{Reversion} The reversion of a multivector is fairly hairy. It reverses the order of the subscripts for each $k$-form. For example, the $3$-form $\vec{e}_{123}$ becomes $\vec{e}_{321} = -\vec{e}_{123}$ while the $4$-form $\vec{e}_{1234}$ does not change signs. Now, the sign only depends upon the odd-ness or even-ness of the number of transpositions required to get things back in order. This obeys a simple recurrance relationship. Let $T(n)$ be the number of transpositions required to revert an $n$-form. Then, we can see that $T(n+1) = T(n) + n - 1$ because it will require $T(n)$ transpositions to reorder the first $n$ subscripts and $n-1$ transpositions to get the $n+1$-th subscript from one end of the list to the other. With this recurrence relationship, we can see that the odd-ness or even-ness of $T(n+4)$ is the same as that of $T(n)$, because \begin{eqnarray*} T(n+4) & = & T(n+3) + n + 2 \\ & = & T(n+2) + 2n + 3 \\ & = & T(n+1) + 3n + 3 \\ & = & T(n) + 4n + 2 \end{eqnarray*} And, because $T(0)$ and $T(1)$ are even while $T(2)$ and $T(3)$ are odd, we have that an $n$-form requires an odd number of transpositions to revert iff $n \equiv 2$ or $n \equiv 3$ modulo $4$. In code, this translates to whether the second bit of the grade is set. <>= inline GeometricAlgebra Reversion( void ) const { GeometricAlgebra a(false); Type zero = 0; for ( unsigned int ii=0; ii < ( 1U << (P+Q) ); ++ii ) { if ( ( GetGrade( ii ) & 2 ) != 0 ) { a[ii] = zero - coef[ii]; } else { a[ii] = coef[ii]; } } return a; } @ \subsubsection{Conjugation} The conjugation of a multivector is a grade involution and a reversion (in either order). Thus, this code is similar to the code in the previous two sections. The sign of the coefficient changes iff either but not both of the grade involution and reversion would change it. <>= inline GeometricAlgebra Conjugation( void ) const { GeometricAlgebra a(false); Type zero = 0; for ( unsigned int ii=0; ii < ( 1U << (P+Q) ); ++ii ) { switch ( GetGrade( ii ) & 3 ) { case 0: case 3: a[ii] = coef[ii]; break; case 1: case 2: a[ii] = zero - coef[ii]; break; } } return a; } @ \subsubsection{Multiplication} The multiplication of a multivector by a scalar is rather straightforward. We simply multiply each coefficient in the multivector by the scalar. <>= template inline GeometricAlgebra operator * ( const GeometricAlgebra& a, const Type& b ) { GeometricAlgebra c; for ( unsigned int ii=0; ii < ( 1U << (P+Q) ); ++ii ) { c[ ii ] = a[ ii ] * b; } return c; } @ Here, since multiplication need not be commutative in [[Type]], we must take to preserve this. <>= template inline GeometricAlgebra operator * ( const Type& a, const GeometricAlgebra& b ) { GeometricAlgebra c; for ( unsigned int ii=0; ii < ( 1U << (P+Q) ); ++ii ) { c[ ii ] = a * b[ ii ]; } return c; } @ The multiplication of two multivectors is a bit more complicated. Here, we have to sum up all of the terms that contribute to each coefficient in the product. Fortunately, with the index-scheme that we defined in \ref{indices} on page \pageref{indices}, the product of the $i$-th term of the first vector and the $j$-th term of the second vector contributes to the $i \otimes j$ coefficient where $\otimes$ is a bitwise [[XOR]]. The sign of the product is stored in the [[GeomMultTable]]. <>= template inline GeometricAlgebra operator * ( const GeometricAlgebra& a, const GeometricAlgebra& b ) { GeometricAlgebra c; for ( unsigned int ii=0; ii < ( 1U << (P+Q) ); ++ii ) { for ( unsigned int jj=0; jj < ( 1U << (P+Q) ); ++jj ) { unsigned int index = ( ii ^ jj ); if ( c.IsPositive( ii, jj ) ) { c[ index ] = c[ index ] + ( a[ ii ] * b[ jj ] ); } else { c[ index ] = c[ index ] - ( a[ ii ] * b[ jj ] ); } } } return c; } @ \subsection{Class} The actual [[GeometricAlgebra]] template class itself inherits from the [[GeomMultTable]] template class which is described in section \ref{sec:geom_mult_table} on page \pageref{sec:geom_mult_table}. The [[GeometricAlgebra]] template class uses the [[GeomMultTable]] template class to maintains the lookup tables that are used in the multiplication, grade involution, reversion, and conjugation. Beyond that, it contains some data members of its own and the methods that were implemented above. <