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