ginac/container.pl

   1 #!/usr/bin/perl -w
   2
   3 if (($#ARGV!=0) and ($#ARGV!=1)) {
   4     die 'usage: container.pl type [maxargs] (type=lst or exprseq)';
   5 }
   6
   7 if ($ARGV[0] eq 'lst') {
   8     $type='lst';
   9 } elsif ($ARGV[0] eq 'exprseq') {
  10     $type='exprseq';
  11 } else {
  12     die 'only lst and exprseq supported';
  13 }
  14
  15 if ($#ARGV==1) {
  16     $maxargs=$ARGV[1];
  17 } else {
  18     $maxargs=15; # must be greater or equal than the value used in function.pl
  19 }
  20
  21 if ($type eq 'exprseq') {
  22
  23     # settings for exprseq
  24     $CONTAINER="exprseq";
  25     $STLHEADER="vector";
  26     $reserve=1;
  27     $prepend=0;
  28     $let_op=0;
  29     $open_bracket='(';
  30     $close_bracket=')';
  31
  32 } elsif ($type eq 'lst') {
  33
  34     # settings for lst
  35     $CONTAINER="lst";
  36     $STLHEADER="list";
  37     $reserve=0;
  38     $prepend=1;
  39     $let_op=1;
  40     $open_bracket='[';
  41     $close_bracket=']';
  42
  43 } else {
  44     die "invalid type $type";
  45 }
  46
  47 $CONTAINER_UC=uc(${CONTAINER});
  48 $STLT="ex".$STLHEADER;
  49
  50 if ($reserve) {
  51     $RESERVE_IMPLEMENTATION="#define RESERVE(s,size) (s).reserve(size)";
  52 } else {
  53     $RESERVE_IMPLEMENTATION="#define RESERVE(s,size) // no reserve needed for ${STLHEADER}";
  54 }
  55
  56 if ($prepend) {
  57     $PREPEND_INTERFACE=<<END_OF_PREPEND_INTERFACE;
  58     virtual ${CONTAINER} & prepend(const ex & b);
  59 END_OF_PREPEND_INTERFACE
  60
  61     $PREPEND_IMPLEMENTATION=<<END_OF_PREPEND_IMPLEMENTATION;
  62 ${CONTAINER} & ${CONTAINER}::prepend(const ex & b)
  63 {
  64     ensure_if_modifiable();
  65     seq.push_front(b);
  66     return *this;
  67 }
  68 END_OF_PREPEND_IMPLEMENTATION
  69 } else {
  70     $PREPEND_INTERFACE="    // no prepend possible for ${CONTAINER}";
  71     $PREPEND_IMPLEMENTATION="";
  72 }
  73
  74 if ($let_op) {
  75     $LET_OP_IMPLEMENTATION=<<END_OF_LET_OP_IMPLEMENTATION
  76 ex & ${CONTAINER}::let_op(int i)
  77 {
  78     GINAC_ASSERT(i>=0);
  79     GINAC_ASSERT(i<nops());
  80
  81     ${STLT}::iterator it=seq.begin();
  82     for (int j=0; j<i; j++) {
  83         ++it;
  84     }
  85     return *it;
  86 }
  87 END_OF_LET_OP_IMPLEMENTATION
  88 } else {
  89     $LET_OP_IMPLEMENTATION="// ${CONTAINER}::let_op() will be implemented by user elsewhere";
  90 }
  91
  92 sub generate_seq {
  93     my ($seq_template,$n,$separator)=@_;
  94     my ($res,$N);
  95
  96     $res='';
  97     for ($N=1; $N<=$n; $N++) {
  98         $res .= eval('"' . $seq_template . '"');
  99         if ($N!=$n) {
 100             $res .= $separator;
 101         }
 102     }
 103     return $res;
 104 }
 105
 106 sub generate_from_to {
 107     my ($template,$seq_template1,$seq_separator1,$seq_template2,
 108         $seq_separator2,$from,$to)=@_;
 109     my ($res,$N,$SEQ);
 110
 111     $res='';
 112     for ($N=$from; $N<=$to; $N++) {
 113         $SEQ1=generate_seq($seq_template1,$N,$seq_separator1);
 114         $SEQ2=generate_seq($seq_template2,$N,$seq_separator2);
 115         $res .= eval('"' . $template . '"');
 116         $SEQ1=''; # to avoid main::SEQ1 used only once warning
 117         $SEQ2=''; # same as above
 118     }
 119     return $res;
 120 }
 121
 122 sub generate {
 123     my ($template,$seq_template1,$seq_separator1,$seq_template2,
 124         $seq_separator2)=@_;
 125     return generate_from_to($template,$seq_template1,$seq_separator1,
 126                             $seq_template2,$seq_separator2,1,$maxargs);
 127 }
 128
 129 $constructors_interface=generate(
 130 '    explicit ${CONTAINER}(${SEQ1});'."\n",
 131 'const ex & param${N}',', ','','');
 132
 133 $constructors_implementation=generate(
 134     <<'END_OF_CONSTRUCTORS_IMPLEMENTATION','const ex & param${N}',', ','    seq.push_back(param${N});',"\n");
 135 ${CONTAINER}::${CONTAINER}(${SEQ1}) : basic(TINFO_${CONTAINER})
 136 {
 137     debugmsg(\"${CONTAINER} constructor from ${N}*ex\",LOGLEVEL_CONSTRUCT);
 138     RESERVE(seq,${N});
 139 ${SEQ2}
 140 }
 141 END_OF_CONSTRUCTORS_IMPLEMENTATION
 142
 143 $interface=<<END_OF_INTERFACE;
 144 /** \@file ${CONTAINER}.h
 145  *
 146  *  Definition of GiNaC's ${CONTAINER}. */
 147
 148 /*
 149  *  This file was generated automatically by container.pl.
 150  *  Please do not modify it directly, edit the perl script instead!
 151  *  container.pl options: \$CONTAINER=${CONTAINER}
 152  *                        \$STLHEADER=${STLHEADER}
 153  *                        \$reserve=${reserve}
 154  *                        \$prepend=${prepend}
 155  *                        \$let_op=${let_op}
 156  *                        \$open_bracket=${open_bracket}
 157  *                        \$close_bracket=${close_bracket}
 158  *                        \$maxargs=${maxargs}
 159  *
 160  *  GiNaC Copyright (C) 1999-2000 Johannes Gutenberg University Mainz, Germany
 161  *
 162  *  This program is free software; you can redistribute it and/or modify
 163  *  it under the terms of the GNU General Public License as published by
 164  *  the Free Software Foundation; either version 2 of the License, or
 165  *  (at your option) any later version.
 166  *
 167  *  This program is distributed in the hope that it will be useful,
 168  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 169  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 170  *  GNU General Public License for more details.
 171  *
 172  *  You should have received a copy of the GNU General Public License
 173  *  along with this program; if not, write to the Free Software
 174  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 175  */
 176
 177 #ifndef __GINAC_${CONTAINER_UC}_H__
 178 #define __GINAC_${CONTAINER_UC}_H__
 179
 180 #include <${STLHEADER}>
 181
 182 // CINT needs <algorithm> to work properly with <vector> and <list>
 183 #include <algorithm>
 184
 185 #include "basic.h"
 186 #include "ex.h"
 187
 188 #ifndef NO_NAMESPACE_GINAC
 189 namespace GiNaC {
 190 #endif // ndef NO_NAMESPACE_GINAC
 191
 192 // typedef ${STLHEADER}<ex> ${STLT};
 193 typedef ${STLHEADER}<ex,malloc_alloc> ${STLT}; // CINT does not like ${STLHEADER}<...,default_alloc>
 194
 195 class ${CONTAINER} : public basic
 196 {
 197     GINAC_DECLARE_REGISTERED_CLASS(${CONTAINER}, basic)
 198
 199 public:
 200     ${CONTAINER}();
 201     ~${CONTAINER}();
 202     ${CONTAINER}(${CONTAINER} const & other);
 203     ${CONTAINER} const & operator=(${CONTAINER} const & other);
 204 protected:
 205     void copy(${CONTAINER} const & other);
 206     void destroy(bool call_parent);
 207
 208 public:
 209     ${CONTAINER}(${STLT} const & s, bool discardable=0);
 210     ${CONTAINER}(${STLT} * vp); // vp will be deleted
 211 ${constructors_interface}
 212
 213 public:
 214     basic * duplicate() const;
 215     void printraw(ostream & os) const;
 216     void print(ostream & os, unsigned upper_precedence=0) const;
 217     void printtree(ostream & os, unsigned indent) const;
 218     bool info(unsigned inf) const;
 219     unsigned nops() const;
 220     ex & let_op(int i);
 221     ex expand(unsigned options=0) const;
 222     bool has(const ex & other) const;
 223     ex eval(int level=0) const;
 224     ex evalf(int level=0) const;
 225     ex normal(lst &sym_lst, lst &repl_lst, int level=0) const;
 226     ex derivative(const symbol & s) const;
 227     ex subs(const lst & ls, const lst & lr) const;
 228 protected:
 229     int compare_same_type(const basic & other) const;
 230     bool is_equal_same_type(const basic & other) const;
 231     unsigned return_type(void) const;
 232
 233     // new virtual functions which can be overridden by derived classes
 234 public:
 235     virtual ${CONTAINER} & append(const ex & b);
 236 ${PREPEND_INTERFACE}
 237 protected:
 238     virtual void printseq(ostream & os, char openbracket, char delim,
 239                           char closebracket, unsigned this_precedence,
 240                           unsigned upper_precedence=0) const;
 241     virtual ex this${CONTAINER}(${STLT} const & v) const;
 242     virtual ex this${CONTAINER}(${STLT} * vp) const;
 243
 244 protected:
 245     bool is_canonical() const;
 246     ${STLT} evalchildren(int level) const;
 247     ${STLT} evalfchildren(int level) const;
 248     ${STLT} normalchildren(int level) const;
 249     ${STLT} diffchildren(const symbol & s) const;
 250     ${STLT} * subschildren(const lst & ls, const lst & lr) const;
 251
 252 protected:
 253     ${STLT} seq;
 254     static unsigned precedence;
 255 };
 256
 257 // global constants
 258
 259 extern const ${CONTAINER} some_${CONTAINER};
 260 extern const type_info & typeid_${CONTAINER};
 261
 262 // utility functions
 263 inline const ${CONTAINER} &ex_to_${CONTAINER}(const ex &e)
 264 {
 265     return static_cast<const ${CONTAINER} &>(*e.bp);
 266 }
 267
 268 inline ${CONTAINER} &ex_to_nonconst_${CONTAINER}(const ex &e)
 269 {
 270     return static_cast<${CONTAINER} &>(*e.bp);
 271 }
 272
 273 #ifndef NO_NAMESPACE_GINAC
 274 } // namespace GiNaC
 275 #endif // ndef NO_NAMESPACE_GINAC
 276
 277 #endif // ndef __GINAC_${CONTAINER_UC}_H__
 278
 279 END_OF_INTERFACE
 280
 281 $implementation=<<END_OF_IMPLEMENTATION;
 282 /** \@file ${CONTAINER}.cpp
 283  *
 284  *  Implementation of GiNaC's ${CONTAINER}. */
 285
 286 /*
 287  *  This file was generated automatically by container.pl.
 288  *  Please do not modify it directly, edit the perl script instead!
 289  *  container.pl options: \$CONTAINER=${CONTAINER}
 290  *                        \$STLHEADER=${STLHEADER}
 291  *                        \$reserve=${reserve}
 292  *                        \$prepend=${prepend}
 293  *                        \$let_op=${let_op}
 294  *                        \$open_bracket=${open_bracket}
 295  *                        \$close_bracket=${close_bracket}
 296  *                        \$maxargs=${maxargs}
 297  *
 298  *  GiNaC Copyright (C) 1999-2000 Johannes Gutenberg University Mainz, Germany
 299  *
 300  *  This program is free software; you can redistribute it and/or modify
 301  *  it under the terms of the GNU General Public License as published by
 302  *  the Free Software Foundation; either version 2 of the License, or
 303  *  (at your option) any later version.
 304  *
 305  *  This program is distributed in the hope that it will be useful,
 306  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 307  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 308  *  GNU General Public License for more details.
 309  *
 310  *  You should have received a copy of the GNU General Public License
 311  *  along with this program; if not, write to the Free Software
 312  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 313  */
 314
 315 #include <iostream>
 316 #include <stdexcept>
 317
 318 #include "${CONTAINER}.h"
 319 #include "ex.h"
 320 #include "archive.h"
 321 #include "debugmsg.h"
 322
 323 #ifndef NO_NAMESPACE_GINAC
 324 namespace GiNaC {
 325 #endif // ndef NO_NAMESPACE_GINAC
 326
 327 GINAC_IMPLEMENT_REGISTERED_CLASS(${CONTAINER}, basic)
 328
 329 ${RESERVE_IMPLEMENTATION}
 330
 331 //////////
 332 // default constructor, destructor, copy constructor assignment operator and helpers
 333 //////////
 334
 335 // public
 336
 337 ${CONTAINER}::${CONTAINER}() : basic(TINFO_${CONTAINER})
 338 {
 339     debugmsg("${CONTAINER} default constructor",LOGLEVEL_CONSTRUCT);
 340 }
 341
 342 ${CONTAINER}::~${CONTAINER}()
 343 {
 344     debugmsg("${CONTAINER} destructor",LOGLEVEL_DESTRUCT);
 345     destroy(0);
 346 }
 347
 348 ${CONTAINER}::${CONTAINER}(${CONTAINER} const & other)
 349 {
 350     debugmsg("${CONTAINER} copy constructor",LOGLEVEL_CONSTRUCT);
 351     copy(other);
 352 }
 353
 354 ${CONTAINER} const & ${CONTAINER}::operator=(${CONTAINER} const & other)
 355 {
 356     debugmsg("${CONTAINER} operator=",LOGLEVEL_ASSIGNMENT);
 357     if (this != &other) {
 358         destroy(1);
 359         copy(other);
 360     }
 361     return *this;
 362 }
 363
 364 // protected
 365
 366 void ${CONTAINER}::copy(${CONTAINER} const & other)
 367 {
 368     inherited::copy(other);
 369     seq=other.seq;
 370 }
 371
 372 void ${CONTAINER}::destroy(bool call_parent)
 373 {
 374     seq.clear();
 375     if (call_parent) inherited::destroy(call_parent);
 376 }
 377
 378 //////////
 379 // other constructors
 380 //////////
 381
 382 // public
 383
 384 ${CONTAINER}::${CONTAINER}(${STLT} const & s, bool discardable) :  basic(TINFO_${CONTAINER})
 385 {
 386     debugmsg("${CONTAINER} constructor from ${STLT}",
 387              LOGLEVEL_CONSTRUCT);
 388     if (discardable) {
 389         seq.swap(const_cast<${STLT} &>(s));
 390     } else {
 391         seq=s;
 392     }
 393 }
 394
 395 ${CONTAINER}::${CONTAINER}(${STLT} * vp) : basic(TINFO_${CONTAINER})
 396 {
 397     debugmsg("${CONTAINER} constructor from ${STLT} *",LOGLEVEL_CONSTRUCT);
 398     GINAC_ASSERT(vp!=0);
 399     seq.swap(*vp);
 400     delete vp;
 401 }
 402
 403 ${constructors_implementation}
 404
 405 //////////
 406 // archiving
 407 //////////
 408
 409 /** Construct object from archive_node. */
 410 ${CONTAINER}::${CONTAINER}(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst)
 411 {
 412     debugmsg("${CONTAINER} constructor from archive_node", LOGLEVEL_CONSTRUCT);
 413     for (unsigned int i=0; true; i++) {
 414         ex e;
 415         if (n.find_ex("seq", e, sym_lst, i))
 416             seq.push_back(e);
 417         else
 418             break;
 419     }
 420 }
 421
 422 /** Unarchive the object. */
 423 ex ${CONTAINER}::unarchive(const archive_node &n, const lst &sym_lst)
 424 {
 425     return (new ${CONTAINER}(n, sym_lst))->setflag(status_flags::dynallocated);
 426 }
 427
 428 /** Archive the object. */
 429 void ${CONTAINER}::archive(archive_node &n) const
 430 {
 431     inherited::archive(n);
 432     ${STLT}::const_iterator i = seq.begin(), iend = seq.end();
 433     while (i != iend) {
 434         n.add_ex("seq", *i);
 435         i++;
 436     }
 437 }
 438
 439 //////////
 440 // functions overriding virtual functions from bases classes
 441 //////////
 442
 443 // public
 444
 445 basic * ${CONTAINER}::duplicate() const
 446 {
 447     debugmsg("${CONTAINER} duplicate",LOGLEVEL_DUPLICATE);
 448     return new ${CONTAINER}(*this);
 449 }
 450
 451 void ${CONTAINER}::printraw(ostream & os) const
 452 {
 453     debugmsg("${CONTAINER} printraw",LOGLEVEL_PRINT);
 454
 455     os << "${CONTAINER}(";
 456     for (${STLT}::const_iterator cit=seq.begin(); cit!=seq.end(); ++cit) {
 457         (*cit).bp->printraw(os);
 458         os << ",";
 459     }
 460     os << ")";
 461 }
 462
 463 void ${CONTAINER}::print(ostream & os, unsigned upper_precedence) const
 464 {
 465     debugmsg("${CONTAINER} print",LOGLEVEL_PRINT);
 466     // always print brackets around seq, ignore upper_precedence
 467     printseq(os,'${open_bracket}',',','${close_bracket}',precedence,precedence+1);
 468 }
 469
 470 void ${CONTAINER}::printtree(ostream & os, unsigned indent) const
 471 {
 472     debugmsg("${CONTAINER} printtree",LOGLEVEL_PRINT);
 473
 474     os << string(indent,' ') << "type=" << typeid(*this).name()
 475        << ", hash=" << hashvalue << " (0x" << hex << hashvalue << dec << ")"
 476        << ", flags=" << flags
 477        << ", nops=" << nops() << endl;
 478     for (${STLT}::const_iterator cit=seq.begin(); cit!=seq.end(); ++cit) {
 479         (*cit).printtree(os,indent+delta_indent);
 480     }
 481     os << string(indent+delta_indent,' ') << "=====" << endl;
 482 }
 483
 484 // ${CONTAINER}::info() will be implemented by user elsewhere";
 485
 486 unsigned ${CONTAINER}::nops() const
 487 {
 488     return seq.size();
 489 }
 490
 491 ${LET_OP_IMPLEMENTATION}
 492
 493 ex ${CONTAINER}::expand(unsigned options) const
 494 {
 495     ${STLT} s;
 496     RESERVE(s,seq.size());
 497     for (${STLT}::const_iterator it=seq.begin(); it!=seq.end(); ++it) {
 498         s.push_back((*it).expand(options));
 499     }
 500
 501     return this${CONTAINER}(s);
 502 }
 503
 504 // a ${CONTAINER} 'has' an expression if it is this expression itself or a child 'has' it
 505
 506 bool ${CONTAINER}::has(const ex & other) const
 507 {
 508     GINAC_ASSERT(other.bp!=0);
 509     if (is_equal(*other.bp)) return true;
 510     for (${STLT}::const_iterator it=seq.begin(); it!=seq.end(); ++it) {
 511         if ((*it).has(other)) return true;
 512     }
 513     return false;
 514 }
 515
 516 ex ${CONTAINER}::eval(int level) const
 517 {
 518     if (level==1) {
 519         return this->hold();
 520     }
 521     return this${CONTAINER}(evalchildren(level));
 522 }
 523
 524 ex ${CONTAINER}::evalf(int level) const
 525 {
 526     return this${CONTAINER}(evalfchildren(level));
 527 }
 528
 529 /** Implementation of ex::normal() for ${CONTAINER}s. It normalizes the arguments
 530  *  and replaces the ${CONTAINER} by a temporary symbol.
 531  *  \@see ex::normal */
 532 ex ${CONTAINER}::normal(lst &sym_lst, lst &repl_lst, int level) const
 533 {
 534     ex n=this${CONTAINER}(normalchildren(level));
 535     return n.bp->basic::normal(sym_lst,repl_lst,level);
 536 }
 537
 538 ex ${CONTAINER}::derivative(const symbol & s) const
 539 {
 540     return this${CONTAINER}(diffchildren(s));
 541 }
 542
 543 ex ${CONTAINER}::subs(const lst & ls, const lst & lr) const
 544 {
 545     ${STLT} * vp=subschildren(ls,lr);
 546     if (vp==0) {
 547         return *this;
 548     }
 549     return this${CONTAINER}(vp);
 550 }
 551
 552 // protected
 553
 554 int ${CONTAINER}::compare_same_type(const basic & other) const
 555 {
 556     GINAC_ASSERT(is_of_type(other,${CONTAINER}));
 557     ${CONTAINER} const & o=static_cast<${CONTAINER} const &>
 558                                     (const_cast<basic &>(other));
 559     int cmpval;
 560     ${STLT}::const_iterator it1=seq.begin();
 561     ${STLT}::const_iterator it2=o.seq.begin();
 562
 563     for (; (it1!=seq.end())&&(it2!=o.seq.end()); ++it1, ++it2) {
 564         cmpval=(*it1).compare(*it2);
 565         if (cmpval!=0) return cmpval;
 566     }
 567
 568     if (it1==seq.end()) {
 569         return (it2==o.seq.end() ? 0 : -1);
 570     }
 571
 572     return 1;
 573 }
 574
 575 bool ${CONTAINER}::is_equal_same_type(const basic & other) const
 576 {
 577     GINAC_ASSERT(is_of_type(other,${CONTAINER}));
 578     ${CONTAINER} const & o=static_cast<${CONTAINER} const &>
 579                                     (const_cast<basic &>(other));
 580     if (seq.size()!=o.seq.size()) return false;
 581
 582     ${STLT}::const_iterator it1=seq.begin();
 583     ${STLT}::const_iterator it2=o.seq.begin();
 584
 585     for (; it1!=seq.end(); ++it1, ++it2) {
 586         if (!(*it1).is_equal(*it2)) return false;
 587     }
 588
 589     return true;
 590 }
 591
 592 unsigned ${CONTAINER}::return_type(void) const
 593 {
 594     return return_types::noncommutative_composite;
 595 }
 596
 597 //////////
 598 // new virtual functions which can be overridden by derived classes
 599 //////////
 600
 601 // public
 602
 603 ${CONTAINER} & ${CONTAINER}::append(const ex & b)
 604 {
 605     ensure_if_modifiable();
 606     seq.push_back(b);
 607     return *this;
 608 }
 609
 610 ${PREPEND_IMPLEMENTATION}
 611
 612 // protected
 613
 614 void ${CONTAINER}::printseq(ostream & os, char openbracket, char delim,
 615                          char closebracket, unsigned this_precedence,
 616                          unsigned upper_precedence) const
 617 {
 618     if (this_precedence<=upper_precedence) os << openbracket;
 619     if (seq.size()!=0) {
 620         ${STLT}::const_iterator it,it_last;
 621         it=seq.begin();
 622         it_last=seq.end();
 623         --it_last;
 624         for (; it!=it_last; ++it) {
 625             (*it).bp->print(os,this_precedence);
 626             os << delim;
 627         }
 628         (*it).bp->print(os,this_precedence);
 629     }
 630     if (this_precedence<=upper_precedence) os << closebracket;
 631 }
 632
 633 ex ${CONTAINER}::this${CONTAINER}(${STLT} const & v) const
 634 {
 635     return ${CONTAINER}(v);
 636 }
 637
 638 ex ${CONTAINER}::this${CONTAINER}(${STLT} * vp) const
 639 {
 640     return ${CONTAINER}(vp);
 641 }
 642
 643 //////////
 644 // non-virtual functions in this class
 645 //////////
 646
 647 // public
 648
 649 // none
 650
 651 // protected
 652
 653 bool ${CONTAINER}::is_canonical() const
 654 {
 655     if (seq.size()<=1) { return 1; }
 656
 657     ${STLT}::const_iterator it=seq.begin();
 658     ${STLT}::const_iterator it_last=it;
 659     for (++it; it!=seq.end(); it_last=it, ++it) {
 660         if ((*it_last).compare(*it)>0) {
 661             if ((*it_last).compare(*it)>0) {
 662                 cout << *it_last << ">" << *it << "\\n";
 663                 return 0;
 664                 }
 665         }
 666     }
 667     return 1;
 668 }
 669
 670
 671 ${STLT} ${CONTAINER}::evalchildren(int level) const
 672 {
 673     ${STLT} s;
 674     RESERVE(s,seq.size());
 675
 676     if (level==1) {
 677         return seq;
 678     }
 679     if (level == -max_recursion_level) {
 680         throw(std::runtime_error("max recursion level reached"));
 681     }
 682     --level;
 683     for (${STLT}::const_iterator it=seq.begin(); it!=seq.end(); ++it) {
 684         s.push_back((*it).eval(level));
 685     }
 686     return s;
 687 }
 688
 689 ${STLT} ${CONTAINER}::evalfchildren(int level) const
 690 {
 691     ${STLT} s;
 692     RESERVE(s,seq.size());
 693
 694     if (level==1) {
 695         return seq;
 696     }
 697     if (level == -max_recursion_level) {
 698         throw(std::runtime_error("max recursion level reached"));
 699     }
 700     --level;
 701     for (${STLT}::const_iterator it=seq.begin(); it!=seq.end(); ++it) {
 702         s.push_back((*it).evalf(level));
 703     }
 704     return s;
 705 }
 706
 707 ${STLT} ${CONTAINER}::normalchildren(int level) const
 708 {
 709     ${STLT} s;
 710     RESERVE(s,seq.size());
 711
 712     if (level==1) {
 713         return seq;
 714     }
 715     if (level == -max_recursion_level) {
 716         throw(std::runtime_error("max recursion level reached"));
 717     }
 718     --level;
 719     for (${STLT}::const_iterator it=seq.begin(); it!=seq.end(); ++it) {
 720         s.push_back((*it).normal(level));
 721     }
 722     return s;
 723 }
 724
 725 ${STLT} ${CONTAINER}::diffchildren(const symbol & y) const
 726 {
 727     ${STLT} s;
 728     RESERVE(s,seq.size());
 729     for (${STLT}::const_iterator it=seq.begin(); it!=seq.end(); ++it) {
 730         s.push_back((*it).diff(y));
 731     }
 732     return s;
 733 }
 734
 735 /* obsolete subschildren
 736 ${STLT} ${CONTAINER}::subschildren(const lst & ls, const lst & lr) const
 737 {
 738     ${STLT} s;
 739     RESERVE(s,seq.size());
 740     for (${STLT}::const_iterator it=seq.begin(); it!=seq.end(); ++it) {
 741         s.push_back((*it).subs(ls,lr));
 742     }
 743     return s;
 744 }
 745 */
 746
 747 ${STLT} * ${CONTAINER}::subschildren(const lst & ls, const lst & lr) const
 748 {
 749     // returns a NULL pointer if nothing had to be substituted
 750     // returns a pointer to a newly created epvector otherwise
 751     // (which has to be deleted somewhere else)
 752
 753     ${STLT}::const_iterator last=seq.end();
 754     ${STLT}::const_iterator cit=seq.begin();
 755     while (cit!=last) {
 756         const ex & subsed_ex=(*cit).subs(ls,lr);
 757         if (!are_ex_trivially_equal(*cit,subsed_ex)) {
 758
 759             // something changed, copy seq, subs and return it
 760             ${STLT} *s=new ${STLT};
 761             RESERVE(*s,seq.size());
 762
 763             // copy parts of seq which are known not to have changed
 764             ${STLT}::const_iterator cit2=seq.begin();
 765             while (cit2!=cit) {
 766                 s->push_back(*cit2);
 767                 ++cit2;
 768             }
 769             // copy first changed element
 770             s->push_back(subsed_ex);
 771             ++cit2;
 772             // copy rest
 773             while (cit2!=last) {
 774                 s->push_back((*cit2).subs(ls,lr));
 775                 ++cit2;
 776             }
 777             return s;
 778         }
 779         ++cit;
 780     }
 781
 782     return 0; // nothing has changed
 783 }
 784
 785 //////////
 786 // static member variables
 787 //////////
 788
 789 // protected
 790
 791 unsigned ${CONTAINER}::precedence=10;
 792
 793 //////////
 794 // global constants
 795 //////////
 796
 797 const ${CONTAINER} some_${CONTAINER};
 798 const type_info & typeid_${CONTAINER}=typeid(some_${CONTAINER});
 799
 800 #ifndef NO_NAMESPACE_GINAC
 801 } // namespace GiNaC
 802 #endif // ndef NO_NAMESPACE_GINAC
 803
 804 END_OF_IMPLEMENTATION
 805
 806 print "Creating interface file ${CONTAINER}.h...";
 807 open OUT,">${CONTAINER}.h" or die "cannot open ${CONTAINER}.h";
 808 print OUT $interface;
 809 close OUT;
 810 print "ok.\n";
 811
 812 print "Creating implementation file ${CONTAINER}.cpp...";
 813 open OUT,">${CONTAINER}.cpp" or die "cannot open ${CONTAINER}.cpp";
 814 print OUT $implementation;
 815 close OUT;
 816 print "ok.\n";
 817
 818 print "done.\n";