GINAC_DECLARE_REGISTERED_CLASS declares duplicate() and compare_same_type(),
[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 "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 // protected
52
53 void clifford::copy(const clifford & other)
54 {
55         inherited::copy(other);
56 }
57
58 void clifford::destroy(bool call_parent)
59 {
60         if (call_parent) inherited::destroy(call_parent);
61 }
62
63 //////////
64 // other constructors
65 //////////
66
67 // public
68
69 clifford::clifford(const std::string & n, const ex & mu) : inherited(lortensor_symbolic, n, mu)
70 {
71         debugmsg("clifford constructor from string,ex",LOGLEVEL_CONSTRUCT);
72         tinfo_key=TINFO_clifford;
73 }
74
75 clifford::clifford(const std::string & n, const exvector & iv) : inherited(lortensor_symbolic, n, iv)
76 {
77         debugmsg("clifford constructor from string,exvector", LOGLEVEL_CONSTRUCT);
78         GINAC_ASSERT(all_of_type_lorentzidx());
79         tinfo_key=TINFO_clifford;
80 }
81
82 clifford::clifford(const std::string & n, exvector *ivp) : inherited(lortensor_symbolic, n, *ivp)
83 {
84         debugmsg("clifford constructor from string,exvector", LOGLEVEL_CONSTRUCT);
85         GINAC_ASSERT(all_of_type_lorentzidx());
86         tinfo_key=TINFO_clifford;
87 }
88
89 //////////
90 // archiving
91 //////////
92
93 /** Construct object from archive_node. */
94 clifford::clifford(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst)
95 {
96         debugmsg("clifford constructor from archive_node", LOGLEVEL_CONSTRUCT);
97 }
98
99 /** Unarchive the object. */
100 ex clifford::unarchive(const archive_node &n, const lst &sym_lst)
101 {
102         return (new clifford(n, sym_lst))->setflag(status_flags::dynallocated);
103 }
104
105 /** Archive the object. */
106 void clifford::archive(archive_node &n) const
107 {
108         inherited::archive(n);
109 }
110
111 //////////
112 // functions overriding virtual functions from bases classes
113 //////////
114
115 // public
116
117 void clifford::printraw(std::ostream & os) const
118 {
119         debugmsg("clifford printraw",LOGLEVEL_PRINT);
120         os << "clifford(" << "indices=";
121         printrawindices(os);
122         os << ",hash=" << hashvalue << ",flags=" << flags << ")";
123 }
124
125 void clifford::printtree(std::ostream & os, unsigned indent) const
126 {
127         debugmsg("clifford printtree",LOGLEVEL_PRINT);
128         os << std::string(indent,' ') << " (clifford): "
129            << seq.size() << "indices=";
130         printtreeindices(os, indent);
131         os << ", hash=" << hashvalue
132            << " (0x" << std::hex << hashvalue << std::dec << ")"
133            << ", flags=" << flags << std::endl;
134 }
135
136 void clifford::print(std::ostream & os, unsigned upper_precedence) const
137 {
138         debugmsg("clifford print",LOGLEVEL_PRINT);
139         os << name;
140         printindices(os);
141 }
142
143 bool clifford::info(unsigned inf) const
144 {
145         return inherited::info(inf);
146 }
147
148 // protected
149
150 int clifford::compare_same_type(const basic & other) const
151 {
152         GINAC_ASSERT(is_of_type(other,clifford));
153         // only compare indices
154         return exprseq::compare_same_type(other);
155 }
156
157 bool clifford::is_equal_same_type(const basic & other) const
158 {
159         GINAC_ASSERT(is_of_type(other,clifford));
160         // only compare indices
161         return exprseq::is_equal_same_type(other);
162 }
163
164 ex clifford::thisexprseq(const exvector & v) const
165 {
166         return clifford(name, v);
167 }
168
169 ex clifford::thisexprseq(exvector *vp) const
170 {
171         return clifford(name, vp);
172 }
173
174 ex clifford::simplify_ncmul(const exvector & v) const
175 {
176         return simplified_ncmul(v);
177 }
178
179 //////////
180 // friend functions
181 //////////
182
183 /** Construct an object representing a Dirac gamma matrix. The index must
184  *  be of class lorentzidx.
185  *
186  *  @param mu Index
187  *  @return newly constructed object */
188 clifford clifford_gamma(const ex & mu)
189 {
190         return clifford("gamma", mu);
191 }
192
193 #ifndef NO_NAMESPACE_GINAC
194 } // namespace GiNaC
195 #endif // ndef NO_NAMESPACE_GINAC