* Implementation of GiNaC's clifford algebra (Dirac gamma) objects. */
/*
- * GiNaC Copyright (C) 1999-2003 Johannes Gutenberg University Mainz, Germany
+ * GiNaC Copyright (C) 1999-2004 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
#include "relational.h"
#include "operators.h"
#include "mul.h"
-#include "print.h"
#include "archive.h"
#include "utils.h"
namespace GiNaC {
-GINAC_IMPLEMENT_REGISTERED_CLASS(clifford, indexed)
-GINAC_IMPLEMENT_REGISTERED_CLASS(diracone, tensor)
-GINAC_IMPLEMENT_REGISTERED_CLASS(diracgamma, tensor)
-GINAC_IMPLEMENT_REGISTERED_CLASS(diracgamma5, tensor)
-GINAC_IMPLEMENT_REGISTERED_CLASS(diracgammaL, tensor)
-GINAC_IMPLEMENT_REGISTERED_CLASS(diracgammaR, tensor)
+GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(clifford, indexed,
+ print_func<print_dflt>(&clifford::do_print_dflt).
+ print_func<print_latex>(&clifford::do_print_latex))
+
+GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(diracone, tensor,
+ print_func<print_dflt>(&diracone::do_print).
+ print_func<print_latex>(&diracone::do_print_latex))
+
+GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(diracgamma, tensor,
+ print_func<print_dflt>(&diracgamma::do_print).
+ print_func<print_latex>(&diracgamma::do_print_latex))
+
+GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(diracgamma5, tensor,
+ print_func<print_dflt>(&diracgamma5::do_print).
+ print_func<print_latex>(&diracgamma5::do_print_latex))
+
+GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(diracgammaL, tensor,
+ print_func<print_context>(&diracgammaL::do_print).
+ print_func<print_latex>(&diracgammaL::do_print_latex))
+
+GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(diracgammaR, tensor,
+ print_func<print_context>(&diracgammaR::do_print).
+ print_func<print_latex>(&diracgammaR::do_print_latex))
//////////
// default constructors
tinfo_key = TINFO_clifford;
}
-clifford::clifford(unsigned char rl, exvector * vp) : inherited(sy_none(), vp), representation_label(rl)
+clifford::clifford(unsigned char rl, std::auto_ptr<exvector> vp) : inherited(sy_none(), vp), representation_label(rl)
{
tinfo_key = TINFO_clifford;
}
return representation_label == o.representation_label;
}
-void clifford::print(const print_context & c, unsigned level) const
+static bool is_dirac_slash(const ex & seq0)
{
- if (!is_a<diracgamma5>(seq[0]) && !is_a<diracgammaL>(seq[0]) &&
- !is_a<diracgammaR>(seq[0]) && !is_a<diracgamma>(seq[0]) &&
- !is_a<diracone>(seq[0])) {
-
- // dirac_slash() object is printed differently
- if (is_a<print_tree>(c))
- inherited::print(c, level);
- else if (is_a<print_latex>(c)) {
- c.s << "{";
- seq[0].print(c, level);
- c.s << "\\hspace{-1.0ex}/}";
- } else {
- seq[0].print(c, level);
- c.s << "\\";
- }
+ return !is_a<diracgamma5>(seq0) && !is_a<diracgammaL>(seq0) &&
+ !is_a<diracgammaR>(seq0) && !is_a<diracgamma>(seq0) &&
+ !is_a<diracone>(seq0);
+}
+void clifford::do_print_dflt(const print_dflt & c, unsigned level) const
+{
+ // dirac_slash() object is printed differently
+ if (is_dirac_slash(seq[0])) {
+ seq[0].print(c, level);
+ c.s << "\\";
} else
- inherited::print(c, level);
+ this->print_dispatch<inherited>(c, level);
+}
+
+void clifford::do_print_latex(const print_latex & c, unsigned level) const
+{
+ // dirac_slash() object is printed differently
+ if (is_dirac_slash(seq[0])) {
+ c.s << "{";
+ seq[0].print(c, level);
+ c.s << "\\hspace{-1.0ex}/}";
+ } else
+ this->print_dispatch<inherited>(c, level);
}
DEFAULT_COMPARE(diracone)
return clifford(representation_label, v);
}
-ex clifford::thiscontainer(exvector * vp) const
+ex clifford::thiscontainer(std::auto_ptr<exvector> vp) const
{
return clifford(representation_label, vp);
}
+ex diracgamma5::conjugate() const
+{
+ return _ex_1 * (*this);
+}
+
+ex diracgammaL::conjugate() const
+{
+ return (new diracgammaR)->setflag(status_flags::dynallocated);
+}
+
+ex diracgammaR::conjugate() const
+{
+ return (new diracgammaL)->setflag(status_flags::dynallocated);
+}
+
//////////
// global functions
//////////
ex e_expanded = e.subs(lst(
dirac_gammaL(rl) == (dirac_ONE(rl)-dirac_gamma5(rl))/2,
dirac_gammaR(rl) == (dirac_ONE(rl)+dirac_gamma5(rl))/2
- )).expand();
+ ), subs_options::no_pattern).expand();
if (!is_a<ncmul>(e_expanded))
return dirac_trace(e_expanded, rl, trONE);
ex canonicalize_clifford(const ex & e)
{
// Scan for any ncmul objects
- lst srl;
+ exmap srl;
ex aux = e.to_rational(srl);
- for (size_t i=0; i<srl.nops(); i++) {
+ for (exmap::iterator i = srl.begin(); i != srl.end(); ++i) {
- ex o = srl.op(i);
- ex lhs = o.lhs();
- ex rhs = o.rhs();
+ ex lhs = i->first;
+ ex rhs = i->second;
if (is_exactly_a<ncmul>(rhs)
&& rhs.return_type() == return_types::noncommutative
// Expand product, if necessary
ex rhs_expanded = rhs.expand();
if (!is_a<ncmul>(rhs_expanded)) {
- srl[i] = (lhs == canonicalize_clifford(rhs_expanded));
+ i->second = canonicalize_clifford(rhs_expanded);
continue;
} else if (!is_a<clifford>(rhs.op(0)))
it[0] = save1;
it[1] = save0;
sum -= ncmul(v, true);
- srl[i] = (lhs == canonicalize_clifford(sum));
+ i->second = canonicalize_clifford(sum);
goto next_sym;
}
++it;
next_sym: ;
}
}
- return aux.subs(srl).simplify_indexed();
+ return aux.subs(srl, subs_options::no_pattern).simplify_indexed();
}
} // namespace GiNaC
git://www.ginac.de / ginac.git / blobdiff