ginac/ex.cpp

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