ginac/function.pl

   1 $maxargs=13;
   2
   3 sub generate_seq {
   4         my ($seq_template,$n)=@_;
   5         my ($res,$N);
   6
   7         $res='';
   8         for ($N=1; $N<=$n; $N++) {
   9                 $res .= eval('"' . $seq_template . '"');
  10                 if ($N!=$n) {
  11                         $res .= ', ';
  12                 }
  13         }
  14         return $res;
  15 }
  16
  17 sub generate_from_to {
  18         my ($template,$seq_template1,$seq_template2,$from,$to)=@_;
  19         my ($res,$N,$SEQ);
  20
  21         $res='';
  22         for ($N=$from; $N<=$to; $N++) {
  23                 $SEQ1=generate_seq($seq_template1,$N);
  24                 $SEQ2=generate_seq($seq_template2,$N);
  25                 $res .= eval('"' . $template . '"');
  26                 $SEQ1=''; # to avoid main::SEQ1 used only once warning
  27                 $SEQ2=''; # same as above
  28         }
  29         return $res;
  30 }
  31
  32 sub generate {
  33         my ($template,$seq_template1,$seq_template2)=@_;
  34         return generate_from_to($template,$seq_template1,$seq_template2,1,$maxargs);
  35 }
  36
  37 $declare_function_macro_namespace = <<'END_OF_DECLARE_FUNCTION_1_AND_2P_MACRO_NAMESPACE';
  38 #define DECLARE_FUNCTION_1P(NAME) \
  39 extern const unsigned function_index_##NAME; \
  40 inline GiNaC::function NAME(const GiNaC::ex & p1) { \
  41         return GiNaC::function(function_index_##NAME, p1); \
  42 }
  43 #define DECLARE_FUNCTION_2P(NAME) \
  44 extern const unsigned function_index_##NAME; \
  45 inline GiNaC::function NAME(const GiNaC::ex & p1, const GiNaC::ex & p2) { \
  46         return GiNaC::function(function_index_##NAME, p1, p2); \
  47 }
  48
  49 END_OF_DECLARE_FUNCTION_1_AND_2P_MACRO_NAMESPACE
  50
  51 $declare_function_macro_namespace .= generate_from_to(
  52         <<'END_OF_DECLARE_FUNCTION_MACRO_NAMESPACE','const GiNaC::ex & p${N}','p${N}',3,$maxargs);
  53 #define DECLARE_FUNCTION_${N}P(NAME) \\
  54 extern const unsigned function_index_##NAME; \\
  55 inline GiNaC::function NAME(${SEQ1}) { \\
  56         return GiNaC::function(function_index_##NAME, ${SEQ2}); \\
  57 }
  58
  59 END_OF_DECLARE_FUNCTION_MACRO_NAMESPACE
  60
  61 $declare_function_macro_no_namespace = <<'END_OF_DECLARE_FUNCTION_1_AND_2P_MACRO_NO_NAMESPACE';
  62 #define DECLARE_FUNCTION_1P(NAME) \
  63 extern const unsigned function_index_##NAME; \
  64 inline function NAME(const ex & p1) { \
  65         return function(function_index_##NAME, p1); \
  66 }
  67 #define DECLARE_FUNCTION_2P(NAME) \
  68 extern const unsigned function_index_##NAME; \
  69 inline function NAME(const ex & p1, const ex & p2) { \
  70         return function(function_index_##NAME, p1, p2); \
  71 }
  72
  73 END_OF_DECLARE_FUNCTION_1_AND_2P_MACRO_NO_NAMESPACE
  74
  75 $declare_function_macro_no_namespace .= generate_from_to(
  76         <<'END_OF_DECLARE_FUNCTION_MACRO_NO_NAMESPACE','const ex & p${N}','p${N}',3,$maxargs);
  77 #define DECLARE_FUNCTION_${N}P(NAME) \\
  78 extern const unsigned function_index_##NAME; \\
  79 inline function NAME(${SEQ1}) { \\
  80         return function(function_index_##NAME, ${SEQ2}); \\
  81 }
  82
  83 END_OF_DECLARE_FUNCTION_MACRO_NO_NAMESPACE
  84
  85 $typedef_eval_funcp=generate(
  86 'typedef ex (* eval_funcp_${N})(${SEQ1});'."\n",
  87 'const ex &','');
  88
  89 $typedef_evalf_funcp=generate(
  90 'typedef ex (* evalf_funcp_${N})(${SEQ1});'."\n",
  91 'const ex &','');
  92
  93 $typedef_derivative_funcp=generate(
  94 'typedef ex (* derivative_funcp_${N})(${SEQ1}, unsigned);'."\n",
  95 'const ex &','');
  96
  97 $typedef_series_funcp=generate(
  98 'typedef ex (* series_funcp_${N})(${SEQ1}, const relational &, int, unsigned);'."\n",
  99 'const ex &','');
 100
 101 $eval_func_interface=generate('    function_options & eval_func(eval_funcp_${N} e);'."\n",'','');
 102
 103 $evalf_func_interface=generate('    function_options & evalf_func(evalf_funcp_${N} ef);'."\n",'','');
 104
 105 $derivative_func_interface=generate('    function_options & derivative_func(derivative_funcp_${N} d);'."\n",'','');
 106
 107 $series_func_interface=generate('    function_options & series_func(series_funcp_${N} s);'."\n",'','');
 108
 109 $constructors_interface=generate(
 110 '    function(unsigned ser, ${SEQ1});'."\n",
 111 'const ex & param${N}','');
 112
 113 $constructors_implementation=generate(
 114         <<'END_OF_CONSTRUCTORS_IMPLEMENTATION','const ex & param${N}','param${N}');
 115 function::function(unsigned ser, ${SEQ1})
 116         : exprseq(${SEQ2}), serial(ser)
 117 {
 118         debugmsg(\"function constructor from unsigned,${N}*ex\",LOGLEVEL_CONSTRUCT);
 119         tinfo_key = TINFO_function;
 120 }
 121 END_OF_CONSTRUCTORS_IMPLEMENTATION
 122
 123 $eval_switch_statement=generate(
 124         <<'END_OF_EVAL_SWITCH_STATEMENT','seq[${N}-1]','');
 125         case ${N}:
 126                 eval_result=((eval_funcp_${N})(registered_functions()[serial].eval_f))(${SEQ1});
 127                 break;
 128 END_OF_EVAL_SWITCH_STATEMENT
 129
 130 $evalf_switch_statement=generate(
 131         <<'END_OF_EVALF_SWITCH_STATEMENT','eseq[${N}-1]','');
 132         case ${N}:
 133                 return ((evalf_funcp_${N})(registered_functions()[serial].evalf_f))(${SEQ1});
 134                 break;
 135 END_OF_EVALF_SWITCH_STATEMENT
 136
 137 $diff_switch_statement=generate(
 138         <<'END_OF_DIFF_SWITCH_STATEMENT','seq[${N}-1]','');
 139         case ${N}:
 140                 return ((derivative_funcp_${N})(registered_functions()[serial].derivative_f))(${SEQ1},diff_param);
 141                 break;
 142 END_OF_DIFF_SWITCH_STATEMENT
 143
 144 $series_switch_statement=generate(
 145         <<'END_OF_SERIES_SWITCH_STATEMENT','seq[${N}-1]','');
 146         case ${N}:
 147                 try {
 148                         res = ((series_funcp_${N})(registered_functions()[serial].series_f))(${SEQ1},r,order,options);
 149                 } catch (do_taylor) {
 150                         res = basic::series(r, order, options);
 151                 }
 152                 return res;
 153                 break;
 154 END_OF_SERIES_SWITCH_STATEMENT
 155
 156 $eval_func_implementation=generate(
 157         <<'END_OF_EVAL_FUNC_IMPLEMENTATION','','');
 158 function_options & function_options::eval_func(eval_funcp_${N} e)
 159 {
 160         test_and_set_nparams(${N});
 161         eval_f=eval_funcp(e);
 162         return *this;
 163 }
 164 END_OF_EVAL_FUNC_IMPLEMENTATION
 165
 166 $evalf_func_implementation=generate(
 167         <<'END_OF_EVALF_FUNC_IMPLEMENTATION','','');
 168 function_options & function_options::evalf_func(evalf_funcp_${N} ef)
 169 {
 170         test_and_set_nparams(${N});
 171         evalf_f=evalf_funcp(ef);
 172         return *this;
 173 }
 174 END_OF_EVALF_FUNC_IMPLEMENTATION
 175
 176 $derivative_func_implementation=generate(
 177         <<'END_OF_DERIVATIVE_FUNC_IMPLEMENTATION','','');
 178 function_options & function_options::derivative_func(derivative_funcp_${N} d)
 179 {
 180         test_and_set_nparams(${N});
 181         derivative_f=derivative_funcp(d);
 182         return *this;
 183 }
 184 END_OF_DERIVATIVE_FUNC_IMPLEMENTATION
 185
 186 $series_func_implementation=generate(
 187         <<'END_OF_SERIES_FUNC_IMPLEMENTATION','','');
 188 function_options & function_options::series_func(series_funcp_${N} s)
 189 {
 190         test_and_set_nparams(${N});
 191         series_f=series_funcp(s);
 192         return *this;
 193 }
 194 END_OF_SERIES_FUNC_IMPLEMENTATION
 195
 196 $interface=<<END_OF_INTERFACE;
 197 /** \@file function.h
 198  *
 199  *  Interface to abstract class function (new function concept). */
 200
 201 /*
 202  *  This file was generated automatically by function.pl.
 203  *  Please do not modify it directly, edit the perl script instead!
 204  *  function.pl options: \$maxargs=${maxargs}
 205  *
 206  *  GiNaC Copyright (C) 1999-2000 Johannes Gutenberg University Mainz, Germany
 207  *
 208  *  This program is free software; you can redistribute it and/or modify
 209  *  it under the terms of the GNU General Public License as published by
 210  *  the Free Software Foundation; either version 2 of the License, or
 211  *  (at your option) any later version.
 212  *
 213  *  This program is distributed in the hope that it will be useful,
 214  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 215  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 216  *  GNU General Public License for more details.
 217  *
 218  *  You should have received a copy of the GNU General Public License
 219  *  along with this program; if not, write to the Free Software
 220  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 221  */
 222
 223 #ifndef __GINAC_FUNCTION_H__
 224 #define __GINAC_FUNCTION_H__
 225
 226 #include <string>
 227 #include <vector>
 228
 229 // CINT needs <algorithm> to work properly with <vector>
 230 #include <algorithm>
 231
 232 #include "exprseq.h"
 233
 234 #ifndef NO_NAMESPACE_GINAC
 235
 236 // the following lines have been generated for max. ${maxargs} parameters
 237 $declare_function_macro_namespace
 238 // end of generated lines
 239
 240 #else // ndef NO_NAMESPACE_GINAC
 241
 242 // the following lines have been generated for max. ${maxargs} parameters
 243 $declare_function_macro_no_namespace
 244 // end of generated lines
 245
 246 #endif // ndef NO_NAMESPACE_GINAC
 247
 248 #ifndef NO_NAMESPACE_GINAC
 249
 250 #define REGISTER_FUNCTION(NAME,OPT) \\
 251 const unsigned function_index_##NAME= \\
 252         GiNaC::function::register_new(GiNaC::function_options(#NAME).OPT);
 253
 254 #define REGISTER_FUNCTION_OLD(NAME,E,EF,D,S) \\
 255 const unsigned function_index_##NAME= \\
 256         GiNaC::function::register_new(GiNaC::function_options(#NAME). \\
 257                                       eval_func(E). \\
 258                                       evalf_func(EF). \\
 259                                       derivative_func(D). \\
 260                                       series_func(S));
 261
 262 #else // ndef NO_NAMESPACE_GINAC
 263
 264 #define REGISTER_FUNCTION(NAME,OPT) \\
 265 const unsigned function_index_##NAME= \\
 266         function::register_new(function_options(#NAME).OPT);
 267
 268 #define REGISTER_FUNCTION_OLD(NAME,E,EF,D,S) \\
 269 const unsigned function_index_##NAME= \\
 270         function::register_new(function_options(#NAME). \\
 271                                eval_func(E). \\
 272                                evalf_func(EF). \\
 273                                derivative_func(D). \\
 274                                series_func(S));
 275
 276 #endif // ndef NO_NAMESPACE_GINAC
 277
 278 #define BEGIN_TYPECHECK \\
 279 bool automatic_typecheck=true;
 280
 281 #define TYPECHECK(VAR,TYPE) \\
 282 if (!is_ex_exactly_of_type(VAR,TYPE)) { \\
 283         automatic_typecheck=false; \\
 284 } else
 285
 286 #ifndef NO_NAMESPACE_GINAC
 287
 288 #define TYPECHECK_INTEGER(VAR) \\
 289 if (!(VAR).info(GiNaC::info_flags::integer)) { \\
 290         automatic_typecheck=false; \\
 291 } else
 292
 293 #else // ndef NO_NAMESPACE_GINAC
 294
 295 #define TYPECHECK_INTEGER(VAR) \\
 296 if (!(VAR).info(info_flags::integer)) { \\
 297         automatic_typecheck=false; \\
 298 } else
 299
 300 #endif // ndef NO_NAMESPACE_GINAC
 301
 302 #define END_TYPECHECK(RV) \\
 303 {} \\
 304 if (!automatic_typecheck) { \\
 305         return RV.hold(); \\
 306 }
 307
 308 #ifndef NO_NAMESPACE_GINAC
 309 namespace GiNaC {
 310 #endif // ndef NO_NAMESPACE_GINAC
 311
 312 class function;
 313
 314 typedef ex (* eval_funcp)();
 315 typedef ex (* evalf_funcp)();
 316 typedef ex (* derivative_funcp)();
 317 typedef ex (* series_funcp)();
 318
 319 // the following lines have been generated for max. ${maxargs} parameters
 320 $typedef_eval_funcp
 321 $typedef_evalf_funcp
 322 $typedef_derivative_funcp
 323 $typedef_series_funcp
 324 // end of generated lines
 325
 326 class function_options
 327 {
 328         friend class function;
 329 public:
 330         function_options();
 331         function_options(std::string const & n, std::string const & tn=std::string());
 332         ~function_options();
 333         void initialize(void);
 334         function_options & set_name(std::string const & n, std::string const & tn=std::string());
 335 // the following lines have been generated for max. ${maxargs} parameters
 336 $eval_func_interface
 337 $evalf_func_interface
 338 $derivative_func_interface
 339 $series_func_interface
 340 // end of generated lines
 341         function_options & set_return_type(unsigned rt, unsigned rtt=0);
 342         function_options & do_not_evalf_params(void);
 343         function_options & remember(unsigned size, unsigned assoc_size=0,
 344                                     unsigned strategy=remember_strategies::delete_never);
 345         function_options & overloaded(unsigned o);
 346         void test_and_set_nparams(unsigned n);
 347         std::string get_name(void) const { return name; }
 348         unsigned get_nparams(void) const { return nparams; }
 349
 350 protected:
 351         std::string name;
 352         std::string TeX_name;
 353
 354         unsigned nparams;
 355
 356         eval_funcp eval_f;
 357         evalf_funcp evalf_f;
 358         derivative_funcp derivative_f;
 359         series_funcp series_f;
 360
 361         bool evalf_params_first;
 362
 363         bool use_return_type;
 364         unsigned return_type;
 365         unsigned return_type_tinfo;
 366
 367         bool use_remember;
 368         unsigned remember_size;
 369         unsigned remember_assoc_size;
 370         unsigned remember_strategy;
 371
 372         unsigned functions_with_same_name;
 373 };
 374
 375 /** The class function is used to implement builtin functions like sin, cos...
 376         and user defined functions */
 377 class function : public exprseq
 378 {
 379         GINAC_DECLARE_REGISTERED_CLASS(function, exprseq)
 380
 381         // CINT has a linking problem
 382 #ifndef __MAKECINT__
 383         friend void ginsh_get_ginac_functions(void);
 384 #endif // def __MAKECINT__
 385
 386         friend class remember_table_entry;
 387         // friend class remember_table_list;
 388         // friend class remember_table;
 389
 390 // member functions
 391
 392         // default constructor, destructor, copy constructor assignment operator and helpers
 393 public:
 394         function();
 395         ~function();
 396         function(const function & other);
 397         const function & operator=(const function & other);
 398 protected:
 399         void copy(const function & other);
 400         void destroy(bool call_parent);
 401
 402         // other constructors
 403 public:
 404         function(unsigned ser);
 405         // the following lines have been generated for max. ${maxargs} parameters
 406 $constructors_interface
 407         // end of generated lines
 408         function(unsigned ser, const exprseq & es);
 409         function(unsigned ser, const exvector & v, bool discardable=0);
 410         function(unsigned ser, exvector * vp); // vp will be deleted
 411
 412         // functions overriding virtual functions from bases classes
 413 public:
 414         basic * duplicate() const;
 415         void printraw(std::ostream & os) const;
 416         void print(std::ostream & os, unsigned upper_precedence=0) const;
 417         void printtree(std::ostream & os, unsigned indent) const;
 418         void printcsrc(std::ostream & os, unsigned type, unsigned upper_precedence=0) const;
 419         ex expand(unsigned options=0) const;
 420         ex eval(int level=0) const;
 421         ex evalf(int level=0) const;
 422         ex series(const relational & r, int order, unsigned options = 0) const;
 423         ex thisexprseq(const exvector & v) const;
 424         ex thisexprseq(exvector * vp) const;
 425 protected:
 426         ex derivative(const symbol & s) const;
 427         int compare_same_type(const basic & other) const;
 428         bool is_equal_same_type(const basic & other) const;
 429         unsigned return_type(void) const;
 430         unsigned return_type_tinfo(void) const;
 431
 432         // new virtual functions which can be overridden by derived classes
 433         // none
 434
 435         // non-virtual functions in this class
 436 protected:
 437         ex pderivative(unsigned diff_param) const; // partial differentiation
 438         static std::vector<function_options> & registered_functions(void);
 439         bool lookup_remember_table(ex & result) const;
 440         void store_remember_table(ex const & result) const;
 441 public:
 442         static unsigned register_new(function_options const & opt);
 443         static unsigned find_function(const std::string &name, unsigned nparams);
 444         unsigned getserial(void) const {return serial;}
 445
 446 // member variables
 447
 448 protected:
 449         unsigned serial;
 450 };
 451
 452 // utility functions/macros
 453 inline const function &ex_to_function(const ex &e)
 454 {
 455         return static_cast<const function &>(*e.bp);
 456 }
 457
 458 #ifndef NO_NAMESPACE_GINAC
 459
 460 #define is_ex_the_function(OBJ, FUNCNAME) \\
 461         (is_ex_exactly_of_type(OBJ, function) && static_cast<GiNaC::function *>(OBJ.bp)->getserial() == function_index_##FUNCNAME)
 462
 463 #else // ndef NO_NAMESPACE_GINAC
 464
 465 #define is_ex_the_function(OBJ, FUNCNAME) \\
 466         (is_ex_exactly_of_type(OBJ, function) && static_cast<function *>(OBJ.bp)->getserial() == function_index_##FUNCNAME)
 467
 468 #endif // ndef NO_NAMESPACE_GINAC
 469
 470 // global constants
 471
 472 extern const function some_function;
 473 extern const type_info & typeid_function;
 474
 475 #ifndef NO_NAMESPACE_GINAC
 476 } // namespace GiNaC
 477 #endif // ndef NO_NAMESPACE_GINAC
 478
 479 #endif // ndef __GINAC_FUNCTION_H__
 480
 481 END_OF_INTERFACE
 482
 483 $implementation=<<END_OF_IMPLEMENTATION;
 484 /** \@file function.cpp
 485  *
 486  *  Implementation of class function. */
 487
 488 /*
 489  *  This file was generated automatically by function.pl.
 490  *  Please do not modify it directly, edit the perl script instead!
 491  *  function.pl options: \$maxargs=${maxargs}
 492  *
 493  *  GiNaC Copyright (C) 1999-2000 Johannes Gutenberg University Mainz, Germany
 494  *
 495  *  This program is free software; you can redistribute it and/or modify
 496  *  it under the terms of the GNU General Public License as published by
 497  *  the Free Software Foundation; either version 2 of the License, or
 498  *  (at your option) any later version.
 499  *
 500  *  This program is distributed in the hope that it will be useful,
 501  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 502  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 503  *  GNU General Public License for more details.
 504  *
 505  *  You should have received a copy of the GNU General Public License
 506  *  along with this program; if not, write to the Free Software
 507  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 508  */
 509
 510 #include <string>
 511 #include <stdexcept>
 512 #include <list>
 513
 514 #include "function.h"
 515 #include "ex.h"
 516 #include "lst.h"
 517 #include "archive.h"
 518 #include "inifcns.h"
 519 #include "utils.h"
 520 #include "debugmsg.h"
 521 #include "remember.h"
 522
 523 #ifndef NO_NAMESPACE_GINAC
 524 namespace GiNaC {
 525 #endif // ndef NO_NAMESPACE_GINAC
 526
 527 //////////
 528 // helper class function_options
 529 //////////
 530
 531 function_options::function_options()
 532 {
 533         initialize();
 534 }
 535
 536 function_options::function_options(std::string const & n, std::string const & tn)
 537 {
 538         initialize();
 539         set_name(n,tn);
 540 }
 541
 542 function_options::~function_options()
 543 {
 544         // nothing to clean up at the moment
 545 }
 546
 547 void function_options::initialize(void)
 548 {
 549         set_name("unnamed_function","\\\\operatorname{unnamed}");
 550         nparams=0;
 551         eval_f=evalf_f=derivative_f=series_f=0;
 552         evalf_params_first=true;
 553         use_return_type=false;
 554         use_remember=false;
 555         functions_with_same_name=1;
 556 }
 557
 558 function_options & function_options::set_name(std::string const & n,
 559                                               std::string const & tn)
 560 {
 561         name=n;
 562         if (tn==std::string()) {
 563                 TeX_name="\\\\operatorname{"+name+"}";
 564         } else {
 565                 TeX_name=tn;
 566         }
 567         return *this;
 568 }
 569
 570 // the following lines have been generated for max. ${maxargs} parameters
 571 $eval_func_implementation
 572 $evalf_func_implementation
 573 $derivative_func_implementation
 574 $series_func_implementation
 575 // end of generated lines
 576
 577 function_options & function_options::set_return_type(unsigned rt, unsigned rtt)
 578 {
 579         use_return_type=true;
 580         return_type=rt;
 581         return_type_tinfo=rtt;
 582         return *this;
 583 }
 584
 585 function_options & function_options::do_not_evalf_params(void)
 586 {
 587         evalf_params_first=false;
 588         return *this;
 589 }
 590
 591 function_options & function_options::remember(unsigned size,
 592                                               unsigned assoc_size,
 593                                               unsigned strategy)
 594 {
 595         use_remember=true;
 596         remember_size=size;
 597         remember_assoc_size=assoc_size;
 598         remember_strategy=strategy;
 599         return *this;
 600 }
 601
 602 function_options & function_options::overloaded(unsigned o)
 603 {
 604         functions_with_same_name=o;
 605         return *this;
 606 }
 607
 608 void function_options::test_and_set_nparams(unsigned n)
 609 {
 610         if (nparams==0) {
 611                 nparams=n;
 612         } else if (nparams!=n) {
 613                 // we do not throw an exception here because this code is
 614                 // usually executed before main(), so the exception could not
 615                 // caught anyhow
 616                 std::cerr << "WARNING: number of parameters ("
 617                           << n << ") differs from number set before ("
 618                           << nparams << ")" << std::endl;
 619         }
 620 }
 621
 622 GINAC_IMPLEMENT_REGISTERED_CLASS(function, exprseq)
 623
 624 //////////
 625 // default constructor, destructor, copy constructor assignment operator and helpers
 626 //////////
 627
 628 // public
 629
 630 function::function() : serial(0)
 631 {
 632         debugmsg("function default constructor",LOGLEVEL_CONSTRUCT);
 633         tinfo_key = TINFO_function;
 634 }
 635
 636 function::~function()
 637 {
 638         debugmsg("function destructor",LOGLEVEL_DESTRUCT);
 639         destroy(false);
 640 }
 641
 642 function::function(const function & other)
 643 {
 644         debugmsg("function copy constructor",LOGLEVEL_CONSTRUCT);
 645         copy(other);
 646 }
 647
 648 const function & function::operator=(const function & other)
 649 {
 650         debugmsg("function operator=",LOGLEVEL_ASSIGNMENT);
 651         if (this != &other) {
 652                 destroy(true);
 653                 copy(other);
 654         }
 655         return *this;
 656 }
 657
 658 // protected
 659
 660 void function::copy(const function & other)
 661 {
 662         exprseq::copy(other);
 663         serial=other.serial;
 664 }
 665
 666 void function::destroy(bool call_parent)
 667 {
 668         if (call_parent) exprseq::destroy(call_parent);
 669 }
 670
 671 //////////
 672 // other constructors
 673 //////////
 674
 675 // public
 676
 677 function::function(unsigned ser) : serial(ser)
 678 {
 679         debugmsg("function constructor from unsigned",LOGLEVEL_CONSTRUCT);
 680         tinfo_key = TINFO_function;
 681 }
 682
 683 // the following lines have been generated for max. ${maxargs} parameters
 684 $constructors_implementation
 685 // end of generated lines
 686
 687 function::function(unsigned ser, const exprseq & es) : exprseq(es), serial(ser)
 688 {
 689         debugmsg("function constructor from unsigned,exprseq",LOGLEVEL_CONSTRUCT);
 690         tinfo_key = TINFO_function;
 691 }
 692
 693 function::function(unsigned ser, const exvector & v, bool discardable)
 694   : exprseq(v,discardable), serial(ser)
 695 {
 696         debugmsg("function constructor from string,exvector,bool",LOGLEVEL_CONSTRUCT);
 697         tinfo_key = TINFO_function;
 698 }
 699
 700 function::function(unsigned ser, exvector * vp)
 701   : exprseq(vp), serial(ser)
 702 {
 703         debugmsg("function constructor from unsigned,exvector *",LOGLEVEL_CONSTRUCT);
 704         tinfo_key = TINFO_function;
 705 }
 706
 707 //////////
 708 // archiving
 709 //////////
 710
 711 /** Construct object from archive_node. */
 712 function::function(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst)
 713 {
 714         debugmsg("function constructor from archive_node", LOGLEVEL_CONSTRUCT);
 715
 716         // Find serial number by function name
 717         std::string s;
 718         if (n.find_string("name", s)) {
 719                 unsigned int ser = 0;
 720                 std::vector<function_options>::const_iterator i = registered_functions().begin(), iend = registered_functions().end();
 721                 while (i != iend) {
 722                         if (s == i->name) {
 723                                 serial = ser;
 724                                 return;
 725                         }
 726                         i++; ser++;
 727                 }
 728                 throw (std::runtime_error("unknown function '" + s + "' in archive"));
 729         } else
 730                 throw (std::runtime_error("unnamed function in archive"));
 731 }
 732
 733 /** Unarchive the object. */
 734 ex function::unarchive(const archive_node &n, const lst &sym_lst)
 735 {
 736         return (new function(n, sym_lst))->setflag(status_flags::dynallocated);
 737 }
 738
 739 /** Archive the object. */
 740 void function::archive(archive_node &n) const
 741 {
 742         inherited::archive(n);
 743         GINAC_ASSERT(serial < registered_functions().size());
 744         n.add_string("name", registered_functions()[serial].name);
 745 }
 746
 747 //////////
 748 // functions overriding virtual functions from bases classes
 749 //////////
 750
 751 // public
 752
 753 basic * function::duplicate() const
 754 {
 755         debugmsg("function duplicate",LOGLEVEL_DUPLICATE);
 756         return new function(*this);
 757 }
 758
 759 void function::printraw(std::ostream & os) const
 760 {
 761         debugmsg("function printraw",LOGLEVEL_PRINT);
 762
 763         GINAC_ASSERT(serial<registered_functions().size());
 764
 765         os << "function(name=" << registered_functions()[serial].name;
 766         for (exvector::const_iterator it=seq.begin(); it!=seq.end(); ++it) {
 767                 os << ",";
 768                 (*it).bp->print(os);
 769         }
 770         os << ")";
 771 }
 772
 773 void function::print(std::ostream & os, unsigned upper_precedence) const
 774 {
 775         debugmsg("function print",LOGLEVEL_PRINT);
 776
 777         GINAC_ASSERT(serial<registered_functions().size());
 778
 779         os << registered_functions()[serial].name;
 780         printseq(os,'(',',',')',exprseq::precedence,function::precedence);
 781 }
 782
 783 void function::printtree(std::ostream & os, unsigned indent) const
 784 {
 785         debugmsg("function printtree",LOGLEVEL_PRINT);
 786
 787         GINAC_ASSERT(serial<registered_functions().size());
 788
 789         os << std::string(indent,' ') << "function "
 790            << registered_functions()[serial].name
 791            << ", hash=" << hashvalue
 792            << " (0x" << std::hex << hashvalue << std::dec << ")"
 793            << ", flags=" << flags
 794            << ", nops=" << nops() << std::endl;
 795         for (unsigned i=0; i<nops(); ++i) {
 796                 seq[i].printtree(os,indent+delta_indent);
 797         }
 798         os << std::string(indent+delta_indent,' ') << "=====" << std::endl;
 799 }
 800
 801 void function::printcsrc(std::ostream & os, unsigned type, unsigned upper_precedence) const
 802 {
 803         debugmsg("function print csrc",LOGLEVEL_PRINT);
 804
 805         GINAC_ASSERT(serial<registered_functions().size());
 806
 807         // Print function name in lowercase
 808         std::string lname;
 809         lname=registered_functions()[serial].name;
 810         for (unsigned i=0; i<lname.size(); i++)
 811                 lname[i] = tolower(lname[i]);
 812         os << lname << "(";
 813
 814         // Print arguments, separated by commas
 815         exvector::const_iterator it = seq.begin();
 816         exvector::const_iterator itend = seq.end();
 817         while (it != itend) {
 818                 it->bp->printcsrc(os, type, 0);
 819                 it++;
 820                 if (it != itend)
 821                         os << ",";
 822         }
 823         os << ")";
 824 }
 825
 826 ex function::expand(unsigned options) const
 827 {
 828         return this->setflag(status_flags::expanded);
 829 }
 830
 831 ex function::eval(int level) const
 832 {
 833         GINAC_ASSERT(serial<registered_functions().size());
 834
 835         if (level>1) {
 836                 // first evaluate children, then we will end up here again
 837                 return function(serial,evalchildren(level));
 838         }
 839
 840         if (registered_functions()[serial].eval_f==0) {
 841                 return this->hold();
 842         }
 843
 844         bool use_remember=registered_functions()[serial].use_remember;
 845         ex eval_result;
 846         if (use_remember && lookup_remember_table(eval_result)) {
 847                 return eval_result;
 848         }
 849
 850         switch (registered_functions()[serial].nparams) {
 851                 // the following lines have been generated for max. ${maxargs} parameters
 852 ${eval_switch_statement}
 853                 // end of generated lines
 854         default:
 855                 throw(std::logic_error("function::eval(): invalid nparams"));
 856         }
 857         if (use_remember) {
 858                 store_remember_table(eval_result);
 859         }
 860         return eval_result;
 861 }
 862
 863 ex function::evalf(int level) const
 864 {
 865         GINAC_ASSERT(serial<registered_functions().size());
 866
 867         exvector eseq=evalfchildren(level);
 868
 869         if (registered_functions()[serial].evalf_f==0) {
 870                 return function(serial,eseq).hold();
 871         }
 872         switch (registered_functions()[serial].nparams) {
 873                 // the following lines have been generated for max. ${maxargs} parameters
 874 ${evalf_switch_statement}
 875                 // end of generated lines
 876         }
 877         throw(std::logic_error("function::evalf(): invalid nparams"));
 878 }
 879
 880 ex function::thisexprseq(const exvector & v) const
 881 {
 882         return function(serial,v);
 883 }
 884
 885 ex function::thisexprseq(exvector * vp) const
 886 {
 887         return function(serial,vp);
 888 }
 889
 890 /** Implementation of ex::series for functions.
 891  *  \@see ex::series */
 892 ex function::series(const relational & r, int order, unsigned options = 0) const
 893 {
 894         GINAC_ASSERT(serial<registered_functions().size());
 895
 896         if (registered_functions()[serial].series_f==0) {
 897                 return basic::series(r, order);
 898         }
 899         ex res;
 900         switch (registered_functions()[serial].nparams) {
 901                 // the following lines have been generated for max. ${maxargs} parameters
 902 ${series_switch_statement}
 903                 // end of generated lines
 904         }
 905         throw(std::logic_error("function::series(): invalid nparams"));
 906 }
 907
 908 // protected
 909
 910
 911 /** Implementation of ex::diff() for functions. It applies the chain rule,
 912  *  except for the Order term function.
 913  *  \@see ex::diff */
 914 ex function::derivative(const symbol & s) const
 915 {
 916         ex result;
 917
 918         if (serial == function_index_Order) {
 919                 // Order Term function only differentiates the argument
 920                 return Order(seq[0].diff(s));
 921         } else if (serial == function_index_Derivative) {
 922                 // Inert derivative performs chain rule on the first argument only, and
 923                 // adds differentiation parameter to list (second argument)
 924                 GINAC_ASSERT(is_ex_exactly_of_type(seq[0], function));
 925                 GINAC_ASSERT(is_ex_exactly_of_type(seq[1], function));
 926                 ex fcn = seq[0];
 927                 ex arg_diff;
 928                 for (unsigned i=0; i!=fcn.nops(); i++) {
 929                         arg_diff = fcn.op(i).diff(s);
 930                         if (!arg_diff.is_zero()) {
 931                                 lst new_lst = ex_to_lst(seq[1]);
 932                                 new_lst.append(i);
 933                                 result += arg_diff * Derivative(fcn, new_lst);
 934                         }
 935                 }
 936         } else {
 937                 // Chain rule
 938                 ex arg_diff;
 939                 for (unsigned i=0; i!=seq.size(); i++) {
 940                         arg_diff = seq[i].diff(s);
 941                         // We apply the chain rule only when it makes sense.  This is not
 942                         // just for performance reasons but also to allow functions to
 943                         // throw when differentiated with respect to one of its arguments
 944                         // without running into trouble with our automatic full
 945                         // differentiation:
 946                         if (!arg_diff.is_zero())
 947                                 result += pderivative(i)*arg_diff;
 948                 }
 949         }
 950         return result;
 951 }
 952
 953 int function::compare_same_type(const basic & other) const
 954 {
 955         GINAC_ASSERT(is_of_type(other, function));
 956         const function & o=static_cast<function &>(const_cast<basic &>(other));
 957
 958         if (serial!=o.serial) {
 959                 return serial < o.serial ? -1 : 1;
 960         }
 961         return exprseq::compare_same_type(o);
 962 }
 963
 964 bool function::is_equal_same_type(const basic & other) const
 965 {
 966         GINAC_ASSERT(is_of_type(other, function));
 967         const function & o=static_cast<function &>(const_cast<basic &>(other));
 968
 969         if (serial!=o.serial) return false;
 970         return exprseq::is_equal_same_type(o);
 971 }
 972
 973 unsigned function::return_type(void) const
 974 {
 975         if (seq.size()==0) {
 976                 return return_types::commutative;
 977         }
 978         return (*seq.begin()).return_type();
 979 }
 980
 981 unsigned function::return_type_tinfo(void) const
 982 {
 983         if (seq.size()==0) {
 984                 return tinfo_key;
 985         }
 986         return (*seq.begin()).return_type_tinfo();
 987 }
 988
 989 //////////
 990 // new virtual functions which can be overridden by derived classes
 991 //////////
 992
 993 // none
 994
 995 //////////
 996 // non-virtual functions in this class
 997 //////////
 998
 999 // protected
1000
1001 ex function::pderivative(unsigned diff_param) const // partial differentiation
1002 {
1003         GINAC_ASSERT(serial<registered_functions().size());
1004
1005         if (registered_functions()[serial].derivative_f==0) {
1006                 return Derivative(*this, lst(diff_param));
1007         }
1008         switch (registered_functions()[serial].nparams) {
1009                 // the following lines have been generated for max. ${maxargs} parameters
1010 ${diff_switch_statement}
1011                 // end of generated lines
1012         }
1013         throw(std::logic_error("function::pderivative(): no diff function defined"));
1014 }
1015
1016 std::vector<function_options> & function::registered_functions(void)
1017 {
1018         static std::vector<function_options> * rf = new std::vector<function_options>;
1019         return *rf;
1020 }
1021
1022 bool function::lookup_remember_table(ex & result) const
1023 {
1024         return remember_table::remember_tables()[serial].lookup_entry(*this,result);
1025 }
1026
1027 void function::store_remember_table(ex const & result) const
1028 {
1029         remember_table::remember_tables()[serial].add_entry(*this,result);
1030 }
1031
1032 // public
1033
1034 unsigned function::register_new(function_options const & opt)
1035 {
1036         unsigned same_name=0;
1037         for (unsigned i=0; i<registered_functions().size(); ++i) {
1038                 if (registered_functions()[i].name==opt.name) {
1039                         same_name++;
1040                 }
1041         }
1042         if (same_name>=opt.functions_with_same_name) {
1043                 // we do not throw an exception here because this code is
1044                 // usually executed before main(), so the exception could not
1045                 // caught anyhow
1046                 std::cerr << "WARNING: function name " << opt.name
1047                                   << " already in use!" << std::endl;
1048         }
1049         registered_functions().push_back(opt);
1050         if (opt.use_remember) {
1051                 remember_table::remember_tables().
1052                         push_back(remember_table(opt.remember_size,
1053                                                                          opt.remember_assoc_size,
1054                                                                          opt.remember_strategy));
1055         } else {
1056                 remember_table::remember_tables().push_back(remember_table());
1057         }
1058         return registered_functions().size()-1;
1059 }
1060
1061 /** Find serial number of function by name and number of parameters.
1062  *  Throws exception if function was not found. */
1063 unsigned function::find_function(const std::string &name, unsigned nparams)
1064 {
1065         std::vector<function_options>::const_iterator i = function::registered_functions().begin(), end = function::registered_functions().end();
1066         unsigned serial = 0;
1067         while (i != end) {
1068                 if (i->get_name() == name && i->get_nparams() == nparams)
1069                         return serial;
1070                 i++;
1071                 serial++;
1072         }
1073         throw (std::runtime_error("no function '" + name + "' with " + ToString(nparams) + " parameters defined"));
1074 }
1075
1076 //////////
1077 // static member variables
1078 //////////
1079
1080 // none
1081
1082 //////////
1083 // global constants
1084 //////////
1085
1086 const function some_function;
1087 const type_info & typeid_function=typeid(some_function);
1088
1089 #ifndef NO_NAMESPACE_GINAC
1090 } // namespace GiNaC
1091 #endif // ndef NO_NAMESPACE_GINAC
1092
1093 END_OF_IMPLEMENTATION
1094
1095 print "Creating interface file function.h...";
1096 open OUT,">function.h" or die "cannot open function.h";
1097 print OUT $interface;
1098 close OUT;
1099 print "ok.\n";
1100
1101 print "Creating implementation file function.cpp...";
1102 open OUT,">function.cpp" or die "cannot open function.cpp";
1103 print OUT $implementation;
1104 close OUT;
1105 print "ok.\n";
1106
1107 print "done.\n";