- ASSERT macro renamed to GINAC_ASSERT
[ginac.git] / ginac / basic.cpp
1 /** @file basic.cpp
2  *
3  *  Implementation of GiNaC's ABC. */
4
5 /*
6  *  GiNaC Copyright (C) 1999 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 <iostream>
24 #include <typeinfo>
25 #include <stdexcept>
26
27 #include "basic.h"
28 #include "ex.h"
29 #include "numeric.h"
30 #include "power.h"
31 #include "symbol.h"
32 #include "lst.h"
33 #include "ncmul.h"
34 #include "utils.h"
35 #include "debugmsg.h"
36
37 namespace GiNaC {
38
39 //////////
40 // default constructor, destructor, copy constructor assignment operator and helpers
41 //////////
42
43 // public
44
45 #ifndef INLINE_BASIC_CONSTRUCTORS
46 basic::basic() : flags(0), refcount(0), tinfo_key(TINFO_BASIC)
47 {
48     debugmsg("basic default constructor",LOGLEVEL_CONSTRUCT);
49     // nothing to do
50 }
51
52 basic::~basic() 
53 {
54     debugmsg("basic destructor",LOGLEVEL_DESTRUCT);
55     destroy(0);
56     GINAC_ASSERT((!(flags & status_flags::dynallocated))||(refcount==0));
57 }
58
59 basic::basic(basic const & other) : flags(0), refcount(0), tinfo_key(TINFO_BASIC)
60 {
61     debugmsg("basic copy constructor",LOGLEVEL_CONSTRUCT);
62     copy(other);
63 }
64 #endif
65
66 basic const & basic::operator=(basic const & other)
67 {
68     debugmsg("basic operator=",LOGLEVEL_ASSIGNMENT);
69     if (this != &other) {
70         destroy(1);
71         copy(other);
72     }
73     return *this;
74 }
75
76 // protected
77
78 #if 0
79 void basic::copy(basic const & other)
80 {
81     flags=other.flags & ~ status_flags::dynallocated;
82     hashvalue=other.hashvalue;
83     tinfo_key=other.tinfo_key;
84 }
85 #endif
86
87 //////////
88 // other constructors
89 //////////
90
91 #ifndef INLINE_BASIC_CONSTRUCTORS
92 basic::basic(unsigned ti) : flags(0), refcount(0), tinfo_key(ti)
93 {
94     debugmsg("basic constructor with tinfo_key",LOGLEVEL_CONSTRUCT);
95     // nothing to do
96 }
97 #endif
98
99 //////////
100 // functions overriding virtual functions from bases classes
101 //////////
102
103 // none
104
105 //////////
106 // new virtual functions which can be overridden by derived classes
107 //////////
108
109 // public
110
111 basic * basic::duplicate() const
112 {
113     debugmsg("basic duplicate",LOGLEVEL_DUPLICATE);
114     return new basic(*this);
115 }
116
117 bool basic::info(unsigned inf) const
118 {
119     return false; // all possible properties are false for basic objects
120 }
121
122 int basic::nops() const
123 {
124     return 0;
125 }
126
127 ex basic::op(int const i) const
128 {
129     return (const_cast<basic *>(this))->let_op(i);
130 }
131
132 ex & basic::let_op(int const i)
133 {
134     throw(std::out_of_range("op() out of range"));
135 }
136
137 ex basic::operator[](ex const & index) const
138 {
139     if (is_exactly_of_type(*index.bp,numeric)) {
140         return op(static_cast<numeric const &>(*index.bp).to_int());
141     }
142     throw(std::invalid_argument("non-numeric indices not supported by this type"));
143 }
144
145 ex basic::operator[](int const i) const
146 {
147     return op(i);
148 }
149
150 bool basic::has(ex const & other) const
151 {
152     GINAC_ASSERT(other.bp!=0);
153     if (is_equal(*other.bp)) return true;
154     if (nops()>0) {
155         for (int i=0; i<nops(); i++) {
156             if (op(i).has(other)) return true;
157         }
158     }
159     return false;
160 }
161
162 int basic::degree(symbol const & s) const
163 {
164     return 0;
165 }
166
167 int basic::ldegree(symbol const & s) const
168 {
169     return 0;
170 }
171
172 ex basic::coeff(symbol const & s, int const n) const
173 {
174     return n==0 ? *this : exZERO();
175 }
176
177 ex basic::collect(symbol const & s) const
178 {
179     ex x;
180     int ldeg=ldegree(s);
181     int deg=degree(s);
182     for (int n=ldeg; n<=deg; n++) {
183         x += coeff(s,n)*power(s,n);
184     }
185     return x;
186 }
187
188 ex basic::eval(int level) const
189 {
190     return this->hold();
191 }
192
193 ex basic::evalf(int level) const
194 {
195     return *this;
196 }
197
198 ex basic::subs(lst const & ls, lst const & lr) const
199 {
200     return *this;
201 }
202
203 exvector basic::get_indices(void) const
204 {
205     return exvector(); // return an empty exvector
206 }
207
208 ex basic::simplify_ncmul(exvector const & v) const
209 {
210     return simplified_ncmul(v);
211 }
212
213 // protected
214
215 int basic::compare_same_type(basic const & other) const
216 {
217     return compare_pointers(this, &other);
218 }
219
220 bool basic::is_equal_same_type(basic const & other) const
221 {
222     return compare_same_type(other)==0;
223 }
224
225 unsigned basic::return_type(void) const
226 {
227     return return_types::commutative;
228 }
229
230 unsigned basic::return_type_tinfo(void) const
231 {
232     return tinfo();
233 }
234
235 unsigned basic::calchash(void) const
236 {
237     unsigned v=golden_ratio_hash(tinfo());
238     for (int i=0; i<nops(); i++) {
239         v=rotate_left_31(v);
240         v ^= (const_cast<basic *>(this))->let_op(i).gethash();
241     }
242
243     v = v & 0x7FFFFFFFU;
244     
245     // store calculated hash value only if object is already evaluated
246     if (flags & status_flags::evaluated) {
247         setflag(status_flags::hash_calculated);
248         hashvalue=v;
249     }
250
251     return v;
252 }
253
254 ex basic::expand(unsigned options) const
255 {
256     return this->setflag(status_flags::expanded);
257 }
258
259 //////////
260 // non-virtual functions in this class
261 //////////
262
263 // public
264
265 ex basic::subs(ex const & e) const
266 {
267     // accept 2 types of replacement expressions:
268     //   - symbol==ex
269     //   - lst(symbol1==ex1,symbol2==ex2,...)
270     // convert to subs(lst(symbol1,symbol2,...),lst(ex1,ex2,...))
271     // additionally, idx can be used instead of symbol
272     if (e.info(info_flags::relation_equal)) {
273         return subs(lst(e));
274     }
275     if (!e.info(info_flags::list)) {
276         throw(std::invalid_argument("basic::subs(ex): argument must be a list"));
277     }
278     lst ls;
279     lst lr;
280     for (int i=0; i<e.nops(); i++) {
281         if (!e.op(i).info(info_flags::relation_equal)) {
282             throw(std::invalid_argument("basic::subs(ex): argument must be a list or equations"));
283         }
284         if (!e.op(i).op(0).info(info_flags::symbol)) {
285             if (!e.op(i).op(0).info(info_flags::idx)) {
286                 throw(std::invalid_argument("basic::subs(ex): lhs must be a symbol or an idx"));
287             }
288         }
289         ls.append(e.op(i).op(0));
290         lr.append(e.op(i).op(1));
291     }
292     return subs(ls,lr);
293 }
294
295 // compare functions to sort expressions canonically
296 // all compare functions return: -1 for *this less than other, 0 equal, 1 greater
297
298 /*
299 int basic::compare(basic const & other) const
300 {
301     const type_info & typeid_this = typeid(*this);
302     const type_info & typeid_other = typeid(other);
303
304     if (typeid_this==typeid_other) {
305         return compare_same_type(other);
306     }
307
308     // special rule: sort numeric() to end
309     if (typeid_this==typeid_numeric) return 1;
310     if (typeid_other==typeid_numeric) return -1;
311
312     // otherwise: sort according to type_info order (arbitrary, but well defined)
313     return typeid_this.before(typeid_other) ? -1 : 1;
314 }
315 */
316
317 int basic::compare(basic const & other) const
318 {
319     unsigned hash_this = gethash();
320     unsigned hash_other = other.gethash();
321
322     if (hash_this<hash_other) return -1;
323     if (hash_this>hash_other) return 1;
324
325     unsigned typeid_this = tinfo();
326     unsigned typeid_other = other.tinfo();
327
328     if (typeid_this<typeid_other) {
329         /*
330         cout << "hash collision, different types: " 
331              << *this << " and " << other << endl;
332         this->printraw(cout);
333         cout << " and ";
334         other.printraw(cout);
335         cout << endl;
336         */
337         return -1;
338     }
339     if (typeid_this>typeid_other) {
340         /*
341         cout << "hash collision, different types: " 
342              << *this << " and " << other << endl;
343         this->printraw(cout);
344         cout << " and ";
345         other.printraw(cout);
346         cout << endl;
347         */
348         return 1;
349     }
350
351     GINAC_ASSERT(typeid(*this)==typeid(other));
352
353     int cmpval=compare_same_type(other);
354     if ((cmpval!=0)&&(hash_this<0x80000000U)) {
355         /*
356         cout << "hash collision, same type: " 
357              << *this << " and " << other << endl;
358         this->printraw(cout);
359         cout << " and ";
360         other.printraw(cout);
361         cout << endl;
362         */
363     }
364     return cmpval;
365 }
366
367 bool basic::is_equal(basic const & other) const
368 {
369     unsigned hash_this = gethash();
370     unsigned hash_other = other.gethash();
371
372     if (hash_this!=hash_other) return false;
373
374     unsigned typeid_this = tinfo();
375     unsigned typeid_other = other.tinfo();
376
377     if (typeid_this!=typeid_other) return false;
378
379     GINAC_ASSERT(typeid(*this)==typeid(other));
380
381     return is_equal_same_type(other);
382 }
383
384 // protected
385
386 basic const & basic::hold(void) const
387 {
388     return setflag(status_flags::evaluated);
389 }
390
391 void basic::ensure_if_modifiable(void) const
392 {
393     if (refcount>1) {
394         throw(std::runtime_error("cannot modify multiply referenced object"));
395     }
396 }
397
398 //////////
399 // static member variables
400 //////////
401
402 // protected
403
404 unsigned basic::precedence=70;
405 unsigned basic::delta_indent=4;
406
407 //////////
408 // global constants
409 //////////
410
411 const basic some_basic;
412 type_info const & typeid_basic=typeid(some_basic);
413
414 //////////
415 // global variables
416 //////////
417
418 int max_recursion_level=1024;
419
420 } // namespace GiNaC