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