./geoma1.2.2007.08.20/0040755000077300007650000000000010662420035011726 5ustar patpat./geoma1.2.2007.08.20/cross7.cc0100644000077300007650000000334710171604617013466 0ustar patpat#include #include #include #include #include "geoma.h" #include "geomaData.h" enum { E1 = ( 1 << 0 ), E2 = ( 1 << 1 ), E3 = ( 1 << 2 ), E4 = ( 1 << 3 ), E5 = ( 1 << 4 ), E6 = ( 1 << 5 ), E7 = ( 1 << 6 ) }; std::ostream& operator << ( std::ostream& out, nklein::GeometricAlgebra< double, 7 >& vv ) { bool printedSome = false; for ( unsigned int ii=0; ii < (1 << 7); ++ii ) { double dd = vv[ ii ]; if ( ::fabs( dd ) > 0.00001 ) { if ( printedSome ) { out << " + "; } out << dd << " e_{"; for ( unsigned int jj=0; jj < 7; ++jj ) { if ( ( ii & ( 1 << jj ) ) > 0 ) { out << (jj+1); } } out << "}"; printedSome = true; } } if ( ! printedSome ) { out << "0"; } } int main( int argc, const char* argv[] ) { nklein::GeometricAlgebra< double, 7 > vv; vv[ E1|E2|E4 ] = 1.0; vv[ E2|E3|E5 ] = 1.0; vv[ E3|E4|E6 ] = 1.0; vv[ E4|E5|E7 ] = 1.0; vv[ E1|E5|E6 ] = 1.0; vv[ E2|E6|E7 ] = 1.0; vv[ E1|E3|E7 ] = 1.0; nklein::GeometricAlgebra< double, 7 > e1234567; e1234567[ E1|E2|E3|E4|E5|E6|E7 ] = 1; if ( argc != 15 ) { std::cerr << "Must give 14 components representing two 7-d vectors" << std::endl; return __LINE__; } nklein::GeometricAlgebra< double, 7 > aa; nklein::GeometricAlgebra< double, 7 > bb; for ( unsigned int ii=0; ii < 7; ++ii ) { aa[ ( 1 << ii ) ] = ::strtod( argv[ ii+1 ], 0 ); bb[ ( 1 << ii ) ] = ::strtod( argv[ ii+8 ], 0 ); } nklein::GeometricAlgebra< double, 7 > ww( aa ^ bb ); nklein::GeometricAlgebra< double, 7 > cc( ( ww ^ ( vv * e1234567 ) ) * e1234567 ); std::cout << aa << " x " << bb << " = " << cc << std::endl; return 0; } ./geoma1.2.2007.08.20/deps/0040755000077300007650000000000010662377401012671 5ustar patpat./geoma1.2.2007.08.20/geoma.cc0100644000077300007650000001065110662377305013340 0ustar patpat#line 1031 "nw/geoma.nw" #include #include #include #include "geoma.h" #include "geomaData.h" #line 638 "nw/geoma.nw" int main( void ) { nklein::GeometricAlgebra< int, 2, 1 > a; nklein::GeometricAlgebra< int, 2, 1 > b; nklein::GeometricAlgebra< int, 2, 1 > c(false); nklein::GeometricAlgebra< int, 3 > d; nklein::GeometricAlgebra< double, 3 > e; nklein::GeometricAlgebra< std::complex< double >, 3 > f; a[0] = 1; a[1] = 1; a[3] = 1; a[7] = 1; b[1] = 1; b[2] = 1; b[4] = 1; c = a; std::cout << "a = " << #line 709 "nw/geoma.nw" c[0] << " + " << c[1] << "e_1" << " + " << c[2] << "e_2" << " + " << c[4] << "e_3" << " + " << c[3] << "e_{12}" << " + " << c[5] << "e_{13}" << " + " << c[6] << "e_{23}" << " + " << c[7] << "e_{123}" << std::endl #line 659 "nw/geoma.nw" ; c = b; std::cout << "b = " << #line 709 "nw/geoma.nw" c[0] << " + " << c[1] << "e_1" << " + " << c[2] << "e_2" << " + " << c[4] << "e_3" << " + " << c[3] << "e_{12}" << " + " << c[5] << "e_{13}" << " + " << c[6] << "e_{23}" << " + " << c[7] << "e_{123}" << std::endl #line 663 "nw/geoma.nw" ; c = 2 * a - b; std::cout << "2*a - b = " << #line 709 "nw/geoma.nw" c[0] << " + " << c[1] << "e_1" << " + " << c[2] << "e_2" << " + " << c[4] << "e_3" << " + " << c[3] << "e_{12}" << " + " << c[5] << "e_{13}" << " + " << c[6] << "e_{23}" << " + " << c[7] << "e_{123}" << std::endl #line 667 "nw/geoma.nw" ; c = a.GradeInvolution(); std::cout << "\\hat{a} = " << #line 709 "nw/geoma.nw" c[0] << " + " << c[1] << "e_1" << " + " << c[2] << "e_2" << " + " << c[4] << "e_3" << " + " << c[3] << "e_{12}" << " + " << c[5] << "e_{13}" << " + " << c[6] << "e_{23}" << " + " << c[7] << "e_{123}" << std::endl #line 671 "nw/geoma.nw" ; c = a.Reversion(); std::cout << "\\tilde{a} = " << #line 709 "nw/geoma.nw" c[0] << " + " << c[1] << "e_1" << " + " << c[2] << "e_2" << " + " << c[4] << "e_3" << " + " << c[3] << "e_{12}" << " + " << c[5] << "e_{13}" << " + " << c[6] << "e_{23}" << " + " << c[7] << "e_{123}" << std::endl #line 675 "nw/geoma.nw" ; c = a.Conjugation(); std::cout << "\\bar{a} = " << #line 709 "nw/geoma.nw" c[0] << " + " << c[1] << "e_1" << " + " << c[2] << "e_2" << " + " << c[4] << "e_3" << " + " << c[3] << "e_{12}" << " + " << c[5] << "e_{13}" << " + " << c[6] << "e_{23}" << " + " << c[7] << "e_{123}" << std::endl #line 679 "nw/geoma.nw" ; c = b*b; std::cout << "b*b = " << #line 709 "nw/geoma.nw" c[0] << " + " << c[1] << "e_1" << " + " << c[2] << "e_2" << " + " << c[4] << "e_3" << " + " << c[3] << "e_{12}" << " + " << c[5] << "e_{13}" << " + " << c[6] << "e_{23}" << " + " << c[7] << "e_{123}" << std::endl #line 683 "nw/geoma.nw" ; c = a*b; std::cout << "a*b = " << #line 709 "nw/geoma.nw" c[0] << " + " << c[1] << "e_1" << " + " << c[2] << "e_2" << " + " << c[4] << "e_3" << " + " << c[3] << "e_{12}" << " + " << c[5] << "e_{13}" << " + " << c[6] << "e_{23}" << " + " << c[7] << "e_{123}" << std::endl #line 687 "nw/geoma.nw" ; c = b*a; std::cout << "b*a = " << #line 709 "nw/geoma.nw" c[0] << " + " << c[1] << "e_1" << " + " << c[2] << "e_2" << " + " << c[4] << "e_3" << " + " << c[3] << "e_{12}" << " + " << c[5] << "e_{13}" << " + " << c[6] << "e_{23}" << " + " << c[7] << "e_{123}" << std::endl #line 691 "nw/geoma.nw" ; c = a^b; std::cout << "a^b = " << #line 709 "nw/geoma.nw" c[0] << " + " << c[1] << "e_1" << " + " << c[2] << "e_2" << " + " << c[4] << "e_3" << " + " << c[3] << "e_{12}" << " + " << c[5] << "e_{13}" << " + " << c[6] << "e_{23}" << " + " << c[7] << "e_{123}" << std::endl #line 695 "nw/geoma.nw" ; c = b^a; std::cout << "b^a = " << #line 709 "nw/geoma.nw" c[0] << " + " << c[1] << "e_1" << " + " << c[2] << "e_2" << " + " << c[4] << "e_3" << " + " << c[3] << "e_{12}" << " + " << c[5] << "e_{13}" << " + " << c[6] << "e_{23}" << " + " << c[7] << "e_{123}" << std::endl #line 699 "nw/geoma.nw" ; return 0; } ./geoma1.2.2007.08.20/geoma.h0100644000077300007650000002153410662377305013204 0ustar patpat#line 988 "nw/geoma.nw" namespace nklein { namespace nklein_priv { #line 960 "nw/geoma.nw" template class GeomGradeTable { private: #line 888 "nw/geoma.nw" static int gradeTable[ 1U << (N) ]; #line 964 "nw/geoma.nw" protected: #line 907 "nw/geoma.nw" GeomGradeTable() { for ( unsigned ii=0; ii < ( 1U << (N) ); ++ii ) { unsigned int iiBits = 0; #line 924 "nw/geoma.nw" char* ptr = (char*)ⅈ for ( unsigned int kk=0; kk < sizeof(unsigned int); ++kk ) { static const unsigned int lut[] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4 }; iiBits += lut[ ( ptr[kk] >> 0 ) & 0x0F ]; iiBits += lut[ ( ptr[kk] >> 4 ) & 0x0F ]; } #line 912 "nw/geoma.nw" gradeTable[ii] = iiBits; } } #line 966 "nw/geoma.nw" public: #line 944 "nw/geoma.nw" static inline unsigned int GetGrade( unsigned int index ) { if ( index >= ( 1U << (N) ) ) { throw std::out_of_range( "index" ); } return gradeTable[index]; } #line 968 "nw/geoma.nw" }; #line 991 "nw/geoma.nw" #line 859 "nw/geoma.nw" template class GeomMultTable : public GeomGradeTable { private: #line 738 "nw/geoma.nw" static int multTable[ 1U << (P+Q) ][ 1U << (P+Q) ]; #line 863 "nw/geoma.nw" protected: #line 760 "nw/geoma.nw" GeomMultTable() { for ( unsigned ii=0; ii < ( 1U << (P+Q) ); ++ii ) { unsigned int iiInitialTopBits = nklein_priv::GeomGradeTable< P+Q >::GetGrade(ii); for ( unsigned jj=0; jj < ( 1U << (P+Q) ); ++jj ) { unsigned int iiTopBits = iiInitialTopBits; #line 790 "nw/geoma.nw" int sign = 1; for ( unsigned int kk=0; kk < (P+Q); ++kk ) { unsigned int bit = ( 1U << kk ); #line 812 "nw/geoma.nw" if ( ( ii & bit ) != 0 ) { --iiTopBits; } #line 797 "nw/geoma.nw" if ( ( jj & bit ) != 0 ) { sign *= ( iiTopBits & 1 ) ? -1 : 1; if ( ( ii & bit ) != 0 ) { #line 823 "nw/geoma.nw" if ( kk >= P ) { sign *= -1; } #line 802 "nw/geoma.nw" } } } #line 771 "nw/geoma.nw" multTable[ii][jj] = sign; } } } #line 865 "nw/geoma.nw" public: #line 837 "nw/geoma.nw" static inline bool IsPositive( unsigned int ii, unsigned int jj ) { if ( ii >= ( 1U << (P+Q) ) ) { throw std::out_of_range( "first index" ); } if ( jj >= ( 1U << (P+Q) ) ) { throw std::out_of_range( "second index" ); } return ( multTable[ii][jj] >= 0 ); } #line 867 "nw/geoma.nw" }; #line 992 "nw/geoma.nw" }; #line 611 "nw/geoma.nw" template class GeometricAlgebra : public nklein_priv::GeomMultTable { protected: #line 130 "nw/geoma.nw" Type coef[ 1U << (P+Q) ]; #line 617 "nw/geoma.nw" public: #line 152 "nw/geoma.nw" GeometricAlgebra( bool init = true ) { if ( init ) { for ( unsigned int ii=0; ii < ( 1U << (P+Q) ); ++ii ) { coef[ii] = 0; } } } #line 168 "nw/geoma.nw" inline GeometricAlgebra( const GeometricAlgebra& b ) { *this = b; } #line 182 "nw/geoma.nw" inline GeometricAlgebra& operator =( const GeometricAlgebra& b ) { for ( unsigned int ii=0; ii < ( 1U << (P+Q) ); ++ii ) { coef[ii] = b.coef[ii]; } return *this; } #line 200 "nw/geoma.nw" inline Type& operator [] ( const unsigned int index ) { if ( index >= ( 1U << (P+Q) ) ) { throw std::out_of_range( "index" ); } return coef[ index ]; } #line 213 "nw/geoma.nw" inline const Type& operator [] ( const unsigned int index ) const { if ( index >= ( 1U << (P+Q) ) ) { throw std::out_of_range( "index" ); } return coef[ index ]; } #line 366 "nw/geoma.nw" inline GeometricAlgebra GradeInvolution( void ) const { GeometricAlgebra a(false); Type zero = 0; for ( unsigned int ii=0; ii < ( 1U << (P+Q) ); ++ii ) { if ( ( nklein_priv::GeomGradeTable< P+Q >::GetGrade( ii ) & 1 ) != 0 ) { a[ii] = zero - coef[ii]; } else { a[ii] = coef[ii]; } } return a; } #line 423 "nw/geoma.nw" inline GeometricAlgebra Reversion( void ) const { GeometricAlgebra a(false); Type zero = 0; for ( unsigned int ii=0; ii < ( 1U << (P+Q) ); ++ii ) { if ( ( nklein_priv::GeomGradeTable< P+Q >::GetGrade( ii ) & 2 ) != 0 ) { a[ii] = zero - coef[ii]; } else { a[ii] = coef[ii]; } } return a; } #line 453 "nw/geoma.nw" inline GeometricAlgebra Conjugation( void ) const { GeometricAlgebra a(false); Type zero = 0; for ( unsigned int ii=0; ii < ( 1U << (P+Q) ); ++ii ) { switch ( nklein_priv::GeomGradeTable< P+Q >::GetGrade( ii ) & 3 ) { case 0: case 3: a[ii] = coef[ii]; break; case 1: case 2: a[ii] = zero - coef[ii]; break; } } return a; } #line 619 "nw/geoma.nw" }; #line 995 "nw/geoma.nw" #line 230 "nw/geoma.nw" template inline GeometricAlgebra operator + ( const GeometricAlgebra& a, const Type& b ) { GeometricAlgebra c = a; c[0] = a[0] + b; return c; } #line 247 "nw/geoma.nw" template inline GeometricAlgebra operator + ( const Type& a, const GeometricAlgebra& b ) { GeometricAlgebra c = b; c[0] = a + b[0]; return c; } #line 266 "nw/geoma.nw" 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; } #line 290 "nw/geoma.nw" template inline GeometricAlgebra operator - ( const GeometricAlgebra& a, const Type& b ) { GeometricAlgebra c = a; c[0] = a[0] - b; return c; } #line 314 "nw/geoma.nw" 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; } #line 339 "nw/geoma.nw" 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; } #line 485 "nw/geoma.nw" 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; } #line 505 "nw/geoma.nw" 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; } #line 533 "nw/geoma.nw" 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; } #line 571 "nw/geoma.nw" 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 mask = ( ii & jj ); if ( mask == 0 ) { 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; } #line 996 "nw/geoma.nw" }; ./geoma1.2.2007.08.20/geomaData.h0100644000077300007650000000116110662377305013770 0ustar patpat#line 1012 "nw/geoma.nw" namespace nklein { namespace nklein_priv { #line 741 "nw/geoma.nw" template int GeomMultTable< P, Q >::multTable[ 1U << (P+Q) ][ 1U << (P+Q) ]; #line 1015 "nw/geoma.nw" #line 892 "nw/geoma.nw" template int GeomGradeTable::gradeTable[ 1U << (N) ]; #line 1016 "nw/geoma.nw" }; static const char* GeometricAlgebraVersion = "nklein::GeometricAlgebra::version: " #line 21 "nw/hdr.nw" "v1.2.2007.08.20" #line 1019 "nw/geoma.nw" ; }; ./geoma1.2.2007.08.20/GNUmakefile0100644000077300007650000000273210171433256014005 0ustar patpat TARGET := geoma NWS := \ nw/hdr.nw \ nw/geoma.nw \ nw/tail.nw SRCS := \ geoma.cc .SECONDARY: $(SRCS) HDRS := \ geoma.h \ geomaData.h .SECONDARY: $(HDRS) OBJS := \ $(patsubst %.cc, %.o, $(filter %.cc, $(SRCS) ) ) .SECONDARY: $(OBJS) DEPS := \ $(patsubst %, deps/%.dep, $(SRCS) ) CPPFLAGS := -O -I. all: $(TARGET) $(TARGET).pdf .PHONY: all $(TARGET): $(OBJS) $(CXX) -o $@ $^ tidy: rm -f $(TARGET).log $(TARGET).aux $(TARGET).toc $(TARGET).tex rm -f $(OBJS) .PHONY: tidy release: tidy rm -f $(TARGET) $(TARGET).dvi $(DEPS) .PHONY: release clean: release rm -f $(TARGET).tex rm -f $(SRCS) $(HDRS) .PHONY: clean clobber: clean rm -f $(TARGET) $(TARGET).pdf $(TARGET).dvi .PHONY: clobber %Data.h: nw/%.nw nw/hdr.nw notangle -R$@ -L $^ > $@ %.h: nw/%.nw nw/hdr.nw notangle -R$@ -L $^ > $@ %.cc: nw/%.nw nw/hdr.nw notangle -R$@ -L $^ > $@ %.o: %.cc $(CXX) -c $(CPPFLAGS) $< -o $@ deps/%.cc.dep: %.cc $(SRCS) $(HDRS) $(CXX) -M $(CPPFLAGS) $< \ | sed -e 's!:! $@:!' \ > $@ $(TARGET).pdf: $(TARGET).tex sum="xxx"; \ osum="yyy"; \ while [ ! "$${sum}" = "$${osum}" ]; do \ osum="$${sum}"; \ pdflatex $< ; \ sum="`sum $@`"; \ done $(TARGET).dvi: $(TARGET).tex sum="xxx"; \ osum="yyy"; \ while [ ! "$${sum}" = "$${osum}" ]; do \ osum="$${sum}"; \ latex $< ; \ sum="`sum $@`"; \ done .SECONDARY: $(TARGET).tex $(TARGET).tex: $(NWS) cat $(filter %.nw, $^ ) | noweave -delay -latex -index > $@ .SECONDARY: $(NWS) include $(DEPS) ./geoma1.2.2007.08.20/matrix.txt0100644000077300007650000000041010171453221013761 0ustar patpatA := { { 0, 1, 1, -1, 1, -1, -1 }, { -1, 0, 1, 1, -1, 1, -1 }, { -1, -1, 0, 1, 1, -1, 1 }, { 1, -1, -1, 0, 1, 1, -1 }, { -1, 1, -1, -1, 0, 1, 1 }, { 1, -1, 1, -1, -1, 0, 1 }, { 1, 1, -1, 1, -1, -1, 0 } }; v := { 0, 0, 0, 1, 0, 0, 0 }; x := SolveMatrix( A, v ); ./geoma1.2.2007.08.20/nw/0040755000077300007650000000000010662417560012363 5ustar patpat./geoma1.2.2007.08.20/nw/geoma.nw0100644000077300007650000006647210662376573014045 0ustar patpat\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 std::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 std::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 ( ( nklein_priv::GeomGradeTable< P+Q >::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 ( ( nklein_priv::GeomGradeTable< P+Q >::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 ( nklein_priv::GeomGradeTable< P+Q >::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; } @ \subsubsection{Wedge} The wedge product of two multivectors is similar to the Clifford product of two multivectors. 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}, this is somewhat straightforward. If the $i$-th term and the $j$-th term have any bits in common, then the contribution of the $i$-th term wedged with the $j$-th term is zero. Otherwise, the contribution is the same as it would be in the Clifford product. <>= 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 mask = ( ii & jj ); if ( mask == 0 ) { 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. <