8d41e92cb96603c84a3f77d31301a5a881a0686e
[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-2000 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_GINAC_NAMESPACE
33 namespace GiNaC {
34 #endif // ndef NO_GINAC_NAMESPACE
35
36 //////////
37 // default constructor, destructor, copy constructor assignment operator and helpers
38 //////////
39
40 // public
41
42 clifford::clifford()
43 {
44     debugmsg("clifford default constructor",LOGLEVEL_CONSTRUCT);
45     serial=next_serial++;
46     name=autoname_prefix()+ToString(serial);
47     tinfo_key=TINFO_clifford;
48 }
49
50 clifford::~clifford()
51 {
52     debugmsg("clifford destructor",LOGLEVEL_DESTRUCT);
53     destroy(0);
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(1);
67         copy(other);
68     }
69     return *this;
70 }
71
72 // protected
73
74 void clifford::copy(const clifford & other)
75 {
76     indexed::copy(other);
77     name=other.name;
78     serial=other.serial;
79 }
80
81 void clifford::destroy(bool call_parent)
82 {
83     if (call_parent) {
84         indexed::destroy(call_parent);
85     }
86 }
87
88 //////////
89 // other constructors
90 //////////
91
92 // public
93
94 clifford::clifford(const string & initname)
95 {
96     debugmsg("clifford constructor from string",LOGLEVEL_CONSTRUCT);
97     name=initname;
98     serial=next_serial++;
99     tinfo_key=TINFO_clifford;
100 }
101
102 //////////
103 // functions overriding virtual functions from bases classes
104 //////////
105
106 // public
107
108 basic * clifford::duplicate() const
109 {
110     debugmsg("clifford duplicate",LOGLEVEL_DUPLICATE);
111     return new clifford(*this);
112 }
113
114 void clifford::printraw(ostream & os) const
115 {
116     debugmsg("clifford printraw",LOGLEVEL_PRINT);
117     os << "clifford(" << "name=" << name << ",serial=" << serial
118        << ",indices=";
119     printrawindices(os);
120     os << ",hash=" << hashvalue << ",flags=" << flags << ")";
121 }
122
123 void clifford::printtree(ostream & os, unsigned indent) const
124 {
125     debugmsg("clifford printtree",LOGLEVEL_PRINT);
126     os << string(indent,' ') << name << " (clifford): "
127        << "serial=" << serial << ","
128        << seq.size() << "indices=";
129     printtreeindices(os,indent);
130     os << ", hash=" << hashvalue << " (0x" << hex << hashvalue << dec << ")"
131        << ", flags=" << flags << endl;
132 }
133
134 void clifford::print(ostream & os, unsigned upper_precedence) const
135 {
136     debugmsg("clifford print",LOGLEVEL_PRINT);
137     os << name;
138     printindices(os);
139 }
140
141 void clifford::printcsrc(ostream & os, unsigned type, unsigned upper_precedence) const
142 {
143     debugmsg("clifford print csrc",LOGLEVEL_PRINT);
144     print(os,upper_precedence);
145 }
146
147 bool clifford::info(unsigned inf) const
148 {
149     return indexed::info(inf);
150 }
151
152 // protected
153
154 int clifford::compare_same_type(const basic & other) const
155 {
156     GINAC_ASSERT(other.tinfo() == TINFO_clifford);
157     const clifford *o = static_cast<const clifford *>(&other);
158     if (serial==o->serial) {
159         return indexed::compare_same_type(other);
160     }
161     return serial < o->serial ? -1 : 1;
162 }
163
164 ex clifford::simplify_ncmul(const exvector & v) const
165 {
166     return simplified_ncmul(v);
167 }
168
169 unsigned clifford::calchash(void) const
170 {
171     hashvalue=golden_ratio_hash(golden_ratio_hash(0x55555556U ^
172                                                   golden_ratio_hash(tinfo_key) ^
173                                                   serial));
174     setflag(status_flags::hash_calculated);
175     return hashvalue;
176 }
177
178 //////////
179 // virtual functions which can be overridden by derived classes
180 //////////
181
182 // none
183
184 //////////
185 // non-virtual functions in this class
186 //////////
187
188 void clifford::setname(const string & n)
189 {
190     name=n;
191 }
192
193 // private
194
195 string & clifford::autoname_prefix(void)
196 {
197     static string * s=new string("clifford");
198     return *s;
199 }
200
201 //////////
202 // static member variables
203 //////////
204
205 // private
206
207 unsigned clifford::next_serial=0;
208
209 //////////
210 // global constants
211 //////////
212
213 const clifford some_clifford;
214 const type_info & typeid_clifford=typeid(some_clifford);
215
216 #ifndef NO_GINAC_NAMESPACE
217 } // namespace GiNaC
218 #endif // ndef NO_GINAC_NAMESPACE