ginac/lorentzidx.cpp

   1 /** @file lorentzidx.cpp
   2  *
   3  *  Implementation of GiNaC's lorentz indices. */
   4
   5 /*
   6  *  GiNaC Copyright (C) 1999 Johannes Gutenberg University Mainz, Germany
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to the Free Software
  20  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include <stdexcept>
  24
  25 #include "lorentzidx.h"
  26 #include "utils.h"
  27
  28 //////////
  29 // default constructor, destructor, copy constructor assignment operator and helpers
  30 //////////
  31
  32 // public
  33
  34 lorentzidx::lorentzidx() : orthogonal_only(false), dim_parallel_space(0)
  35 {
  36     debugmsg("lorentzidx default constructor",LOGLEVEL_CONSTRUCT);
  37     // serial is incremented in idx::idx()
  38     name="mu"+ToString(serial);
  39     tinfo_key=TINFO_lorentzidx;
  40 }
  41
  42 lorentzidx::~lorentzidx()
  43 {
  44     debugmsg("lorentzidx destructor",LOGLEVEL_DESTRUCT);
  45     destroy(0);
  46 }
  47
  48 lorentzidx::lorentzidx(lorentzidx const & other)
  49 {
  50     debugmsg("lorentzidx copy constructor",LOGLEVEL_CONSTRUCT);
  51     copy(other);
  52 }
  53
  54 lorentzidx const & lorentzidx::operator=(lorentzidx const & other)
  55 {
  56     debugmsg("lorentzidx operator=",LOGLEVEL_ASSIGNMENT);
  57     if (this != &other) {
  58         destroy(1);
  59         copy(other);
  60     }
  61     return *this;
  62 }
  63
  64 // protected
  65
  66 void lorentzidx::copy(lorentzidx const & other)
  67 {
  68     idx::copy(other);
  69     orthogonal_only=other.orthogonal_only;
  70     dim_parallel_space=other.dim_parallel_space;
  71 }
  72
  73 void lorentzidx::destroy(bool call_parent)
  74 {
  75     if (call_parent) idx::destroy(call_parent);
  76 }
  77
  78 //////////
  79 // other constructors
  80 //////////
  81
  82 // public
  83
  84 lorentzidx::lorentzidx(bool cov, bool oonly, unsigned dimp) :
  85     idx(cov), orthogonal_only(oonly), dim_parallel_space(dimp)
  86 {
  87     debugmsg("lorentzidx constructor from bool",LOGLEVEL_CONSTRUCT);
  88     // serial is incremented in idx::idx(bool)
  89     if (oonly) {
  90         name="muorth"+ToString(serial);
  91     } else {
  92         name="mu"+ToString(serial);
  93     }
  94     tinfo_key=TINFO_lorentzidx;
  95 }
  96
  97 lorentzidx::lorentzidx(string const & n, bool cov, bool oonly, unsigned dimp)
  98     : idx(n,cov), orthogonal_only(oonly), dim_parallel_space(dimp)
  99 {
 100     debugmsg("lorentzidx constructor from string,bool,bool,unsigned",
 101              LOGLEVEL_CONSTRUCT);
 102     tinfo_key=TINFO_lorentzidx;
 103 }
 104
 105 lorentzidx::lorentzidx(char const * n, bool cov, bool oonly, unsigned dimp)
 106     : idx(n,cov), orthogonal_only(oonly), dim_parallel_space(dimp)
 107 {
 108     debugmsg("lorentzidx constructor from char*,bool,bool,unsigned",
 109              LOGLEVEL_CONSTRUCT);
 110     tinfo_key=TINFO_lorentzidx;
 111 }
 112
 113 lorentzidx::lorentzidx(unsigned const v, bool cov) : idx(v,cov),
 114     orthogonal_only(false), dim_parallel_space(0)
 115 {
 116     debugmsg("lorentzidx constructor from unsigned,bool",LOGLEVEL_CONSTRUCT);
 117     tinfo_key=TINFO_lorentzidx;
 118 }
 119
 120 //////////
 121 // functions overriding virtual functions from bases classes
 122 //////////
 123
 124 // public
 125
 126 basic * lorentzidx::duplicate() const
 127 {
 128     debugmsg("lorentzidx duplicate",LOGLEVEL_DUPLICATE);
 129     return new lorentzidx(*this);
 130 }
 131
 132 void lorentzidx::printraw(ostream & os) const
 133 {
 134     debugmsg("lorentzidx printraw",LOGLEVEL_PRINT);
 135
 136     os << "lorentzidx(";
 137
 138     if (symbolic) {
 139         os << "symbolic,name=" << name;
 140     } else {
 141         os << "non symbolic,value=" << value;
 142     }
 143
 144     if (covariant) {
 145         os << ",covariant";
 146     } else {
 147         os << ",contravariant";
 148     }
 149
 150     if (orthogonal_only) {
 151         os << ",only orthogonal components at " << dim_parallel_space
 152            << " parallel dimensions";
 153     } else {
 154         os << ",parallel and orthogonal components";
 155     }
 156
 157     os << ",serial=" << serial;
 158     os << ",hash=" << hashvalue << ",flags=" << flags;
 159     os << ")";
 160 }
 161
 162 void lorentzidx::printtree(ostream & os, unsigned indent) const
 163 {
 164     debugmsg("lorentzidx printtree",LOGLEVEL_PRINT);
 165
 166     os << string(indent,' ') << "lorentzidx: ";
 167
 168     if (symbolic) {
 169         os << "symbolic,name=" << name;
 170     } else {
 171         os << "non symbolic,value=" << value;
 172     }
 173
 174     if (covariant) {
 175         os << ",covariant";
 176     } else {
 177         os << ",contravariant";
 178     }
 179
 180     if (orthogonal_only) {
 181         os << ",only orthogonal components at " << dim_parallel_space
 182            << " parallel dimensions";
 183     } else {
 184         os << ",parallel and orthogonal components";
 185     }
 186
 187     os << ", serial=" << serial
 188        << ", hash=" << hashvalue << " (0x" << hex << hashvalue << dec << ")"
 189        << ", flags=" << flags << endl;
 190 }
 191
 192 void lorentzidx::print(ostream & os, unsigned upper_precedence) const
 193 {
 194     debugmsg("lorentzidx print",LOGLEVEL_PRINT);
 195
 196     if (covariant) {
 197         os << "_";
 198     } else {
 199         os << "~";
 200     }
 201     if (symbolic) {
 202         os << name;
 203     } else {
 204         os << value;
 205     }
 206 }
 207
 208 bool lorentzidx::info(unsigned inf) const
 209 {
 210     if (inf==info_flags::lorentzidx) return true;
 211     return idx::info(inf);
 212 }
 213
 214 //////////
 215 // new virtual functions which can be overridden by derived classes
 216 //////////
 217
 218 // none
 219
 220 //////////
 221 // non-virtual functions in this class
 222 //////////
 223
 224 // public
 225
 226 lorentzidx lorentzidx::create_anonymous_representative(void) const
 227 {
 228     ASSERT(is_symbolic());
 229     lorentzidx i_copy(*this);
 230     i_copy.serial=0;
 231     i_copy.name="anonymous_representative";
 232     i_copy.covariant=false;
 233     i_copy.clearflag(status_flags::dynallocated|
 234                      status_flags::hash_calculated);
 235     return i_copy;
 236 }
 237
 238 //////////
 239 // static member variables
 240 //////////
 241
 242 // none
 243
 244 //////////
 245 // global constants
 246 //////////
 247
 248 const lorentzidx some_lorentzidx;
 249 type_info const & typeid_lorentzidx=typeid(some_lorentzidx);
 250
 251
 252