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