- added documentation to the indexed, color, lortensor and clifford classes
[ginac.git] / 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 "utils.h"
30 #include "debugmsg.h"
31
32 #ifndef NO_NAMESPACE_GINAC
33 namespace GiNaC {
34 #endif // ndef NO_NAMESPACE_GINAC
35
36 GINAC_IMPLEMENT_REGISTERED_CLASS(clifford, lortensor)
37
38 //////////
39 // default constructor, destructor, copy constructor assignment operator and helpers
40 //////////
41
42 // public
43
44 clifford::clifford()
45 {
46         debugmsg("clifford default constructor",LOGLEVEL_CONSTRUCT);
47         tinfo_key = TINFO_clifford;
48 }
49
50 clifford::~clifford()
51 {
52         debugmsg("clifford destructor",LOGLEVEL_DESTRUCT);
53         destroy(false);
54 }
55
56 clifford::clifford(const clifford & other)
57 {
58         debugmsg("clifford copy constructor",LOGLEVEL_CONSTRUCT);
59         copy(other);
60 }
61
62 const clifford & clifford::operator=(const clifford & other)
63 {
64         debugmsg("clifford operator=",LOGLEVEL_ASSIGNMENT);
65         if (this != &other) {
66                 destroy(true);
67                 copy(other);
68         }
69         return *this;
70 }
71
72 // protected
73
74 void clifford::copy(const clifford & other)
75 {
76         inherited::copy(other);
77 }
78
79 void clifford::destroy(bool call_parent)
80 {
81         if (call_parent) inherited::destroy(call_parent);
82 }
83
84 //////////
85 // other constructors
86 //////////
87
88 // public
89
90 clifford::clifford(const std::string & n, const ex & mu) : inherited(lortensor_symbolic, n, mu)
91 {
92         debugmsg("clifford constructor from string,ex",LOGLEVEL_CONSTRUCT);
93         tinfo_key=TINFO_clifford;
94 }
95
96 //////////
97 // functions overriding virtual functions from bases classes
98 //////////
99
100 // public
101
102 basic * clifford::duplicate() const
103 {
104         debugmsg("clifford duplicate",LOGLEVEL_DUPLICATE);
105         return new clifford(*this);
106 }
107
108 void clifford::printraw(std::ostream & os) const
109 {
110         debugmsg("clifford printraw",LOGLEVEL_PRINT);
111         os << "clifford(" << "indices=";
112         printrawindices(os);
113         os << ",hash=" << hashvalue << ",flags=" << flags << ")";
114 }
115
116 void clifford::printtree(std::ostream & os, unsigned indent) const
117 {
118         debugmsg("clifford printtree",LOGLEVEL_PRINT);
119         os << std::string(indent,' ') << " (clifford): "
120            << seq.size() << "indices=";
121         printtreeindices(os, indent);
122         os << ", hash=" << hashvalue
123            << " (0x" << std::hex << hashvalue << std::dec << ")"
124            << ", flags=" << flags << std::endl;
125 }
126
127 void clifford::print(std::ostream & os, unsigned upper_precedence) const
128 {
129         debugmsg("clifford print",LOGLEVEL_PRINT);
130         os << name;
131         printindices(os);
132 }
133
134 bool clifford::info(unsigned inf) const
135 {
136         return inherited::info(inf);
137 }
138
139 // protected
140
141 int clifford::compare_same_type(const basic & other) const
142 {
143         GINAC_ASSERT(is_of_type(other,clifford));
144         // only compare indices
145         return exprseq::compare_same_type(other);
146 }
147
148 bool clifford::is_equal_same_type(const basic & other) const
149 {
150         GINAC_ASSERT(is_of_type(other,clifford));
151         // only compare indices
152         return exprseq::is_equal_same_type(other);
153 }
154
155 ex clifford::simplify_ncmul(const exvector & v) const
156 {
157         return simplified_ncmul(v);
158 }
159
160 //////////
161 // virtual functions which can be overridden by derived classes
162 //////////
163
164 // none
165
166 //////////
167 // non-virtual functions in this class
168 //////////
169
170 // none
171
172 //////////
173 // static member variables
174 //////////
175
176 // none
177
178 //////////
179 // friend functions
180 //////////
181
182 /** Construct an object representing a Dirac gamma matrix. The index must
183  *  be of class lorentzidx.
184  *
185  *  @param mu Index
186  *  @return newly constructed object */
187 clifford clifford_gamma(const ex & mu)
188 {
189         return clifford("gamma", mu);
190 }
191
192 //////////
193 // global constants
194 //////////
195
196 const clifford some_clifford;
197 const std::type_info & typeid_clifford = typeid(some_clifford);
198
199 #ifndef NO_NAMESPACE_GINAC
200 } // namespace GiNaC
201 #endif // ndef NO_NAMESPACE_GINAC