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