X-Git-Url: https://ginac.de/ginac.git//ginac.git?a=blobdiff_plain;f=ginac%2Fclifford.cpp;h=ecd95b7e95afca94265036741133875f2511b008;hb=85ce9664ddba79c28a6945b1e5b4e2b71f77cb51;hp=fc6604dcecbe3c865c73e5554c12533031cab3b2;hpb=9e2d60e206395fc9908e1f9025e50c76b3d7c182;p=ginac.git

diff --git a/ginac/clifford.cpp b/ginac/clifford.cpp
index fc6604dc..ecd95b7e 100644
--- a/ginac/clifford.cpp
+++ b/ginac/clifford.cpp
@@ -1,10 +1,9 @@
 /** @file clifford.cpp
  *
- *  Implementation of GiNaC's clifford objects.
- *  No real implementation yet, to be done.     */
+ *  Implementation of GiNaC's clifford algebra (Dirac gamma) objects. */
 
 /*
- *  GiNaC Copyright (C) 1999-2000 Johannes Gutenberg University Mainz, Germany
+ *  GiNaC Copyright (C) 1999-2001 Johannes Gutenberg University Mainz, Germany
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -21,199 +20,193 @@
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
-#include <string>
-
 #include "clifford.h"
 #include "ex.h"
+#include "idx.h"
 #include "ncmul.h"
-#include "utils.h"
+#include "print.h"
+#include "archive.h"
 #include "debugmsg.h"
+#include "utils.h"
+
+#include <stdexcept>
 
-#ifndef NO_NAMESPACE_GINAC
 namespace GiNaC {
-#endif // ndef NO_NAMESPACE_GINAC
+
+GINAC_IMPLEMENT_REGISTERED_CLASS(clifford, indexed)
+GINAC_IMPLEMENT_REGISTERED_CLASS(diracone, tensor)
+GINAC_IMPLEMENT_REGISTERED_CLASS(diracgamma, tensor)
 
 //////////
 // default constructor, destructor, copy constructor assignment operator and helpers
 //////////
 
-// public
-
 clifford::clifford()
 {
-	debugmsg("clifford default constructor",LOGLEVEL_CONSTRUCT);
-	serial=next_serial++;
-	name=autoname_prefix()+ToString(serial);
-	tinfo_key=TINFO_clifford;
+	debugmsg("clifford default constructor", LOGLEVEL_CONSTRUCT);
+	tinfo_key = TINFO_clifford;
 }
 
-clifford::~clifford()
-{
-	debugmsg("clifford destructor",LOGLEVEL_DESTRUCT);
-	destroy(false);
-}
+DEFAULT_COPY(clifford)
+DEFAULT_DESTROY(clifford)
+DEFAULT_CTORS(diracone)
+DEFAULT_CTORS(diracgamma)
 
-clifford::clifford(const clifford & other)
+//////////
+// other constructors
+//////////
+
+/** Construct object with one Lorentz index. This constructor is for internal
+ *  use only. Use the dirac_gamma() function instead.
+ *  @see dirac_gamma */
+clifford::clifford(const ex & b, const ex & mu) : inherited(b, mu)
 {
-	debugmsg("clifford copy constructor",LOGLEVEL_CONSTRUCT);
-	copy (other);
+	debugmsg("clifford constructor from ex,ex", LOGLEVEL_CONSTRUCT);
+	GINAC_ASSERT(is_ex_of_type(mu, varidx));
+	tinfo_key = TINFO_clifford;
 }
 
-const clifford & clifford::operator=(const clifford & other)
+/** Construct object without any indices. This constructor is for internal
+ *  use only. Use the dirac_one() function instead.
+ *  @see dirac_one */
+clifford::clifford(const ex & b) : inherited(b)
 {
-	debugmsg("clifford operator=",LOGLEVEL_ASSIGNMENT);
-	if (this != &other) {
-		destroy(true);
-		copy(other);
-	}
-	return *this;
+	debugmsg("clifford constructor from ex", LOGLEVEL_CONSTRUCT);
+	tinfo_key = TINFO_clifford;
 }
 
-// protected
-
-void clifford::copy(const clifford & other)
+clifford::clifford(const exvector & v, bool discardable) : inherited(indexed::unknown, v, discardable)
 {
-	indexed::copy(other);
-	name=other.name;
-	serial=other.serial;
+	debugmsg("clifford constructor from exvector", LOGLEVEL_CONSTRUCT);
+	tinfo_key = TINFO_clifford;
 }
 
-void clifford::destroy(bool call_parent)
+clifford::clifford(exvector * vp) : inherited(indexed::unknown, vp)
 {
-	if (call_parent) {
-		indexed::destroy(call_parent);
-	}
+	debugmsg("clifford constructor from exvector *", LOGLEVEL_CONSTRUCT);
+	tinfo_key = TINFO_clifford;
 }
 
 //////////
-// other constructors
+// archiving
 //////////
 
-// public
-
-clifford::clifford(const std::string & initname)
-{
-	debugmsg("clifford constructor from string",LOGLEVEL_CONSTRUCT);
-	name=initname;
-	serial=next_serial++;
-	tinfo_key=TINFO_clifford;
-}
+DEFAULT_ARCHIVING(clifford)
+DEFAULT_ARCHIVING(diracone)
+DEFAULT_ARCHIVING(diracgamma)
 
 //////////
 // functions overriding virtual functions from bases classes
 //////////
 
-// public
-
-basic * clifford::duplicate() const
-{
-	debugmsg("clifford duplicate",LOGLEVEL_DUPLICATE);
-	return new clifford(*this);
-}
-
-void clifford::printraw(std::ostream & os) const
-{
-	debugmsg("clifford printraw",LOGLEVEL_PRINT);
-	os << "clifford(" << "name=" << name << ",serial=" << serial
-	   << ",indices=";
-	printrawindices(os);
-	os << ",hash=" << hashvalue << ",flags=" << flags << ")";
-}
-
-void clifford::printtree(std::ostream & os, unsigned indent) const
-{
-	debugmsg("clifford printtree",LOGLEVEL_PRINT);
-	os << std::string(indent,' ') << name << " (clifford): "
-	   << "serial=" << serial << ","
-	   << seq.size() << "indices=";
-	printtreeindices(os, indent);
-	os << ", hash=" << hashvalue
-	   << " (0x" << std::hex << hashvalue << std::dec << ")"
-	   << ", flags=" << flags << std::endl;
-}
-
-void clifford::print(std::ostream & os, unsigned upper_precedence) const
+int clifford::compare_same_type(const basic & other) const
 {
-	debugmsg("clifford print",LOGLEVEL_PRINT);
-	os << name;
-	printindices(os);
-}
+	return inherited::compare_same_type(other);
+}
+
+DEFAULT_COMPARE(diracone)
+DEFAULT_COMPARE(diracgamma)
+DEFAULT_PRINT(diracone, "ONE")
+DEFAULT_PRINT(diracgamma, "gamma")
+
+/** Contraction of a gamma matrix with something else. */
+bool diracgamma::contract_with(exvector::iterator self, exvector::iterator other, exvector & v) const
+{
+	GINAC_ASSERT(is_ex_of_type(*self, indexed));
+	GINAC_ASSERT(is_ex_of_type(*other, indexed));
+	GINAC_ASSERT(is_ex_of_type(self->op(0), diracgamma));
+
+	if (is_ex_of_type(other->op(0), diracgamma)) {
+
+		ex dim = ex_to_idx(self->op(1)).get_dim();
+
+		// gamma~mu*gamma.mu = dim*ONE
+		if (other - self == 1) {
+			*self = dim;
+			*other = dirac_one();
+			return true;
+
+		// gamma~mu*gamma~alpha*gamma.mu = (2-dim)*gamma~alpha
+		} else if (other - self == 2
+		        && is_ex_of_type(self[1], clifford)) {
+			*self = 2 - dim;
+			*other = _ex1();
+			return true;
+
+		// gamma~mu*gamma~alpha*gamma~beta*gamma.mu = 4*g~alpha~beta+(dim-4)*gamam~alpha*gamma~beta
+		} else if (other - self == 3
+		        && is_ex_of_type(self[1], clifford)
+		        && is_ex_of_type(self[2], clifford)) {
+			*self = 4 * metric_tensor(self[1].op(1), self[2].op(1)) * dirac_one() + (dim - 4) * self[1] * self[2];
+			self[1] = _ex1();
+			self[2] = _ex1();
+			*other = _ex1();
+			return true;
+
+		// gamma~mu*gamma~alpha*gamma~beta*gamma~delta*gamma.mu = -2*gamma~delta*gamma~beta*gamma~alpha+(4-dim)*gamma~alpha*gamma~beta*gamma~delta
+		} else if (other - self == 4
+		        && is_ex_of_type(self[1], clifford)
+		        && is_ex_of_type(self[2], clifford)
+		        && is_ex_of_type(self[3], clifford)) {
+			*self = -2 * self[3] * self[2] * self[1] + (4 - dim) * self[1] * self[2] * self[3];
+			self[1] = _ex1();
+			self[2] = _ex1();
+			self[3] = _ex1();
+			*other = _ex1();
+			return true;
+		}
+	}
 
-void clifford::printcsrc(std::ostream & os, unsigned type, unsigned upper_precedence) const
-{
-	debugmsg("clifford print csrc",LOGLEVEL_PRINT);
-	print(os,upper_precedence);
+	return false;
 }
 
-bool clifford::info(unsigned inf) const
+/** Perform automatic simplification on noncommutative product of clifford
+ *  objects. This removes superfluous ONEs. */
+ex clifford::simplify_ncmul(const exvector & v) const
 {
-	return indexed::info(inf);
-}
+	exvector s;
+	s.reserve(v.size());
 
-// protected
-
-int clifford::compare_same_type(const basic & other) const
-{
-	GINAC_ASSERT(other.tinfo() == TINFO_clifford);
-	const clifford *o = static_cast<const clifford *>(&other);
-	if (serial==o->serial) {
-		return indexed::compare_same_type(other);
+	exvector::const_iterator it = v.begin(), itend = v.end();
+	while (it != itend) {
+		if (!is_ex_of_type(it->op(0), diracone))
+			s.push_back(*it);
+		it++;
 	}
-	return serial < o->serial ? -1 : 1;
+
+	if (s.size() == 0)
+		return clifford(diracone());
+	else if (s.size() == v.size())
+		return simplified_ncmul(v);
+	else
+		return simplified_ncmul(s);
 }
 
-ex clifford::simplify_ncmul(const exvector & v) const
+ex clifford::thisexprseq(const exvector & v) const
 {
-	return simplified_ncmul(v);
+	return clifford(v);
 }
 
-unsigned clifford::calchash(void) const
+ex clifford::thisexprseq(exvector * vp) const
 {
-	hashvalue=golden_ratio_hash(golden_ratio_hash(0x55555556U ^
-												  golden_ratio_hash(tinfo_key) ^
-												  serial));
-	setflag(status_flags::hash_calculated);
-	return hashvalue;
+	return clifford(vp);
 }
 
 //////////
-// virtual functions which can be overridden by derived classes
+// global functions
 //////////
 
-// none
-
-//////////
-// non-virtual functions in this class
-//////////
-
-void clifford::setname(const std::string & n)
+ex dirac_one(void)
 {
-	name = n;
+	return clifford(diracone());
 }
 
-// private
-
-std::string & clifford::autoname_prefix(void)
+ex dirac_gamma(const ex & mu)
 {
-	static std::string * s = new std::string("clifford");
-	return *s;
-}
-
-//////////
-// static member variables
-//////////
+	if (!is_ex_of_type(mu, varidx))
+		throw(std::invalid_argument("index of Dirac gamma must be of type varidx"));
 
-// private
-
-unsigned clifford::next_serial=0;
-
-//////////
-// global constants
-//////////
-
-const clifford some_clifford;
-const std::type_info & typeid_clifford = typeid(some_clifford);
+	return clifford(diracgamma(), mu);
+}
 
-#ifndef NO_NAMESPACE_GINAC
 } // namespace GiNaC
-#endif // ndef NO_NAMESPACE_GINAC