]> www.ginac.de Git - ginac.git/blob - ginac/lorentzidx.cpp
- added documentation for the idx, coloridx and lorentzidx classes
[ginac.git] / ginac / lorentzidx.cpp
1 /** @file lorentzidx.cpp
2  *
3  *  Implementation of GiNaC's lorentz indices. */
4
5 /*
6  *  GiNaC Copyright (C) 1999-2001 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 "lst.h"
27 #include "archive.h"
28 #include "utils.h"
29 #include "debugmsg.h"
30
31 #ifndef NO_NAMESPACE_GINAC
32 namespace GiNaC {
33 #endif // ndef NO_NAMESPACE_GINAC
34
35 GINAC_IMPLEMENT_REGISTERED_CLASS(lorentzidx, idx)
36
37 //////////
38 // default constructor, destructor, copy constructor assignment operator and helpers
39 //////////
40
41 // public
42
43 lorentzidx::lorentzidx() : orthogonal_only(false), dim_parallel_space(0)
44 {
45         debugmsg("lorentzidx default constructor",LOGLEVEL_CONSTRUCT);
46         // serial is incremented in idx::idx()
47         name = "mu" + ToString(serial);
48         tinfo_key = TINFO_lorentzidx;
49 }
50
51 lorentzidx::~lorentzidx() 
52 {
53         debugmsg("lorentzidx destructor",LOGLEVEL_DESTRUCT);
54         destroy(false);
55 }
56
57 lorentzidx::lorentzidx(const lorentzidx & other)
58 {
59         debugmsg("lorentzidx copy constructor",LOGLEVEL_CONSTRUCT);
60         copy(other);
61 }
62
63 const lorentzidx & lorentzidx::operator=(const lorentzidx & other)
64 {
65         debugmsg("lorentzidx operator=",LOGLEVEL_ASSIGNMENT);
66         if (this != &other) {
67                 destroy(true);
68                 copy(other);
69         }
70         return *this;
71 }
72
73 // protected
74
75 void lorentzidx::copy(const lorentzidx & other)
76 {
77         inherited::copy(other);
78         orthogonal_only=other.orthogonal_only;
79         dim_parallel_space=other.dim_parallel_space;
80 }
81
82 void lorentzidx::destroy(bool call_parent)
83 {
84         if (call_parent) inherited::destroy(call_parent);
85 }
86
87 //////////
88 // other constructors
89 //////////
90
91 // public
92
93 /** Construct symbolic Lorentz index, using an automatically generated unique name.
94  *
95  *  @param cov Index is covariant (contravariant otherwise)
96  *  @param oonly Index only lives in orthogonal space
97  *  @param dimp Dimension of parallel space
98  *  @return newly constructed index */
99 lorentzidx::lorentzidx(bool cov, bool oonly, unsigned dimp)
100   : idx(cov), orthogonal_only(oonly), dim_parallel_space(dimp)
101 {
102         debugmsg("lorentzidx constructor from bool",LOGLEVEL_CONSTRUCT);
103         // serial is incremented in idx::idx(bool)
104         if (oonly) {
105                 name="muorth"+ToString(serial);
106         } else {
107                 name="mu"+ToString(serial);
108         }
109         tinfo_key=TINFO_lorentzidx;
110 }
111
112 /** Construct symbolic Lorentz index with specified name.
113  *
114  *  @param n Symbolic index name
115  *  @param cov Index is covariant (contravariant otherwise)
116  *  @param oonly Index only lives in orthogonal space
117  *  @param dimp Dimension of parallel space
118  *  @return newly constructed index */
119 lorentzidx::lorentzidx(const std::string & n, bool cov, bool oonly, unsigned dimp)
120   : idx(n,cov), orthogonal_only(oonly), dim_parallel_space(dimp)
121 {
122         debugmsg("lorentzidx constructor from string,bool,bool,unsigned",
123                          LOGLEVEL_CONSTRUCT);
124         tinfo_key=TINFO_lorentzidx;
125 }
126
127 /** Construct symbolic Lorentz index with specified name.
128  *
129  *  @param n Symbolic index name
130  *  @param cov Index is covariant (contravariant otherwise)
131  *  @param oonly Index only lives in orthogonal space
132  *  @param dimp Dimension of parallel space
133  *  @return newly constructed index */
134 lorentzidx::lorentzidx(const char * n, bool cov, bool oonly, unsigned dimp)
135   : idx(n,cov), orthogonal_only(oonly), dim_parallel_space(dimp)
136 {
137         debugmsg("lorentzidx constructor from char*,bool,bool,unsigned",
138                          LOGLEVEL_CONSTRUCT);
139         tinfo_key=TINFO_lorentzidx;
140 }
141
142 /** Construct numeric Lorentz index with specified value.
143  *
144  *  @param v Numeric index value
145  *  @param cov Index is covariant (contravariant otherwise)
146  *  @return newly constructed index */
147 lorentzidx::lorentzidx(unsigned v, bool cov)
148   : idx(v,cov), orthogonal_only(false), dim_parallel_space(0)
149 {
150         debugmsg("lorentzidx constructor from unsigned,bool",LOGLEVEL_CONSTRUCT);
151         tinfo_key=TINFO_lorentzidx;
152 }
153
154 //////////
155 // archiving
156 //////////
157
158 /** Construct object from archive_node. */
159 lorentzidx::lorentzidx(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst)
160 {
161         debugmsg("lorentzidx constructor from archive_node", LOGLEVEL_CONSTRUCT);
162         n.find_bool("orthogonal_only", orthogonal_only);
163         n.find_unsigned("pdim", dim_parallel_space);
164 }
165
166 /** Unarchive the object. */
167 ex lorentzidx::unarchive(const archive_node &n, const lst &sym_lst)
168 {
169         ex s = (new lorentzidx(n, sym_lst))->setflag(status_flags::dynallocated);
170
171         if (ex_to_lorentzidx(s).symbolic) {
172                 // If lorentzidx is in sym_lst, return the existing lorentzidx
173                 for (unsigned i=0; i<sym_lst.nops(); i++) {
174                         if (is_ex_of_type(sym_lst.op(i), lorentzidx) && (ex_to_lorentzidx(sym_lst.op(i)).name == ex_to_lorentzidx(s).name))
175                                 return sym_lst.op(i);
176                 }
177         }
178         return s;
179 }
180
181 /** Archive the object. */
182 void lorentzidx::archive(archive_node &n) const
183 {
184         inherited::archive(n);
185         n.add_bool("orthogonal_only", orthogonal_only);
186         n.add_unsigned("pdim", dim_parallel_space);
187 }
188
189 //////////
190 // functions overriding virtual functions from bases classes
191 //////////
192
193 // public
194
195 basic * lorentzidx::duplicate() const
196 {
197         debugmsg("lorentzidx duplicate",LOGLEVEL_DUPLICATE);
198         return new lorentzidx(*this);
199 }
200
201 void lorentzidx::printraw(std::ostream & os) const
202 {
203         debugmsg("lorentzidx printraw",LOGLEVEL_PRINT);
204
205         os << "lorentzidx(";
206
207         if (symbolic) {
208                 os << "symbolic,name=" << name;
209         } else {
210                 os << "non symbolic,value=" << value;
211         }
212
213         if (covariant) {
214                 os << ",covariant";
215         } else {
216                 os << ",contravariant";
217         }
218
219         if (orthogonal_only) {
220                 os << ",only orthogonal components at " << dim_parallel_space
221                    << " parallel dimensions";
222         } else {
223                 os << ",parallel and orthogonal components";
224         }
225
226         os << ",serial=" << serial;
227         os << ",hash=" << hashvalue << ",flags=" << flags;
228         os << ")";
229 }
230
231 void lorentzidx::printtree(std::ostream & os, unsigned indent) const
232 {
233         debugmsg("lorentzidx printtree",LOGLEVEL_PRINT);
234
235         os << std::string(indent,' ') << "lorentzidx: ";
236
237         if (symbolic) {
238                 os << "symbolic,name=" << name;
239         } else {
240                 os << "non symbolic,value=" << value;
241         }
242
243         if (covariant) {
244                 os << ",covariant";
245         } else {
246                 os << ",contravariant";
247         }
248
249         if (orthogonal_only) {
250                 os << ",only orthogonal components at " << dim_parallel_space
251                    << " parallel dimensions";
252         } else {
253                 os << ",parallel and orthogonal components";
254         }
255
256         os << ", serial=" << serial
257            << ", hash=" << hashvalue
258            << " (0x" << std::hex << hashvalue << std::dec << ")"
259            << ", flags=" << flags << std::endl;
260 }
261
262 void lorentzidx::print(std::ostream & os, unsigned upper_precedence) const
263 {
264         debugmsg("lorentzidx print",LOGLEVEL_PRINT);
265
266         if (covariant) {
267                 os << "_";
268         } else {
269                 os << "~";
270         }
271         if (symbolic) {
272                 os << name;
273         } else {
274                 os << value;
275         }
276 }
277
278 bool lorentzidx::info(unsigned inf) const
279 {
280         if (inf==info_flags::lorentzidx) return true;
281         return inherited::info(inf);
282 }
283
284 //////////
285 // new virtual functions which can be overridden by derived classes
286 //////////
287
288 // none
289
290 //////////
291 // non-virtual functions in this class
292 //////////
293
294 // public
295
296 /** Create anonymous contravariant copy of a symbolic Lorentz index. */
297 lorentzidx lorentzidx::create_anonymous_representative(void) const
298 {
299         GINAC_ASSERT(is_symbolic());
300         lorentzidx i_copy(*this);
301         i_copy.serial=0;
302         i_copy.name="anonymous_representative";
303         i_copy.covariant=false;
304         i_copy.clearflag(status_flags::dynallocated |
305                          status_flags::hash_calculated);
306         return i_copy;
307 }
308
309 //////////
310 // static member variables
311 //////////
312
313 // none
314
315 //////////
316 // global constants
317 //////////
318
319 const lorentzidx some_lorentzidx;
320 const std::type_info & typeid_lorentzidx = typeid(some_lorentzidx);
321
322 #ifndef NO_NAMESPACE_GINAC
323 } // namespace GiNaC
324 #endif // ndef NO_NAMESPACE_GINAC