- The status_flags::expanded is now used on some occasions.
[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     if (bp->flags & status_flags::expanded)
254         return *bp;
255     else
256         return bp->expand(options);
257 }
258
259 bool ex::has(const ex & other) const
260 {
261     GINAC_ASSERT(bp!=0);
262     return bp->has(other);
263 }
264
265 int ex::degree(const symbol & s) const
266 {
267     GINAC_ASSERT(bp!=0);
268     return bp->degree(s);
269 }
270
271 int ex::ldegree(const symbol & s) const
272 {
273     GINAC_ASSERT(bp!=0);
274     return bp->ldegree(s);
275 }
276
277 ex ex::coeff(const symbol & s, int n) const
278 {
279     GINAC_ASSERT(bp!=0);
280     return bp->coeff(s,n);
281 }
282
283 ex ex::collect(const symbol & s) const
284 {
285     GINAC_ASSERT(bp!=0);
286     return bp->collect(s);
287 }
288
289 ex ex::eval(int level) const
290 {
291     GINAC_ASSERT(bp!=0);
292     return bp->eval(level);
293 }
294
295 ex ex::evalf(int level) const
296 {
297     GINAC_ASSERT(bp!=0);
298     return bp->evalf(level);
299 }
300
301 /** Compute partial derivative of an expression.
302  *
303  *  @param s  symbol by which the expression is derived
304  *  @param nth  order of derivative (default 1)
305  *  @return partial derivative as a new expression */
306 ex ex::diff(const symbol & s, unsigned nth) const
307 {
308     GINAC_ASSERT(bp!=0);
309
310     if (!nth)
311         return *this;
312     else
313         return bp->diff(s, nth);
314 }
315
316 ex ex::subs(const lst & ls, const lst & lr) const
317 {
318     GINAC_ASSERT(bp!=0);
319     return bp->subs(ls,lr);
320 }
321
322 ex ex::subs(const ex & e) const
323 {
324     GINAC_ASSERT(bp!=0);
325     return bp->subs(e);
326 }
327
328 exvector ex::get_indices(void) const
329 {
330     GINAC_ASSERT(bp!=0);
331     return bp->get_indices();
332 }
333
334 ex ex::simplify_ncmul(const exvector & v) const
335 {
336     GINAC_ASSERT(bp!=0);
337     return bp->simplify_ncmul(v);
338 }
339
340 ex ex::operator[](const ex & index) const
341 {
342     debugmsg("ex operator[ex]",LOGLEVEL_OPERATOR);
343     GINAC_ASSERT(bp!=0);
344     return (*bp)[index];
345 }
346
347 ex ex::operator[](int i) const
348 {
349     debugmsg("ex operator[int]",LOGLEVEL_OPERATOR);
350     GINAC_ASSERT(bp!=0);
351     return (*bp)[i];
352 }
353
354 /** Return operand/member at position i. */
355 ex ex::op(int i) const
356 {
357     debugmsg("ex op()",LOGLEVEL_MEMBER_FUNCTION);
358     GINAC_ASSERT(bp!=0);
359     return bp->op(i);
360 }
361
362 /** Return modifyable operand/member at position i. */
363 ex & ex::let_op(int i)
364 {
365     debugmsg("ex let_op()",LOGLEVEL_MEMBER_FUNCTION);
366     makewriteable();
367     GINAC_ASSERT(bp!=0);
368     return bp->let_op(i);
369 }
370
371 /** Left hand side of relational expression. */
372 ex ex::lhs(void) const
373 {
374     debugmsg("ex lhs()",LOGLEVEL_MEMBER_FUNCTION);
375     GINAC_ASSERT(is_ex_of_type(*this,relational));
376     return (*static_cast<relational *>(bp)).lhs();
377 }
378
379 /** Right hand side of relational expression. */
380 ex ex::rhs(void) const
381 {
382     debugmsg("ex rhs()",LOGLEVEL_MEMBER_FUNCTION);
383     GINAC_ASSERT(is_ex_of_type(*this,relational));
384     return (*static_cast<relational *>(bp)).rhs();
385 }
386
387 #ifndef INLINE_EX_CONSTRUCTORS
388 int ex::compare(const ex & other) const
389 {
390     GINAC_ASSERT(bp!=0);
391     GINAC_ASSERT(other.bp!=0);
392     if (bp==other.bp) {
393         // special case: both expression point to same basic, trivially equal
394         return 0; 
395     }
396     return bp->compare(*other.bp);
397 }
398 #endif // ndef INLINE_EX_CONSTRUCTORS
399
400 #ifndef INLINE_EX_CONSTRUCTORS
401 bool ex::is_equal(const ex & other) const
402 {
403     GINAC_ASSERT(bp!=0);
404     GINAC_ASSERT(other.bp!=0);
405     if (bp==other.bp) {
406         // special case: both expression point to same basic, trivially equal
407         return true; 
408     }
409     return bp->is_equal(*other.bp);
410 }
411 #endif // ndef INLINE_EX_CONSTRUCTORS
412
413 unsigned ex::return_type(void) const
414 {
415     GINAC_ASSERT(bp!=0);
416     return bp->return_type();
417 }
418
419 unsigned ex::return_type_tinfo(void) const
420 {
421     GINAC_ASSERT(bp!=0);
422     return bp->return_type_tinfo();
423 }
424
425 unsigned ex::gethash(void) const
426 {
427     GINAC_ASSERT(bp!=0);
428     return bp->gethash();
429 }
430
431 ex ex::exadd(const ex & rh) const
432 {
433     return (new add(*this,rh))->setflag(status_flags::dynallocated);
434 }
435
436 ex ex::exmul(const ex & rh) const
437 {
438     return (new mul(*this,rh))->setflag(status_flags::dynallocated);
439 }
440
441 ex ex::exncmul(const ex & rh) const
442 {
443     return (new ncmul(*this,rh))->setflag(status_flags::dynallocated);
444 }
445
446 // private
447
448 void ex::makewriteable()
449 {
450     debugmsg("ex makewriteable",LOGLEVEL_MEMBER_FUNCTION);
451     GINAC_ASSERT(bp!=0);
452     GINAC_ASSERT(bp->flags & status_flags::dynallocated);
453     if (bp->refcount > 1) {
454         basic * bp2 = bp->duplicate();
455         ++bp2->refcount;
456         bp2->setflag(status_flags::dynallocated);
457         --bp->refcount;
458         bp = bp2;
459     }
460     GINAC_ASSERT(bp->refcount == 1);
461 }
462
463 void ex::construct_from_basic(const basic & other)
464 {
465     if ((other.flags & status_flags::evaluated)==0) {
466         // cf. copy constructor
467         const ex & tmpex = other.eval(1); // evaluate only one (top) level
468         bp = tmpex.bp;
469         GINAC_ASSERT(bp!=0);
470         GINAC_ASSERT(bp->flags & status_flags::dynallocated);
471         ++bp->refcount;
472         if ((other.flags & status_flags::dynallocated)&&(other.refcount==0)) {
473             delete &const_cast<basic &>(other);
474         }
475     } else {
476         if (other.flags & status_flags::dynallocated) {
477             bp = &const_cast<basic &>(other);
478         } else {
479             bp = other.duplicate();
480             bp->setflag(status_flags::dynallocated);
481         }
482         GINAC_ASSERT(bp!=0);
483         // bp->clearflag(status_flags::evaluated);
484         ++bp->refcount;
485     }
486     GINAC_ASSERT(bp!=0);
487     GINAC_ASSERT(bp->flags & status_flags::dynallocated);
488 }
489
490 void ex::construct_from_int(int i)
491 {
492     switch (i) {  // some tiny efficiency-hack
493     case -2:
494         bp = _ex_2().bp;
495         ++bp->refcount;
496         break;
497     case -1:
498         bp = _ex_1().bp;
499         ++bp->refcount;
500         break;
501     case 0:
502         bp = _ex0().bp;
503         ++bp->refcount;
504         break;
505     case 1:
506         bp = _ex1().bp;
507         ++bp->refcount;
508         break;
509     case 2:
510         bp = _ex2().bp;
511         ++bp->refcount;
512         break;
513     default:
514         bp = new numeric(i);
515         bp->setflag(status_flags::dynallocated);
516         ++bp->refcount;
517         GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
518         GINAC_ASSERT(bp->refcount=1);
519     }
520 }
521     
522 void ex::construct_from_uint(unsigned int i)
523 {
524     switch (i) {  // some tiny efficiency-hack
525     case -2:
526         bp = _ex_2().bp;
527         ++bp->refcount;
528         break;
529     case -1:
530         bp = _ex_1().bp;
531         ++bp->refcount;
532         break;
533     case 0:
534         bp = _ex0().bp;
535         ++bp->refcount;
536         break;
537     case 1:
538         bp = _ex1().bp;
539         ++bp->refcount;
540         break;
541     case 2:
542         bp = _ex2().bp;
543         ++bp->refcount;
544         break;
545     default:
546         bp = new numeric(i);
547         bp->setflag(status_flags::dynallocated);
548         ++bp->refcount;
549         GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
550         GINAC_ASSERT(bp->refcount=1);
551     }
552 }
553     
554 void ex::construct_from_long(long i)
555 {
556     switch (i) {  // some tiny efficiency-hack
557     case -2:
558         bp = _ex_2().bp;
559         ++bp->refcount;
560         break;
561     case -1:
562         bp = _ex_1().bp;
563         ++bp->refcount;
564         break;
565     case 0:
566         bp = _ex0().bp;
567         ++bp->refcount;
568         break;
569     case 1:
570         bp = _ex1().bp;
571         ++bp->refcount;
572         break;
573     case 2:
574         bp = _ex2().bp;
575         ++bp->refcount;
576         break;
577     default:
578         bp = new numeric(i);
579         bp->setflag(status_flags::dynallocated);
580         ++bp->refcount;
581         GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
582         GINAC_ASSERT(bp->refcount=1);
583     }
584 }
585     
586 void ex::construct_from_ulong(unsigned long i)
587 {
588     switch (i) {  // some tiny efficiency-hack
589     case -2:
590         bp = _ex_2().bp;
591         ++bp->refcount;
592         break;
593     case -1:
594         bp = _ex_1().bp;
595         ++bp->refcount;
596         break;
597     case 0:
598         bp = _ex0().bp;
599         ++bp->refcount;
600         break;
601     case 1:
602         bp = _ex1().bp;
603         ++bp->refcount;
604         break;
605     case 2:
606         bp = _ex2().bp;
607         ++bp->refcount;
608         break;
609     default:
610         bp = new numeric(i);
611         bp->setflag(status_flags::dynallocated);
612         ++bp->refcount;
613         GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
614         GINAC_ASSERT(bp->refcount=1);
615     }
616 }
617     
618 void ex::construct_from_double(double d)
619 {
620     bp = new numeric(d);
621     bp->setflag(status_flags::dynallocated);
622     ++bp->refcount;
623     GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
624     GINAC_ASSERT(bp->refcount=1);
625 }
626     
627 //////////
628 // static member variables
629 //////////
630
631 // none
632
633 //////////
634 // functions which are not member functions
635 //////////
636
637 // none
638
639 //////////
640 // global functions
641 //////////
642
643 // none
644
645
646 #ifndef NO_NAMESPACE_GINAC
647 } // namespace GiNaC
648 #endif // ndef NO_NAMESPACE_GINAC