ginac/clifford.cpp

   1 /** @file clifford.cpp
   2  *
   3  *  Implementation of GiNaC's clifford objects.
   4  *  No real implementation yet, to be done.     */
   5
   6 /*
   7  *  GiNaC Copyright (C) 1999-2001 Johannes Gutenberg University Mainz, Germany
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  */
  23
  24 #include <string>
  25
  26 #include "clifford.h"
  27 #include "ex.h"
  28 #include "ncmul.h"
  29 #include "archive.h"
  30 #include "utils.h"
  31 #include "debugmsg.h"
  32
  33 #ifndef NO_NAMESPACE_GINAC
  34 namespace GiNaC {
  35 #endif // ndef NO_NAMESPACE_GINAC
  36
  37 GINAC_IMPLEMENT_REGISTERED_CLASS(clifford, lortensor)
  38
  39 //////////
  40 // default constructor, destructor, copy constructor assignment operator and helpers
  41 //////////
  42
  43 // public
  44
  45 clifford::clifford()
  46 {
  47         debugmsg("clifford default constructor",LOGLEVEL_CONSTRUCT);
  48         tinfo_key = TINFO_clifford;
  49 }
  50
  51 clifford::~clifford()
  52 {
  53         debugmsg("clifford destructor",LOGLEVEL_DESTRUCT);
  54         destroy(false);
  55 }
  56
  57 clifford::clifford(const clifford & other)
  58 {
  59         debugmsg("clifford copy constructor",LOGLEVEL_CONSTRUCT);
  60         copy(other);
  61 }
  62
  63 const clifford & clifford::operator=(const clifford & other)
  64 {
  65         debugmsg("clifford operator=",LOGLEVEL_ASSIGNMENT);
  66         if (this != &other) {
  67                 destroy(true);
  68                 copy(other);
  69         }
  70         return *this;
  71 }
  72
  73 // protected
  74
  75 void clifford::copy(const clifford & other)
  76 {
  77         inherited::copy(other);
  78 }
  79
  80 void clifford::destroy(bool call_parent)
  81 {
  82         if (call_parent) inherited::destroy(call_parent);
  83 }
  84
  85 //////////
  86 // other constructors
  87 //////////
  88
  89 // public
  90
  91 clifford::clifford(const std::string & n, const ex & mu) : inherited(lortensor_symbolic, n, mu)
  92 {
  93         debugmsg("clifford constructor from string,ex",LOGLEVEL_CONSTRUCT);
  94         tinfo_key=TINFO_clifford;
  95 }
  96
  97 clifford::clifford(const std::string & n, const exvector & iv) : inherited(lortensor_symbolic, n, iv)
  98 {
  99         debugmsg("clifford constructor from string,exvector", LOGLEVEL_CONSTRUCT);
 100         GINAC_ASSERT(all_of_type_lorentzidx());
 101         tinfo_key=TINFO_clifford;
 102 }
 103
 104 clifford::clifford(const std::string & n, exvector *ivp) : inherited(lortensor_symbolic, n, *ivp)
 105 {
 106         debugmsg("clifford constructor from string,exvector", LOGLEVEL_CONSTRUCT);
 107         GINAC_ASSERT(all_of_type_lorentzidx());
 108         tinfo_key=TINFO_clifford;
 109 }
 110
 111 //////////
 112 // archiving
 113 //////////
 114
 115 /** Construct object from archive_node. */
 116 clifford::clifford(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst)
 117 {
 118         debugmsg("clifford constructor from archive_node", LOGLEVEL_CONSTRUCT);
 119 }
 120
 121 /** Unarchive the object. */
 122 ex clifford::unarchive(const archive_node &n, const lst &sym_lst)
 123 {
 124         return (new clifford(n, sym_lst))->setflag(status_flags::dynallocated);
 125 }
 126
 127 /** Archive the object. */
 128 void clifford::archive(archive_node &n) const
 129 {
 130         inherited::archive(n);
 131 }
 132
 133 //////////
 134 // functions overriding virtual functions from bases classes
 135 //////////
 136
 137 // public
 138
 139 basic * clifford::duplicate() const
 140 {
 141         debugmsg("clifford duplicate",LOGLEVEL_DUPLICATE);
 142         return new clifford(*this);
 143 }
 144
 145 void clifford::printraw(std::ostream & os) const
 146 {
 147         debugmsg("clifford printraw",LOGLEVEL_PRINT);
 148         os << "clifford(" << "indices=";
 149         printrawindices(os);
 150         os << ",hash=" << hashvalue << ",flags=" << flags << ")";
 151 }
 152
 153 void clifford::printtree(std::ostream & os, unsigned indent) const
 154 {
 155         debugmsg("clifford printtree",LOGLEVEL_PRINT);
 156         os << std::string(indent,' ') << " (clifford): "
 157            << seq.size() << "indices=";
 158         printtreeindices(os, indent);
 159         os << ", hash=" << hashvalue
 160            << " (0x" << std::hex << hashvalue << std::dec << ")"
 161            << ", flags=" << flags << std::endl;
 162 }
 163
 164 void clifford::print(std::ostream & os, unsigned upper_precedence) const
 165 {
 166         debugmsg("clifford print",LOGLEVEL_PRINT);
 167         os << name;
 168         printindices(os);
 169 }
 170
 171 bool clifford::info(unsigned inf) const
 172 {
 173         return inherited::info(inf);
 174 }
 175
 176 // protected
 177
 178 int clifford::compare_same_type(const basic & other) const
 179 {
 180         GINAC_ASSERT(is_of_type(other,clifford));
 181         // only compare indices
 182         return exprseq::compare_same_type(other);
 183 }
 184
 185 bool clifford::is_equal_same_type(const basic & other) const
 186 {
 187         GINAC_ASSERT(is_of_type(other,clifford));
 188         // only compare indices
 189         return exprseq::is_equal_same_type(other);
 190 }
 191
 192 ex clifford::thisexprseq(const exvector & v) const
 193 {
 194         return clifford(name, v);
 195 }
 196
 197 ex clifford::thisexprseq(exvector *vp) const
 198 {
 199         return clifford(name, vp);
 200 }
 201
 202 ex clifford::simplify_ncmul(const exvector & v) const
 203 {
 204         return simplified_ncmul(v);
 205 }
 206
 207 //////////
 208 // friend functions
 209 //////////
 210
 211 /** Construct an object representing a Dirac gamma matrix. The index must
 212  *  be of class lorentzidx.
 213  *
 214  *  @param mu Index
 215  *  @return newly constructed object */
 216 clifford clifford_gamma(const ex & mu)
 217 {
 218         return clifford("gamma", mu);
 219 }
 220
 221 #ifndef NO_NAMESPACE_GINAC
 222 } // namespace GiNaC
 223 #endif // ndef NO_NAMESPACE_GINAC