- ex::numer() and ex::denom() now make use of the new normal()
[ginac.git] / ginac / ex.cpp
1 /** @file ex.cpp
2  *
3  *  Implementation of GiNaC's light-weight expression handles. */
4
5 /*
6  *  GiNaC Copyright (C) 1999-2000 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
25 #include "ex.h"
26 #include "add.h"
27 #include "mul.h"
28 #include "ncmul.h"
29 #include "numeric.h"
30 #include "power.h"
31 #include "relational.h"
32 #include "debugmsg.h"
33 #include "utils.h"
34
35 #ifndef NO_NAMESPACE_GINAC
36 namespace GiNaC {
37 #endif // ndef NO_NAMESPACE_GINAC
38
39 //////////
40 // default constructor, destructor, copy constructor assignment operator and helpers
41 //////////
42
43 // public
44
45 #ifndef INLINE_EX_CONSTRUCTORS
46
47 ex::ex() : bp(ex0().bp)
48 {
49     debugmsg("ex default constructor",LOGLEVEL_CONSTRUCT);
50     GINAC_ASSERT(ex0().bp!=0);
51     GINAC_ASSERT(ex0().bp->flags & status_flags::dynallocated);
52     GINAC_ASSERT(bp!=0);
53     ++bp->refcount;
54 }
55
56 ex::~ex()
57 {
58     debugmsg("ex destructor",LOGLEVEL_DESTRUCT);
59     GINAC_ASSERT(bp!=0);
60     GINAC_ASSERT(bp->flags & status_flags::dynallocated);
61     if (--bp->refcount == 0) {
62         delete bp;
63     }
64 }
65
66 ex::ex(const ex & other) : bp(other.bp)
67 {
68     debugmsg("ex copy constructor",LOGLEVEL_CONSTRUCT);
69     GINAC_ASSERT(bp!=0);
70     GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
71     ++bp->refcount;
72 }
73
74 const ex & ex::operator=(const ex & other)
75 {
76     debugmsg("ex operator=",LOGLEVEL_ASSIGNMENT);
77     GINAC_ASSERT(bp!=0);
78     GINAC_ASSERT(bp->flags & status_flags::dynallocated);
79     GINAC_ASSERT(other.bp!=0);
80     GINAC_ASSERT(other.bp->flags & status_flags::dynallocated);
81     ++other.bp->refcount;
82     basic * tmpbp=other.bp;
83     if (--bp->refcount==0) {
84             delete bp;
85     }
86     bp=tmpbp;
87     return *this;
88 }
89
90 #endif // ndef INLINE_EX_CONSTRUCTORS
91
92 //////////
93 // other constructors
94 //////////
95
96 // public
97
98 #ifndef INLINE_EX_CONSTRUCTORS
99
100 ex::ex(const basic & other)
101 {
102     debugmsg("ex constructor from basic",LOGLEVEL_CONSTRUCT);
103     construct_from_basic(other);
104 }
105
106 ex::ex(int i)
107 {
108     debugmsg("ex constructor from int",LOGLEVEL_CONSTRUCT);
109     construct_from_int(i);
110 }
111
112 ex::ex(unsigned int i)
113 {
114     debugmsg("ex constructor from unsigned int",LOGLEVEL_CONSTRUCT);
115     construct_from_uint(i);
116 }
117
118 ex::ex(long i)
119 {
120     debugmsg("ex constructor from long",LOGLEVEL_CONSTRUCT);
121     construct_from_long(i);
122 }
123
124 ex::ex(unsigned long i)
125 {
126     debugmsg("ex constructor from unsigned long",LOGLEVEL_CONSTRUCT);
127     construct_from_ulong(i);
128 }
129
130 ex::ex(double const d)
131 {
132     debugmsg("ex constructor from double",LOGLEVEL_CONSTRUCT);
133     construct_from_double(d);
134 }
135
136 #endif // ndef INLINE_EX_CONSTRUCTORS
137
138 //////////
139 // functions overriding virtual functions from bases classes
140 //////////
141
142 // none
143
144 //////////
145 // new virtual functions which can be overridden by derived classes
146 //////////
147
148 // none
149
150 //////////
151 // non-virtual functions in this class
152 //////////
153
154 // public
155
156 /** Swap the contents of two expressions. */
157 void ex::swap(ex & other)
158 {
159     debugmsg("ex swap",LOGLEVEL_MEMBER_FUNCTION);
160
161     GINAC_ASSERT(bp!=0);
162     GINAC_ASSERT(bp->flags & status_flags::dynallocated);
163     GINAC_ASSERT(other.bp!=0);
164     GINAC_ASSERT(other.bp->flags & status_flags::dynallocated);
165     
166     basic * tmpbp=bp;
167     bp=other.bp;
168     other.bp=tmpbp;
169 }
170
171 /** Output formatted to be useful as ginsh input. */
172 void ex::print(ostream & os, unsigned upper_precedence) const
173 {
174     debugmsg("ex print",LOGLEVEL_PRINT);
175     GINAC_ASSERT(bp!=0);
176     bp->print(os,upper_precedence);
177 }
178
179 void ex::printraw(ostream & os) const
180 {
181     debugmsg("ex printraw",LOGLEVEL_PRINT);
182     GINAC_ASSERT(bp!=0);
183     os << "ex(";
184     bp->printraw(os);
185     os << ")";
186 }
187
188 void ex::printtree(ostream & os, unsigned indent) const
189 {
190     debugmsg("ex printtree",LOGLEVEL_PRINT);
191     GINAC_ASSERT(bp!=0);
192     // os << "refcount=" << bp->refcount << " ";
193     bp->printtree(os,indent);
194 }
195
196 /** Print expression as a C++ statement. The output looks like
197  *  "<type> <var_name> = <expression>;". The "type" parameter has an effect
198  *  on how number literals are printed.
199  *
200  *  @param os output stream
201  *  @param type variable type (one of the csrc_types)
202  *  @param var_name variable name to be printed */
203 void ex::printcsrc(ostream & os, unsigned type, const char *var_name) const
204 {
205     debugmsg("ex print csrc", LOGLEVEL_PRINT);
206     GINAC_ASSERT(bp!=0);
207     switch (type) {
208         case csrc_types::ctype_float:
209             os << "float ";
210             break;
211         case csrc_types::ctype_double:
212             os << "double ";
213             break;
214         case csrc_types::ctype_cl_N:
215             os << "cl_N ";
216             break;
217     }
218     os << var_name << " = ";
219     bp->printcsrc(os, type, 0);
220     os << ";\n";
221 }
222
223 /** Little wrapper arount print to be called within a debugger. */
224 void ex::dbgprint(void) const
225 {
226     debugmsg("ex dbgprint",LOGLEVEL_PRINT);
227     GINAC_ASSERT(bp!=0);
228     bp->dbgprint();
229 }
230
231 /** Little wrapper arount printtree to be called within a debugger. */
232 void ex::dbgprinttree(void) const
233 {
234     debugmsg("ex dbgprinttree",LOGLEVEL_PRINT);
235     GINAC_ASSERT(bp!=0);
236     bp->dbgprinttree();
237 }
238
239 bool ex::info(unsigned inf) const
240 {
241     return bp->info(inf);
242 }
243
244 unsigned ex::nops() const
245 {
246     GINAC_ASSERT(bp!=0);
247     return bp->nops();
248 }
249
250 ex ex::expand(unsigned options) const
251 {
252     GINAC_ASSERT(bp!=0);
253     return bp->expand(options);
254 }
255
256 bool ex::has(const ex & other) const
257 {
258     GINAC_ASSERT(bp!=0);
259     return bp->has(other);
260 }
261
262 int ex::degree(const symbol & s) const
263 {
264     GINAC_ASSERT(bp!=0);
265     return bp->degree(s);
266 }
267
268 int ex::ldegree(const symbol & s) const
269 {
270     GINAC_ASSERT(bp!=0);
271     return bp->ldegree(s);
272 }
273
274 ex ex::coeff(const symbol & s, int n) const
275 {
276     GINAC_ASSERT(bp!=0);
277     return bp->coeff(s,n);
278 }
279
280 ex ex::collect(const symbol & s) const
281 {
282     GINAC_ASSERT(bp!=0);
283     return bp->collect(s);
284 }
285
286 ex ex::eval(int level) const
287 {
288     GINAC_ASSERT(bp!=0);
289     return bp->eval(level);
290 }
291
292 ex ex::evalf(int level) const
293 {
294     GINAC_ASSERT(bp!=0);
295     return bp->evalf(level);
296 }
297
298 /** Compute partial derivative of an expression.
299  *
300  *  @param s  symbol by which the expression is derived
301  *  @param nth  order of derivative (default 1)
302  *  @return partial derivative as a new expression */
303 ex ex::diff(const symbol & s, unsigned nth) const
304 {
305     GINAC_ASSERT(bp!=0);
306
307     if (!nth)
308         return *this;
309     else
310         return bp->diff(s, nth);
311 }
312
313 ex ex::subs(const lst & ls, const lst & lr) const
314 {
315     GINAC_ASSERT(bp!=0);
316     return bp->subs(ls,lr);
317 }
318
319 ex ex::subs(const ex & e) const
320 {
321     GINAC_ASSERT(bp!=0);
322     return bp->subs(e);
323 }
324
325 exvector ex::get_indices(void) const
326 {
327     GINAC_ASSERT(bp!=0);
328     return bp->get_indices();
329 }
330
331 ex ex::simplify_ncmul(const exvector & v) const
332 {
333     GINAC_ASSERT(bp!=0);
334     return bp->simplify_ncmul(v);
335 }
336
337 ex ex::operator[](const ex & index) const
338 {
339     debugmsg("ex operator[ex]",LOGLEVEL_OPERATOR);
340     GINAC_ASSERT(bp!=0);
341     return (*bp)[index];
342 }
343
344 ex ex::operator[](int i) const
345 {
346     debugmsg("ex operator[int]",LOGLEVEL_OPERATOR);
347     GINAC_ASSERT(bp!=0);
348     return (*bp)[i];
349 }
350
351 /** Return operand/member at position i. */
352 ex ex::op(int i) const
353 {
354     debugmsg("ex op()",LOGLEVEL_MEMBER_FUNCTION);
355     GINAC_ASSERT(bp!=0);
356     return bp->op(i);
357 }
358
359 /** Return modifyable operand/member at position i. */
360 ex & ex::let_op(int i)
361 {
362     debugmsg("ex let_op()",LOGLEVEL_MEMBER_FUNCTION);
363     makewriteable();
364     GINAC_ASSERT(bp!=0);
365     return bp->let_op(i);
366 }
367
368 /** Left hand side of relational expression. */
369 ex ex::lhs(void) const
370 {
371     debugmsg("ex lhs()",LOGLEVEL_MEMBER_FUNCTION);
372     GINAC_ASSERT(is_ex_of_type(*this,relational));
373     return (*static_cast<relational *>(bp)).lhs();
374 }
375
376 /** Right hand side of relational expression. */
377 ex ex::rhs(void) const
378 {
379     debugmsg("ex rhs()",LOGLEVEL_MEMBER_FUNCTION);
380     GINAC_ASSERT(is_ex_of_type(*this,relational));
381     return (*static_cast<relational *>(bp)).rhs();
382 }
383
384 #ifndef INLINE_EX_CONSTRUCTORS
385 int ex::compare(const ex & other) const
386 {
387     GINAC_ASSERT(bp!=0);
388     GINAC_ASSERT(other.bp!=0);
389     if (bp==other.bp) {
390         // special case: both expression point to same basic, trivially equal
391         return 0; 
392     }
393     return bp->compare(*other.bp);
394 }
395 #endif // ndef INLINE_EX_CONSTRUCTORS
396
397 #ifndef INLINE_EX_CONSTRUCTORS
398 bool ex::is_equal(const ex & other) const
399 {
400     GINAC_ASSERT(bp!=0);
401     GINAC_ASSERT(other.bp!=0);
402     if (bp==other.bp) {
403         // special case: both expression point to same basic, trivially equal
404         return true; 
405     }
406     return bp->is_equal(*other.bp);
407 }
408 #endif // ndef INLINE_EX_CONSTRUCTORS
409
410 unsigned ex::return_type(void) const
411 {
412     GINAC_ASSERT(bp!=0);
413     return bp->return_type();
414 }
415
416 unsigned ex::return_type_tinfo(void) const
417 {
418     GINAC_ASSERT(bp!=0);
419     return bp->return_type_tinfo();
420 }
421
422 unsigned ex::gethash(void) const
423 {
424     GINAC_ASSERT(bp!=0);
425     return bp->gethash();
426 }
427
428 ex ex::exadd(const ex & rh) const
429 {
430     return (new add(*this,rh))->setflag(status_flags::dynallocated);
431 }
432
433 ex ex::exmul(const ex & rh) const
434 {
435     return (new mul(*this,rh))->setflag(status_flags::dynallocated);
436 }
437
438 ex ex::exncmul(const ex & rh) const
439 {
440     return (new ncmul(*this,rh))->setflag(status_flags::dynallocated);
441 }
442
443 // private
444
445 void ex::makewriteable()
446 {
447     debugmsg("ex makewriteable",LOGLEVEL_MEMBER_FUNCTION);
448     GINAC_ASSERT(bp!=0);
449     GINAC_ASSERT(bp->flags & status_flags::dynallocated);
450     if (bp->refcount > 1) {
451         basic * bp2 = bp->duplicate();
452         ++bp2->refcount;
453         bp2->setflag(status_flags::dynallocated);
454         --bp->refcount;
455         bp = bp2;
456     }
457     GINAC_ASSERT(bp->refcount == 1);
458 }
459
460 void ex::construct_from_basic(const basic & other)
461 {
462     if ((other.flags & status_flags::evaluated)==0) {
463         // cf. copy constructor
464         const ex & tmpex = other.eval(1); // evaluate only one (top) level
465         bp = tmpex.bp;
466         GINAC_ASSERT(bp!=0);
467         GINAC_ASSERT(bp->flags & status_flags::dynallocated);
468         ++bp->refcount;
469         if ((other.flags & status_flags::dynallocated)&&(other.refcount==0)) {
470             delete &const_cast<basic &>(other);
471         }
472     } else {
473         if (other.flags & status_flags::dynallocated) {
474             bp = &const_cast<basic &>(other);
475         } else {
476             bp = other.duplicate();
477             bp->setflag(status_flags::dynallocated);
478         }
479         GINAC_ASSERT(bp!=0);
480         // bp->clearflag(status_flags::evaluated);
481         ++bp->refcount;
482     }
483     GINAC_ASSERT(bp!=0);
484     GINAC_ASSERT(bp->flags & status_flags::dynallocated);
485 }
486
487 void ex::construct_from_int(int i)
488 {
489     switch (i) {  // some tiny efficiency-hack
490     case -2:
491         bp = _ex_2().bp;
492         ++bp->refcount;
493         break;
494     case -1:
495         bp = _ex_1().bp;
496         ++bp->refcount;
497         break;
498     case 0:
499         bp = _ex0().bp;
500         ++bp->refcount;
501         break;
502     case 1:
503         bp = _ex1().bp;
504         ++bp->refcount;
505         break;
506     case 2:
507         bp = _ex2().bp;
508         ++bp->refcount;
509         break;
510     default:
511         bp = new numeric(i);
512         bp->setflag(status_flags::dynallocated);
513         ++bp->refcount;
514         GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
515         GINAC_ASSERT(bp->refcount=1);
516     }
517 }
518     
519 void ex::construct_from_uint(unsigned int i)
520 {
521     switch (i) {  // some tiny efficiency-hack
522     case -2:
523         bp = _ex_2().bp;
524         ++bp->refcount;
525         break;
526     case -1:
527         bp = _ex_1().bp;
528         ++bp->refcount;
529         break;
530     case 0:
531         bp = _ex0().bp;
532         ++bp->refcount;
533         break;
534     case 1:
535         bp = _ex1().bp;
536         ++bp->refcount;
537         break;
538     case 2:
539         bp = _ex2().bp;
540         ++bp->refcount;
541         break;
542     default:
543         bp = new numeric(i);
544         bp->setflag(status_flags::dynallocated);
545         ++bp->refcount;
546         GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
547         GINAC_ASSERT(bp->refcount=1);
548     }
549 }
550     
551 void ex::construct_from_long(long i)
552 {
553     switch (i) {  // some tiny efficiency-hack
554     case -2:
555         bp = _ex_2().bp;
556         ++bp->refcount;
557         break;
558     case -1:
559         bp = _ex_1().bp;
560         ++bp->refcount;
561         break;
562     case 0:
563         bp = _ex0().bp;
564         ++bp->refcount;
565         break;
566     case 1:
567         bp = _ex1().bp;
568         ++bp->refcount;
569         break;
570     case 2:
571         bp = _ex2().bp;
572         ++bp->refcount;
573         break;
574     default:
575         bp = new numeric(i);
576         bp->setflag(status_flags::dynallocated);
577         ++bp->refcount;
578         GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
579         GINAC_ASSERT(bp->refcount=1);
580     }
581 }
582     
583 void ex::construct_from_ulong(unsigned long i)
584 {
585     switch (i) {  // some tiny efficiency-hack
586     case -2:
587         bp = _ex_2().bp;
588         ++bp->refcount;
589         break;
590     case -1:
591         bp = _ex_1().bp;
592         ++bp->refcount;
593         break;
594     case 0:
595         bp = _ex0().bp;
596         ++bp->refcount;
597         break;
598     case 1:
599         bp = _ex1().bp;
600         ++bp->refcount;
601         break;
602     case 2:
603         bp = _ex2().bp;
604         ++bp->refcount;
605         break;
606     default:
607         bp = new numeric(i);
608         bp->setflag(status_flags::dynallocated);
609         ++bp->refcount;
610         GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
611         GINAC_ASSERT(bp->refcount=1);
612     }
613 }
614     
615 void ex::construct_from_double(double d)
616 {
617     bp = new numeric(d);
618     bp->setflag(status_flags::dynallocated);
619     ++bp->refcount;
620     GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
621     GINAC_ASSERT(bp->refcount=1);
622 }
623     
624 //////////
625 // static member variables
626 //////////
627
628 // none
629
630 //////////
631 // functions which are not member functions
632 //////////
633
634 // none
635
636 //////////
637 // global functions
638 //////////
639
640 // none
641
642
643 #ifndef NO_NAMESPACE_GINAC
644 } // namespace GiNaC
645 #endif // ndef NO_NAMESPACE_GINAC