ginac/ex.h

   1 /** @file ex.h
   2  *
   3  *  Interface to GiNaC's light-weight expression handles. */
   4
   5 /*
   6  *  GiNaC Copyright (C) 1999-2003 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 #ifndef __GINAC_EX_H__
  24 #define __GINAC_EX_H__
  25
  26 #include <iosfwd>
  27 #include <iterator>
  28 #include <functional>
  29
  30 #include "basic.h"
  31 #include "ptr.h"
  32
  33 namespace GiNaC {
  34
  35
  36 /** Helper class to initialize the library.  There must be one static object
  37  *  of this class in every object file that makes use of our flyweights in
  38  *  order to guarantee proper initialization.  Hence we put it into this
  39  *  file which is included by every relevant file anyways.  This is modeled
  40  *  after section 27.4.2.1.6 of the C++ standard, where cout and friends are
  41  *  set up.
  42  *
  43  *  @see utils.cpp */
  44 class library_init {
  45 public:
  46         library_init();
  47         ~library_init();
  48 private:
  49         static int count;
  50 };
  51 /** For construction of flyweights, etc. */
  52 static library_init library_initializer;
  53
  54
  55 class scalar_products;
  56
  57
  58 /** Lightweight wrapper for GiNaC's symbolic objects.  Basically all it does is
  59  *  to hold a pointer to the other objects, manage the reference counting and
  60  *  provide methods for manipulation of these objects.  (Some people call such
  61  *  a thing a proxy class.) */
  62 class ex
  63 {
  64         friend class archive_node;
  65         friend inline bool are_ex_trivially_equal(const ex &, const ex &);
  66         template<class T> friend inline const T &ex_to(const ex &);
  67         template<class T> friend inline bool is_a(const ex &);
  68         template<class T> friend inline bool is_exactly_a(const ex &);
  69
  70         // default constructor, copy constructor and assignment operator
  71 public:
  72         ex();
  73 #ifdef OBSCURE_CINT_HACK
  74         ex(const ex & other);
  75         ex & operator=(const ex & other);
  76 #endif
  77
  78         // other constructors
  79 public:
  80         ex(const basic & other);
  81         ex(int i);
  82         ex(unsigned int i);
  83         ex(long i);
  84         ex(unsigned long i);
  85         ex(double const d);
  86
  87         /** Construct ex from string and a list of symbols. The input grammar is
  88          *  similar to the GiNaC output format. All symbols and indices to be used
  89          *  in the expression must be specified in a lst in the second argument.
  90          *  Undefined symbols and other parser errors will throw an exception. */
  91         ex(const std::string &s, const ex &l);
  92
  93 public:
  94         // Iterators
  95         class const_iterator : public std::iterator<std::random_access_iterator_tag, ex, ptrdiff_t, const ex *, const ex &>
  96         {
  97                 friend class ex;
  98
  99         public:
 100                 const_iterator() {}
 101                 const_iterator(const basic *bp_, size_t i_) : bp(bp_), i(i_) {}
 102
 103                 bool operator==(const const_iterator &other) const
 104                 {
 105                         return bp == other.bp && i == other.i;
 106                 }
 107
 108                 bool operator!=(const const_iterator &other) const
 109                 {
 110                         return !(*this == other);
 111                 }
 112
 113                 bool operator<(const const_iterator &other) const
 114                 {
 115                         return i < other.i;
 116                 }
 117
 118                 bool operator>(const const_iterator &other) const
 119                 {
 120                         return other < *this;
 121                 }
 122
 123                 bool operator<=(const const_iterator &other) const
 124                 {
 125                         return !(other < *this);
 126                 }
 127
 128                 bool operator>=(const const_iterator &other) const
 129                 {
 130                         return !(*this < other);
 131                 }
 132
 133                 // This should return an ex&, but that would be a reference to a
 134                 // temporary value
 135                 ex operator*() const
 136                 {
 137                         return bp->op(i);
 138                 }
 139
 140 #if 0
 141                 // How do we make this work in the context of the "reference to
 142                 // temporary" problem? Return an auto_ptr?
 143                 pointer operator->() const
 144                 {
 145                         return &(operator*());
 146                 }
 147 #endif
 148
 149                 const_iterator &operator++()
 150                 {
 151                         ++i;
 152                         return *this;
 153                 }
 154
 155                 const_iterator operator++(int)
 156                 {
 157                         const_iterator tmp = *this;
 158                         ++i;
 159                         return tmp;
 160                 }
 161
 162                 const_iterator &operator+=(difference_type n)
 163                 {
 164                         i += n;
 165                         return *this;
 166                 }
 167
 168                 const_iterator operator+(difference_type n) const
 169                 {
 170                         return const_iterator(bp, i + n);
 171                 }
 172
 173                 inline friend const_iterator operator+(difference_type n, const const_iterator &it)
 174                 {
 175                         return const_iterator(it.bp, it.i + n);
 176                 }
 177
 178                 const_iterator &operator--()
 179                 {
 180                         --i;
 181                         return *this;
 182                 }
 183
 184                 const_iterator operator--(int)
 185                 {
 186                         const_iterator tmp = *this;
 187                         --i;
 188                         return tmp;
 189                 }
 190
 191                 const_iterator &operator-=(difference_type n)
 192                 {
 193                         i -= n;
 194                         return *this;
 195                 }
 196
 197                 const_iterator operator-(difference_type n) const
 198                 {
 199                         return const_iterator(bp, i - n);
 200                 }
 201
 202                 inline friend difference_type operator-(const const_iterator &lhs, const const_iterator &rhs)
 203                 {
 204                         return lhs.i - rhs.i;
 205                 }
 206
 207                 reference operator[](difference_type n) const
 208                 {
 209                 }
 210
 211         protected:
 212                 const basic *bp;
 213                 size_t i;
 214         };
 215
 216         const_iterator begin() const { return const_iterator(get_pointer(bp), 0); }
 217         const_iterator end() const { return const_iterator(get_pointer(bp), bp->nops()); }
 218
 219 #if 0
 220         // This doesn't work because of the "reference to temporary" problem
 221         // in operator*()
 222         typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 223         const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
 224         const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
 225 #endif
 226
 227         // non-virtual functions in this class
 228 public:
 229         /** Efficiently swap the contents of two expressions. */
 230         void swap(ex & other)
 231         {
 232                 GINAC_ASSERT(bp->flags & status_flags::dynallocated);
 233                 GINAC_ASSERT(other.bp->flags & status_flags::dynallocated);
 234                 bp.swap(other.bp);
 235         }
 236
 237         // evaluation
 238         ex eval(int level = 0) const { return bp->eval(level); }
 239         ex evalf(int level = 0) const { return bp->evalf(level); }
 240         ex evalm() const { return bp->evalm(); }
 241         ex eval_ncmul(const exvector & v) const { return bp->eval_ncmul(v); }
 242
 243         // printing
 244         void print(const print_context & c, unsigned level = 0) const;
 245         void dbgprint() const;
 246         void dbgprinttree() const;
 247
 248         // info
 249         bool info(unsigned inf) const { return bp->info(inf); }
 250
 251         // operand access
 252         size_t nops() const { return bp->nops(); }
 253         ex op(size_t i) const { return bp->op(i); }
 254         ex operator[](const ex & index) const { return (*bp)[index]; }
 255         ex operator[](size_t i) const { return (*bp)[i]; }
 256         ex & let_op(size_t i);
 257         ex & operator[](const ex & index);
 258         ex & operator[](size_t i);
 259         ex lhs() const;
 260         ex rhs() const;
 261
 262         // pattern matching
 263         bool has(const ex & pattern) const { return bp->has(pattern); }
 264         bool find(const ex & pattern, lst & found) const;
 265         bool match(const ex & pattern) const;
 266         bool match(const ex & pattern, lst & repl_lst) const { return bp->match(pattern, repl_lst); }
 267
 268         // substitutions
 269         ex subs(const exmap & m, unsigned options = 0) const;
 270         ex subs(const lst & ls, const lst & lr, unsigned options = 0) const;
 271         ex subs(const ex & e, unsigned options = 0) const;
 272
 273         // function mapping
 274         ex map(map_function & f) const { return bp->map(f); }
 275         ex map(ex (*f)(const ex & e)) const;
 276
 277         // visitors and tree traversal
 278         void accept(visitor & v) const { bp->accept(v); }
 279         void traverse_preorder(visitor & v) const;
 280         void traverse_postorder(visitor & v) const;
 281         void traverse(visitor & v) const { traverse_preorder(v); }
 282
 283         // degree/coeff
 284         int degree(const ex & s) const { return bp->degree(s); }
 285         int ldegree(const ex & s) const { return bp->ldegree(s); }
 286         ex coeff(const ex & s, int n = 1) const { return bp->coeff(s, n); }
 287         ex lcoeff(const ex & s) const { return coeff(s, degree(s)); }
 288         ex tcoeff(const ex & s) const { return coeff(s, ldegree(s)); }
 289
 290         // expand/collect
 291         ex expand(unsigned options=0) const;
 292         ex collect(const ex & s, bool distributed = false) const { return bp->collect(s, distributed); }
 293
 294         // differentiation and series expansion
 295         ex diff(const symbol & s, unsigned nth = 1) const;
 296         ex series(const ex & r, int order, unsigned options = 0) const;
 297
 298         // rational functions
 299         ex normal(int level = 0) const;
 300         ex to_rational(lst &repl_lst) const;
 301         ex to_polynomial(lst &repl_lst) const;
 302         ex numer() const;
 303         ex denom() const;
 304         ex numer_denom() const;
 305
 306         // polynomial algorithms
 307         ex unit(const symbol &x) const;
 308         ex content(const symbol &x) const;
 309         numeric integer_content() const;
 310         ex primpart(const symbol &x) const;
 311         ex primpart(const symbol &x, const ex &cont) const;
 312         ex smod(const numeric &xi) const { return bp->smod(xi); }
 313         numeric max_coefficient() const;
 314
 315         // indexed objects
 316         exvector get_free_indices() const { return bp->get_free_indices(); }
 317         ex simplify_indexed() const;
 318         ex simplify_indexed(const scalar_products & sp) const;
 319
 320         // comparison
 321         int compare(const ex & other) const;
 322         bool is_equal(const ex & other) const;
 323         bool is_zero() const { extern const ex _ex0; return is_equal(_ex0); }
 324
 325         // symmetry
 326         ex symmetrize() const;
 327         ex symmetrize(const lst & l) const;
 328         ex antisymmetrize() const;
 329         ex antisymmetrize(const lst & l) const;
 330         ex symmetrize_cyclic() const;
 331         ex symmetrize_cyclic(const lst & l) const;
 332
 333         // noncommutativity
 334         unsigned return_type() const { return bp->return_type(); }
 335         unsigned return_type_tinfo() const { return bp->return_type_tinfo(); }
 336
 337         unsigned gethash() const { return bp->gethash(); }
 338
 339 private:
 340         static ptr<basic> construct_from_basic(const basic & other);
 341         static basic & construct_from_int(int i);
 342         static basic & construct_from_uint(unsigned int i);
 343         static basic & construct_from_long(long i);
 344         static basic & construct_from_ulong(unsigned long i);
 345         static basic & construct_from_double(double d);
 346         static ptr<basic> construct_from_string_and_lst(const std::string &s, const ex &l);
 347         void makewriteable();
 348
 349 #ifdef OBSCURE_CINT_HACK
 350 public:
 351         static bool last_created_or_assigned_bp_can_be_converted_to_ex()
 352         {
 353                 if (last_created_or_assigned_bp==0) return false;
 354                 if ((last_created_or_assigned_bp->flags &
 355                          status_flags::dynallocated)==0) return false;
 356                 if ((last_created_or_assigned_bp->flags &
 357                          status_flags::evaluated)==0) return false;
 358                 return true;
 359         }
 360 protected:
 361         void update_last_created_or_assigned_bp()
 362         {
 363                 last_created_or_assigned_bp = bp;
 364                 last_created_or_assigned_exp = (long)(void *)(this);
 365         }
 366 #endif // def OBSCURE_CINT_HACK
 367
 368 // member variables
 369
 370 private:
 371         ptr<basic> bp;      ///< pointer to basic object managed by this
 372
 373 #ifdef OBSCURE_CINT_HACK
 374 public:
 375         static ptr<basic> last_created_or_assigned_bp;
 376         static basic * dummy_bp;
 377         static long last_created_or_assigned_exp;
 378 #endif // def OBSCURE_CINT_HACK
 379 };
 380
 381
 382 // performance-critical inlined method implementations
 383
 384 // This needs to be a basic* because we don't know that numeric is derived
 385 // from basic and we need a basic& for the ex default constructor
 386 extern const basic *_num0_bp;
 387
 388 inline
 389 ex::ex() : bp(*const_cast<basic *>(_num0_bp))
 390 {
 391         GINAC_ASSERT(bp->flags & status_flags::dynallocated);
 392 #ifdef OBSCURE_CINT_HACK
 393         update_last_created_or_assigned_bp();
 394 #endif // def OBSCURE_CINT_HACK
 395 }
 396
 397 #ifdef OBSCURE_CINT_HACK
 398 inline
 399 ex::ex(const ex & other) : bp(other.bp)
 400 {
 401         GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
 402         update_last_created_or_assigned_bp();
 403 }
 404
 405 inline
 406 ex & ex::operator=(const ex & other)
 407 {
 408         GINAC_ASSERT(bp->flags & status_flags::dynallocated);
 409         GINAC_ASSERT(other.bp->flags & status_flags::dynallocated);
 410         bp = other.bp;
 411         update_last_created_or_assigned_bp();
 412         return *this;
 413 }
 414 #endif // def OBSCURE_CINT_HACK
 415
 416 inline
 417 ex::ex(const basic & other) : bp(construct_from_basic(other))
 418 {
 419         GINAC_ASSERT(bp->flags & status_flags::dynallocated);
 420 #ifdef OBSCURE_CINT_HACK
 421         update_last_created_or_assigned_bp();
 422 #endif // def OBSCURE_CINT_HACK
 423 }
 424
 425 inline
 426 ex::ex(int i) : bp(construct_from_int(i))
 427 {
 428         GINAC_ASSERT(bp->flags & status_flags::dynallocated);
 429 #ifdef OBSCURE_CINT_HACK
 430         update_last_created_or_assigned_bp();
 431 #endif // def OBSCURE_CINT_HACK
 432 }
 433
 434 inline
 435 ex::ex(unsigned int i) : bp(construct_from_uint(i))
 436 {
 437         GINAC_ASSERT(bp->flags & status_flags::dynallocated);
 438 #ifdef OBSCURE_CINT_HACK
 439         update_last_created_or_assigned_bp();
 440 #endif // def OBSCURE_CINT_HACK
 441 }
 442
 443 inline
 444 ex::ex(long i) : bp(construct_from_long(i))
 445 {
 446         GINAC_ASSERT(bp->flags & status_flags::dynallocated);
 447 #ifdef OBSCURE_CINT_HACK
 448         update_last_created_or_assigned_bp();
 449 #endif // def OBSCURE_CINT_HACK
 450 }
 451
 452 inline
 453 ex::ex(unsigned long i) : bp(construct_from_ulong(i))
 454 {
 455         GINAC_ASSERT(bp->flags & status_flags::dynallocated);
 456 #ifdef OBSCURE_CINT_HACK
 457         update_last_created_or_assigned_bp();
 458 #endif // def OBSCURE_CINT_HACK
 459 }
 460
 461 inline
 462 ex::ex(double const d) : bp(construct_from_double(d))
 463 {
 464         GINAC_ASSERT(bp->flags & status_flags::dynallocated);
 465 #ifdef OBSCURE_CINT_HACK
 466         update_last_created_or_assigned_bp();
 467 #endif // def OBSCURE_CINT_HACK
 468 }
 469
 470 inline
 471 ex::ex(const std::string &s, const ex &l) : bp(construct_from_string_and_lst(s, l))
 472 {
 473         GINAC_ASSERT(bp->flags & status_flags::dynallocated);
 474 #ifdef OBSCURE_CINT_HACK
 475         update_last_created_or_assigned_bp();
 476 #endif // def OBSCURE_CINT_HACK
 477 }
 478
 479 inline
 480 int ex::compare(const ex & other) const
 481 {
 482         if (bp == other.bp)  // trivial case: both expressions point to same basic
 483                 return 0;
 484         return bp->compare(*other.bp);
 485 }
 486
 487 inline
 488 bool ex::is_equal(const ex & other) const
 489 {
 490         if (bp == other.bp)  // trivial case: both expressions point to same basic
 491                 return true;
 492         return bp->is_equal(*other.bp);
 493 }
 494
 495
 496 // utility functions
 497
 498 /** Compare two objects of class quickly without doing a deep tree traversal.
 499  *  @return "true" if they are equal
 500  *          "false" if equality cannot be established quickly (e1 and e2 may
 501  *          still be equal, in this case. */
 502 inline bool are_ex_trivially_equal(const ex &e1, const ex &e2)
 503 {
 504         return e1.bp == e2.bp;
 505 }
 506
 507 // wrapper functions around member functions
 508 inline size_t nops(const ex & thisex)
 509 { return thisex.nops(); }
 510
 511 inline ex expand(const ex & thisex, unsigned options = 0)
 512 { return thisex.expand(options); }
 513
 514 inline bool has(const ex & thisex, const ex & pattern)
 515 { return thisex.has(pattern); }
 516
 517 inline bool find(const ex & thisex, const ex & pattern, lst & found)
 518 { return thisex.find(pattern, found); }
 519
 520 inline int degree(const ex & thisex, const ex & s)
 521 { return thisex.degree(s); }
 522
 523 inline int ldegree(const ex & thisex, const ex & s)
 524 { return thisex.ldegree(s); }
 525
 526 inline ex coeff(const ex & thisex, const ex & s, int n=1)
 527 { return thisex.coeff(s, n); }
 528
 529 inline ex numer(const ex & thisex)
 530 { return thisex.numer(); }
 531
 532 inline ex denom(const ex & thisex)
 533 { return thisex.denom(); }
 534
 535 inline ex numer_denom(const ex & thisex)
 536 { return thisex.numer_denom(); }
 537
 538 inline ex normal(const ex & thisex, int level=0)
 539 { return thisex.normal(level); }
 540
 541 inline ex to_rational(const ex & thisex, lst & repl_lst)
 542 { return thisex.to_rational(repl_lst); }
 543
 544 inline ex to_polynomial(const ex & thisex, lst & repl_lst)
 545 { return thisex.to_polynomial(repl_lst); }
 546
 547 inline ex collect(const ex & thisex, const ex & s, bool distributed = false)
 548 { return thisex.collect(s, distributed); }
 549
 550 inline ex eval(const ex & thisex, int level = 0)
 551 { return thisex.eval(level); }
 552
 553 inline ex evalf(const ex & thisex, int level = 0)
 554 { return thisex.evalf(level); }
 555
 556 inline ex evalm(const ex & thisex)
 557 { return thisex.evalm(); }
 558
 559 inline ex diff(const ex & thisex, const symbol & s, unsigned nth = 1)
 560 { return thisex.diff(s, nth); }
 561
 562 inline ex series(const ex & thisex, const ex & r, int order, unsigned options = 0)
 563 { return thisex.series(r, order, options); }
 564
 565 inline bool match(const ex & thisex, const ex & pattern, lst & repl_lst)
 566 { return thisex.match(pattern, repl_lst); }
 567
 568 inline ex simplify_indexed(const ex & thisex)
 569 { return thisex.simplify_indexed(); }
 570
 571 inline ex simplify_indexed(const ex & thisex, const scalar_products & sp)
 572 { return thisex.simplify_indexed(sp); }
 573
 574 inline ex symmetrize(const ex & thisex)
 575 { return thisex.symmetrize(); }
 576
 577 inline ex symmetrize(const ex & thisex, const lst & l)
 578 { return thisex.symmetrize(l); }
 579
 580 inline ex antisymmetrize(const ex & thisex)
 581 { return thisex.antisymmetrize(); }
 582
 583 inline ex antisymmetrize(const ex & thisex, const lst & l)
 584 { return thisex.antisymmetrize(l); }
 585
 586 inline ex symmetrize_cyclic(const ex & thisex)
 587 { return thisex.symmetrize_cyclic(); }
 588
 589 inline ex symmetrize_cyclic(const ex & thisex, const lst & l)
 590 { return thisex.symmetrize_cyclic(l); }
 591
 592 inline ex op(const ex & thisex, size_t i)
 593 { return thisex.op(i); }
 594
 595 inline ex lhs(const ex & thisex)
 596 { return thisex.lhs(); }
 597
 598 inline ex rhs(const ex & thisex)
 599 { return thisex.rhs(); }
 600
 601 inline bool is_zero(const ex & thisex)
 602 { return thisex.is_zero(); }
 603
 604 inline void swap(ex & e1, ex & e2)
 605 { e1.swap(e2); }
 606
 607 /* Function objects for STL sort() etc. */
 608 struct ex_is_less : public std::binary_function<ex, ex, bool> {
 609         bool operator() (const ex &lh, const ex &rh) const { return lh.compare(rh) < 0; }
 610 };
 611
 612 struct ex_is_equal : public std::binary_function<ex, ex, bool> {
 613         bool operator() (const ex &lh, const ex &rh) const { return lh.is_equal(rh); }
 614 };
 615
 616 struct op0_is_equal : public std::binary_function<ex, ex, bool> {
 617         bool operator() (const ex &lh, const ex &rh) const { return lh.op(0).is_equal(rh.op(0)); }
 618 };
 619
 620 struct ex_swap : public std::binary_function<ex, ex, void> {
 621         void operator() (ex &lh, ex &rh) const { lh.swap(rh); }
 622 };
 623
 624 inline ex ex::subs(const exmap & m, unsigned options) const
 625 {
 626         return bp->subs(m, options);
 627 }
 628
 629 inline ex subs(const ex & thisex, const exmap & m, unsigned options = 0)
 630 { return thisex.subs(m, options); }
 631
 632 inline ex subs(const ex & thisex, const lst & ls, const lst & lr, unsigned options = 0)
 633 { return thisex.subs(ls, lr, options); }
 634
 635 inline ex subs(const ex & thisex, const ex & e, unsigned options = 0)
 636 { return thisex.subs(e, options); }
 637
 638
 639 /* Convert function pointer to function object suitable for map(). */
 640 class pointer_to_map_function : public map_function {
 641 protected:
 642         ex (*ptr)(const ex &);
 643 public:
 644         explicit pointer_to_map_function(ex x(const ex &)) : ptr(x) {}
 645         ex operator()(const ex & e) { return ptr(e); }
 646 };
 647
 648 template<class T1>
 649 class pointer_to_map_function_1arg : public map_function {
 650 protected:
 651         ex (*ptr)(const ex &, T1);
 652         T1 arg1;
 653 public:
 654         explicit pointer_to_map_function_1arg(ex x(const ex &, T1), T1 a1) : ptr(x), arg1(a1) {}
 655         ex operator()(const ex & e) { return ptr(e, arg1); }
 656 };
 657
 658 template<class T1, class T2>
 659 class pointer_to_map_function_2args : public map_function {
 660 protected:
 661         ex (*ptr)(const ex &, T1, T2);
 662         T1 arg1;
 663         T2 arg2;
 664 public:
 665         explicit pointer_to_map_function_2args(ex x(const ex &, T1, T2), T1 a1, T2 a2) : ptr(x), arg1(a1), arg2(a2) {}
 666         ex operator()(const ex & e) { return ptr(e, arg1, arg2); }
 667 };
 668
 669 template<class T1, class T2, class T3>
 670 class pointer_to_map_function_3args : public map_function {
 671 protected:
 672         ex (*ptr)(const ex &, T1, T2, T3);
 673         T1 arg1;
 674         T2 arg2;
 675         T3 arg3;
 676 public:
 677         explicit pointer_to_map_function_3args(ex x(const ex &, T1, T2, T3), T1 a1, T2 a2, T3 a3) : ptr(x), arg1(a1), arg2(a2), arg3(a3) {}
 678         ex operator()(const ex & e) { return ptr(e, arg1, arg2, arg3); }
 679 };
 680
 681 inline ex ex::map(ex f(const ex &)) const
 682 {
 683         pointer_to_map_function fcn(f);
 684         return bp->map(fcn);
 685 }
 686
 687 // convenience type checker template functions
 688
 689 /** Check if ex is a handle to a T, including base classes. */
 690 template <class T>
 691 inline bool is_a(const ex &obj)
 692 {
 693         return is_a<T>(*obj.bp);
 694 }
 695
 696 /** Check if ex is a handle to a T, not including base classes. */
 697 template <class T>
 698 inline bool is_exactly_a(const ex &obj)
 699 {
 700         return is_exactly_a<T>(*obj.bp);
 701 }
 702
 703 /** Return a reference to the basic-derived class T object embedded in an
 704  *  expression.  This is fast but unsafe: the result is undefined if the
 705  *  expression does not contain a T object at its top level.  Hence, you
 706  *  should generally check the type of e first.
 707  *
 708  *  @param e expression
 709  *  @return reference to object of class T
 710  *  @see is_exactly_a<class T>() */
 711 template <class T>
 712 inline const T &ex_to(const ex &e)
 713 {
 714         GINAC_ASSERT(is_a<T>(e));
 715         return static_cast<const T &>(*e.bp);
 716 }
 717
 718 } // namespace GiNaC
 719
 720
 721 // Specializations of Standard Library algorithms
 722 namespace std {
 723
 724 /** Specialization of std::swap() for ex objects. */
 725 template <>
 726 inline void swap(GiNaC::ex &a, GiNaC::ex &b)
 727 {
 728         a.swap(b);
 729 }
 730
 731 /** Specialization of std::iter_swap() for vector<ex> iterators. */
 732 template <>
 733 inline void iter_swap(vector<GiNaC::ex>::iterator i1, vector<GiNaC::ex>::iterator i2)
 734 {
 735         i1->swap(*i2);
 736 }
 737
 738 /** Specialization of std::iter_swap() for list<ex> iterators. */
 739 template <>
 740 inline void iter_swap(list<GiNaC::ex>::iterator i1, list<GiNaC::ex>::iterator i2)
 741 {
 742         i1->swap(*i2);
 743 }
 744
 745 } // namespace std
 746
 747 #endif // ndef __GINAC_EX_H__