ginac/function.cpp

   1 /** @file function.cpp
   2  *
   3  *  Implementation of class function.
   4  *
   5  *  This file was generated automatically by function.pl.
   6  *  Please do not modify it directly, edit the perl script instead!
   7  *  function.pl options: $maxargs=10
   8  *
   9  *  GiNaC Copyright (C) 1999 Johannes Gutenberg University Mainz, Germany
  10  *
  11  *  This program is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  This program is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License
  22  *  along with this program; if not, write to the Free Software
  23  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  24  */
  25
  26 #include <string>
  27 #include <stdexcept>
  28
  29 #include "ginac.h"
  30
  31 //////////
  32 // default constructor, destructor, copy constructor assignment operator and helpers
  33 //////////
  34
  35 // public
  36
  37 function::function() : serial(0)
  38 {
  39     debugmsg("function default constructor",LOGLEVEL_CONSTRUCT);
  40     tinfo_key = TINFO_FUNCTION;
  41 }
  42
  43 function::~function()
  44 {
  45     debugmsg("function destructor",LOGLEVEL_DESTRUCT);
  46     destroy(0);
  47 }
  48
  49 function::function(function const & other)
  50 {
  51     debugmsg("function copy constructor",LOGLEVEL_CONSTRUCT);
  52     copy(other);
  53 }
  54
  55 function const & function::operator=(function const & other)
  56 {
  57     debugmsg("function operator=",LOGLEVEL_ASSIGNMENT);
  58     if (this != &other) {
  59         destroy(1);
  60         copy(other);
  61     }
  62     return *this;
  63 }
  64
  65 // protected
  66
  67 void function::copy(function const & other)
  68 {
  69     exprseq::copy(other);
  70     serial=other.serial;
  71 }
  72
  73 void function::destroy(bool call_parent)
  74 {
  75     if (call_parent) exprseq::destroy(call_parent);
  76 }
  77
  78 //////////
  79 // other constructors
  80 //////////
  81
  82 // public
  83
  84 function::function(unsigned ser) : serial(ser)
  85 {
  86     debugmsg("function constructor from unsigned",LOGLEVEL_CONSTRUCT);
  87     tinfo_key = TINFO_FUNCTION;
  88 }
  89
  90 // the following lines have been generated for max. 10 parameters
  91 function::function(unsigned ser, ex const & param1)
  92     : exprseq(param1), serial(ser)
  93 {
  94     debugmsg("function constructor from unsigned,1*ex",LOGLEVEL_CONSTRUCT);
  95     tinfo_key = TINFO_FUNCTION;
  96 }
  97 function::function(unsigned ser, ex const & param1, ex const & param2)
  98     : exprseq(param1, param2), serial(ser)
  99 {
 100     debugmsg("function constructor from unsigned,2*ex",LOGLEVEL_CONSTRUCT);
 101     tinfo_key = TINFO_FUNCTION;
 102 }
 103 function::function(unsigned ser, ex const & param1, ex const & param2, ex const & param3)
 104     : exprseq(param1, param2, param3), serial(ser)
 105 {
 106     debugmsg("function constructor from unsigned,3*ex",LOGLEVEL_CONSTRUCT);
 107     tinfo_key = TINFO_FUNCTION;
 108 }
 109 function::function(unsigned ser, ex const & param1, ex const & param2, ex const & param3, ex const & param4)
 110     : exprseq(param1, param2, param3, param4), serial(ser)
 111 {
 112     debugmsg("function constructor from unsigned,4*ex",LOGLEVEL_CONSTRUCT);
 113     tinfo_key = TINFO_FUNCTION;
 114 }
 115 function::function(unsigned ser, ex const & param1, ex const & param2, ex const & param3, ex const & param4, ex const & param5)
 116     : exprseq(param1, param2, param3, param4, param5), serial(ser)
 117 {
 118     debugmsg("function constructor from unsigned,5*ex",LOGLEVEL_CONSTRUCT);
 119     tinfo_key = TINFO_FUNCTION;
 120 }
 121 function::function(unsigned ser, ex const & param1, ex const & param2, ex const & param3, ex const & param4, ex const & param5, ex const & param6)
 122     : exprseq(param1, param2, param3, param4, param5, param6), serial(ser)
 123 {
 124     debugmsg("function constructor from unsigned,6*ex",LOGLEVEL_CONSTRUCT);
 125     tinfo_key = TINFO_FUNCTION;
 126 }
 127 function::function(unsigned ser, ex const & param1, ex const & param2, ex const & param3, ex const & param4, ex const & param5, ex const & param6, ex const & param7)
 128     : exprseq(param1, param2, param3, param4, param5, param6, param7), serial(ser)
 129 {
 130     debugmsg("function constructor from unsigned,7*ex",LOGLEVEL_CONSTRUCT);
 131     tinfo_key = TINFO_FUNCTION;
 132 }
 133 function::function(unsigned ser, ex const & param1, ex const & param2, ex const & param3, ex const & param4, ex const & param5, ex const & param6, ex const & param7, ex const & param8)
 134     : exprseq(param1, param2, param3, param4, param5, param6, param7, param8), serial(ser)
 135 {
 136     debugmsg("function constructor from unsigned,8*ex",LOGLEVEL_CONSTRUCT);
 137     tinfo_key = TINFO_FUNCTION;
 138 }
 139 function::function(unsigned ser, ex const & param1, ex const & param2, ex const & param3, ex const & param4, ex const & param5, ex const & param6, ex const & param7, ex const & param8, ex const & param9)
 140     : exprseq(param1, param2, param3, param4, param5, param6, param7, param8, param9), serial(ser)
 141 {
 142     debugmsg("function constructor from unsigned,9*ex",LOGLEVEL_CONSTRUCT);
 143     tinfo_key = TINFO_FUNCTION;
 144 }
 145 function::function(unsigned ser, ex const & param1, ex const & param2, ex const & param3, ex const & param4, ex const & param5, ex const & param6, ex const & param7, ex const & param8, ex const & param9, ex const & param10)
 146     : exprseq(param1, param2, param3, param4, param5, param6, param7, param8, param9, param10), serial(ser)
 147 {
 148     debugmsg("function constructor from unsigned,10*ex",LOGLEVEL_CONSTRUCT);
 149     tinfo_key = TINFO_FUNCTION;
 150 }
 151
 152 // end of generated lines
 153
 154 function::function(unsigned ser, exprseq const & es) : exprseq(es), serial(ser)
 155 {
 156     debugmsg("function constructor from unsigned,exprseq",LOGLEVEL_CONSTRUCT);
 157     tinfo_key = TINFO_FUNCTION;
 158 }
 159
 160 function::function(unsigned ser, exvector const & v, bool discardable)
 161     : exprseq(v,discardable), serial(ser)
 162 {
 163     debugmsg("function constructor from string,exvector,bool",LOGLEVEL_CONSTRUCT);
 164     tinfo_key = TINFO_FUNCTION;
 165 }
 166
 167 function::function(unsigned ser, exvector * vp)
 168     : exprseq(vp), serial(ser)
 169 {
 170     debugmsg("function constructor from unsigned,exvector *",LOGLEVEL_CONSTRUCT);
 171     tinfo_key = TINFO_FUNCTION;
 172 }
 173
 174 //////////
 175 // functions overriding virtual functions from bases classes
 176 //////////
 177
 178 // public
 179
 180 basic * function::duplicate() const
 181 {
 182     debugmsg("function duplicate",LOGLEVEL_DUPLICATE);
 183     return new function(*this);
 184 }
 185
 186 void function::printraw(ostream & os) const
 187 {
 188     debugmsg("function printraw",LOGLEVEL_PRINT);
 189
 190     ASSERT(serial<registered_functions().size());
 191
 192     os << "function(name=" << registered_functions()[serial].name;
 193     for (exvector::const_iterator it=seq.begin(); it!=seq.end(); ++it) {
 194         os << ",";
 195         (*it).bp->print(os);
 196     }
 197     os << ")";
 198 }
 199
 200 void function::print(ostream & os, unsigned upper_precedence) const
 201 {
 202     debugmsg("function print",LOGLEVEL_PRINT);
 203
 204     ASSERT(serial<registered_functions().size());
 205
 206     os << registered_functions()[serial].name;
 207     printseq(os,'(',',',')',exprseq::precedence,function::precedence);
 208 }
 209
 210 void function::printtree(ostream & os, unsigned indent) const
 211 {
 212     debugmsg("function printtree",LOGLEVEL_PRINT);
 213
 214     ASSERT(serial<registered_functions().size());
 215
 216     os << string(indent,' ') << "function "
 217        << registered_functions()[serial].name
 218        << ", hash=" << hashvalue << " (0x" << hex << hashvalue << dec << ")"
 219        << ", flags=" << flags
 220        << ", nops=" << nops() << endl;
 221     for (int i=0; i<nops(); ++i) {
 222         seq[i].printtree(os,indent+delta_indent);
 223     }
 224     os << string(indent+delta_indent,' ') << "=====" << endl;
 225 }
 226
 227 void function::printcsrc(ostream & os, unsigned type, unsigned upper_precedence) const
 228 {
 229     debugmsg("function print csrc",LOGLEVEL_PRINT);
 230
 231     ASSERT(serial<registered_functions().size());
 232
 233         // Print function name in lowercase
 234     string lname;
 235     lname=registered_functions()[serial].name;
 236     for (unsigned i=0; i<lname.size(); i++)
 237         lname[i] = tolower(lname[i]);
 238     os << lname << "(";
 239
 240         // Print arguments, separated by commas
 241     exvector::const_iterator it = seq.begin();
 242     exvector::const_iterator itend = seq.end();
 243     while (it != itend) {
 244         it->bp->printcsrc(os, type, 0);
 245         it++;
 246         if (it != itend)
 247             os << ",";
 248     }
 249     os << ")";
 250 }
 251
 252 ex function::expand(unsigned options) const
 253 {
 254     return this->setflag(status_flags::expanded);
 255 }
 256
 257 ex function::eval(int level) const
 258 {
 259     ASSERT(serial<registered_functions().size());
 260
 261     exvector eseq=evalchildren(level);
 262
 263     if (registered_functions()[serial].e==0) {
 264         return function(serial,eseq).hold();
 265     }
 266     switch (registered_functions()[serial].nparams) {
 267         // the following lines have been generated for max. 10 parameters
 268     case 1:
 269         return ((eval_funcp_1)(registered_functions()[serial].e))(eseq[1-1]);
 270         break;
 271     case 2:
 272         return ((eval_funcp_2)(registered_functions()[serial].e))(eseq[1-1], eseq[2-1]);
 273         break;
 274     case 3:
 275         return ((eval_funcp_3)(registered_functions()[serial].e))(eseq[1-1], eseq[2-1], eseq[3-1]);
 276         break;
 277     case 4:
 278         return ((eval_funcp_4)(registered_functions()[serial].e))(eseq[1-1], eseq[2-1], eseq[3-1], eseq[4-1]);
 279         break;
 280     case 5:
 281         return ((eval_funcp_5)(registered_functions()[serial].e))(eseq[1-1], eseq[2-1], eseq[3-1], eseq[4-1], eseq[5-1]);
 282         break;
 283     case 6:
 284         return ((eval_funcp_6)(registered_functions()[serial].e))(eseq[1-1], eseq[2-1], eseq[3-1], eseq[4-1], eseq[5-1], eseq[6-1]);
 285         break;
 286     case 7:
 287         return ((eval_funcp_7)(registered_functions()[serial].e))(eseq[1-1], eseq[2-1], eseq[3-1], eseq[4-1], eseq[5-1], eseq[6-1], eseq[7-1]);
 288         break;
 289     case 8:
 290         return ((eval_funcp_8)(registered_functions()[serial].e))(eseq[1-1], eseq[2-1], eseq[3-1], eseq[4-1], eseq[5-1], eseq[6-1], eseq[7-1], eseq[8-1]);
 291         break;
 292     case 9:
 293         return ((eval_funcp_9)(registered_functions()[serial].e))(eseq[1-1], eseq[2-1], eseq[3-1], eseq[4-1], eseq[5-1], eseq[6-1], eseq[7-1], eseq[8-1], eseq[9-1]);
 294         break;
 295     case 10:
 296         return ((eval_funcp_10)(registered_functions()[serial].e))(eseq[1-1], eseq[2-1], eseq[3-1], eseq[4-1], eseq[5-1], eseq[6-1], eseq[7-1], eseq[8-1], eseq[9-1], eseq[10-1]);
 297         break;
 298
 299         // end of generated lines
 300     }
 301     throw(std::logic_error("function::eval(): invalid nparams"));
 302 }
 303
 304 ex function::evalf(int level) const
 305 {
 306     ASSERT(serial<registered_functions().size());
 307
 308     exvector eseq=evalfchildren(level);
 309
 310     if (registered_functions()[serial].ef==0) {
 311         return function(serial,eseq).hold();
 312     }
 313     switch (registered_functions()[serial].nparams) {
 314         // the following lines have been generated for max. 10 parameters
 315     case 1:
 316         return ((evalf_funcp_1)(registered_functions()[serial].ef))(eseq[1-1]);
 317         break;
 318     case 2:
 319         return ((evalf_funcp_2)(registered_functions()[serial].ef))(eseq[1-1], eseq[2-1]);
 320         break;
 321     case 3:
 322         return ((evalf_funcp_3)(registered_functions()[serial].ef))(eseq[1-1], eseq[2-1], eseq[3-1]);
 323         break;
 324     case 4:
 325         return ((evalf_funcp_4)(registered_functions()[serial].ef))(eseq[1-1], eseq[2-1], eseq[3-1], eseq[4-1]);
 326         break;
 327     case 5:
 328         return ((evalf_funcp_5)(registered_functions()[serial].ef))(eseq[1-1], eseq[2-1], eseq[3-1], eseq[4-1], eseq[5-1]);
 329         break;
 330     case 6:
 331         return ((evalf_funcp_6)(registered_functions()[serial].ef))(eseq[1-1], eseq[2-1], eseq[3-1], eseq[4-1], eseq[5-1], eseq[6-1]);
 332         break;
 333     case 7:
 334         return ((evalf_funcp_7)(registered_functions()[serial].ef))(eseq[1-1], eseq[2-1], eseq[3-1], eseq[4-1], eseq[5-1], eseq[6-1], eseq[7-1]);
 335         break;
 336     case 8:
 337         return ((evalf_funcp_8)(registered_functions()[serial].ef))(eseq[1-1], eseq[2-1], eseq[3-1], eseq[4-1], eseq[5-1], eseq[6-1], eseq[7-1], eseq[8-1]);
 338         break;
 339     case 9:
 340         return ((evalf_funcp_9)(registered_functions()[serial].ef))(eseq[1-1], eseq[2-1], eseq[3-1], eseq[4-1], eseq[5-1], eseq[6-1], eseq[7-1], eseq[8-1], eseq[9-1]);
 341         break;
 342     case 10:
 343         return ((evalf_funcp_10)(registered_functions()[serial].ef))(eseq[1-1], eseq[2-1], eseq[3-1], eseq[4-1], eseq[5-1], eseq[6-1], eseq[7-1], eseq[8-1], eseq[9-1], eseq[10-1]);
 344         break;
 345
 346         // end of generated lines
 347     }
 348     throw(std::logic_error("function::evalf(): invalid nparams"));
 349 }
 350
 351 ex function::thisexprseq(exvector const & v) const
 352 {
 353     return function(serial,v);
 354 }
 355
 356 ex function::thisexprseq(exvector * vp) const
 357 {
 358     return function(serial,vp);
 359 }
 360
 361 /** Implementation of ex::series for functions.
 362  *  @see ex::series */
 363 ex function::series(symbol const & s, ex const & point, int order) const
 364 {
 365     ASSERT(serial<registered_functions().size());
 366
 367     if (registered_functions()[serial].s==0) {
 368         return basic::series(s, point, order);
 369     }
 370     switch (registered_functions()[serial].nparams) {
 371         // the following lines have been generated for max. 10 parameters
 372     case 1:
 373         return ((series_funcp_1)(registered_functions()[serial].s))(seq[1-1],s,point,order);
 374         break;
 375     case 2:
 376         return ((series_funcp_2)(registered_functions()[serial].s))(seq[1-1], seq[2-1],s,point,order);
 377         break;
 378     case 3:
 379         return ((series_funcp_3)(registered_functions()[serial].s))(seq[1-1], seq[2-1], seq[3-1],s,point,order);
 380         break;
 381     case 4:
 382         return ((series_funcp_4)(registered_functions()[serial].s))(seq[1-1], seq[2-1], seq[3-1], seq[4-1],s,point,order);
 383         break;
 384     case 5:
 385         return ((series_funcp_5)(registered_functions()[serial].s))(seq[1-1], seq[2-1], seq[3-1], seq[4-1], seq[5-1],s,point,order);
 386         break;
 387     case 6:
 388         return ((series_funcp_6)(registered_functions()[serial].s))(seq[1-1], seq[2-1], seq[3-1], seq[4-1], seq[5-1], seq[6-1],s,point,order);
 389         break;
 390     case 7:
 391         return ((series_funcp_7)(registered_functions()[serial].s))(seq[1-1], seq[2-1], seq[3-1], seq[4-1], seq[5-1], seq[6-1], seq[7-1],s,point,order);
 392         break;
 393     case 8:
 394         return ((series_funcp_8)(registered_functions()[serial].s))(seq[1-1], seq[2-1], seq[3-1], seq[4-1], seq[5-1], seq[6-1], seq[7-1], seq[8-1],s,point,order);
 395         break;
 396     case 9:
 397         return ((series_funcp_9)(registered_functions()[serial].s))(seq[1-1], seq[2-1], seq[3-1], seq[4-1], seq[5-1], seq[6-1], seq[7-1], seq[8-1], seq[9-1],s,point,order);
 398         break;
 399     case 10:
 400         return ((series_funcp_10)(registered_functions()[serial].s))(seq[1-1], seq[2-1], seq[3-1], seq[4-1], seq[5-1], seq[6-1], seq[7-1], seq[8-1], seq[9-1], seq[10-1],s,point,order);
 401         break;
 402
 403         // end of generated lines
 404     }
 405     throw(std::logic_error("function::series(): invalid nparams"));
 406 }
 407
 408 // protected
 409
 410 int function::compare_same_type(basic const & other) const
 411 {
 412     ASSERT(is_of_type(other, function));
 413     function const & o=static_cast<function &>(const_cast<basic &>(other));
 414
 415     if (serial!=o.serial) {
 416         return serial < o.serial ? -1 : 1;
 417     }
 418     return exprseq::compare_same_type(o);
 419 }
 420
 421 bool function::is_equal_same_type(basic const & other) const
 422 {
 423     ASSERT(is_of_type(other, function));
 424     function const & o=static_cast<function &>(const_cast<basic &>(other));
 425
 426     if (serial!=o.serial) return false;
 427     return exprseq::is_equal_same_type(o);
 428 }
 429
 430 unsigned function::return_type(void) const
 431 {
 432     if (seq.size()==0) {
 433         return return_types::commutative;
 434     }
 435     return (*seq.begin()).return_type();
 436 }
 437
 438 unsigned function::return_type_tinfo(void) const
 439 {
 440     if (seq.size()==0) {
 441         return tinfo_key;
 442     }
 443     return (*seq.begin()).return_type_tinfo();
 444 }
 445
 446 //////////
 447 // new virtual functions which can be overridden by derived classes
 448 //////////
 449
 450 // none
 451
 452 //////////
 453 // non-virtual functions in this class
 454 //////////
 455
 456 // protected
 457
 458 ex function::pdiff(unsigned diff_param) const // partial differentiation
 459 {
 460     ASSERT(serial<registered_functions().size());
 461
 462     if (registered_functions()[serial].d==0) {
 463         throw(std::logic_error(string("function::pdiff(") + registered_functions()[serial].name + "): no diff function defined"));
 464     }
 465     switch (registered_functions()[serial].nparams) {
 466         // the following lines have been generated for max. 10 parameters
 467     case 1:
 468         return ((diff_funcp_1)(registered_functions()[serial].d))(seq[1-1],diff_param);
 469         break;
 470     case 2:
 471         return ((diff_funcp_2)(registered_functions()[serial].d))(seq[1-1], seq[2-1],diff_param);
 472         break;
 473     case 3:
 474         return ((diff_funcp_3)(registered_functions()[serial].d))(seq[1-1], seq[2-1], seq[3-1],diff_param);
 475         break;
 476     case 4:
 477         return ((diff_funcp_4)(registered_functions()[serial].d))(seq[1-1], seq[2-1], seq[3-1], seq[4-1],diff_param);
 478         break;
 479     case 5:
 480         return ((diff_funcp_5)(registered_functions()[serial].d))(seq[1-1], seq[2-1], seq[3-1], seq[4-1], seq[5-1],diff_param);
 481         break;
 482     case 6:
 483         return ((diff_funcp_6)(registered_functions()[serial].d))(seq[1-1], seq[2-1], seq[3-1], seq[4-1], seq[5-1], seq[6-1],diff_param);
 484         break;
 485     case 7:
 486         return ((diff_funcp_7)(registered_functions()[serial].d))(seq[1-1], seq[2-1], seq[3-1], seq[4-1], seq[5-1], seq[6-1], seq[7-1],diff_param);
 487         break;
 488     case 8:
 489         return ((diff_funcp_8)(registered_functions()[serial].d))(seq[1-1], seq[2-1], seq[3-1], seq[4-1], seq[5-1], seq[6-1], seq[7-1], seq[8-1],diff_param);
 490         break;
 491     case 9:
 492         return ((diff_funcp_9)(registered_functions()[serial].d))(seq[1-1], seq[2-1], seq[3-1], seq[4-1], seq[5-1], seq[6-1], seq[7-1], seq[8-1], seq[9-1],diff_param);
 493         break;
 494     case 10:
 495         return ((diff_funcp_10)(registered_functions()[serial].d))(seq[1-1], seq[2-1], seq[3-1], seq[4-1], seq[5-1], seq[6-1], seq[7-1], seq[8-1], seq[9-1], seq[10-1],diff_param);
 496         break;
 497
 498         // end of generated lines
 499     }
 500     throw(std::logic_error("function::pdiff(): no diff function defined"));
 501 }
 502
 503 vector<registered_function_info> & function::registered_functions(void)
 504 {
 505     static vector<registered_function_info> * rf=new vector<registered_function_info>;
 506     return *rf;
 507 }
 508
 509 // public
 510
 511 // the following lines have been generated for max. 10 parameters
 512 unsigned function::register_new(char const * nm, eval_funcp_1 e,
 513                                  evalf_funcp_1 ef, diff_funcp_1 d, series_funcp_1 s)
 514 {
 515     registered_function_info rfi={nm,1,0,eval_funcp(e),
 516                                   evalf_funcp(ef),diff_funcp(d),series_funcp(s)};
 517     registered_functions().push_back(rfi);
 518     return registered_functions().size()-1;
 519 }
 520 unsigned function::register_new(char const * nm, eval_funcp_2 e,
 521                                  evalf_funcp_2 ef, diff_funcp_2 d, series_funcp_2 s)
 522 {
 523     registered_function_info rfi={nm,2,0,eval_funcp(e),
 524                                   evalf_funcp(ef),diff_funcp(d),series_funcp(s)};
 525     registered_functions().push_back(rfi);
 526     return registered_functions().size()-1;
 527 }
 528 unsigned function::register_new(char const * nm, eval_funcp_3 e,
 529                                  evalf_funcp_3 ef, diff_funcp_3 d, series_funcp_3 s)
 530 {
 531     registered_function_info rfi={nm,3,0,eval_funcp(e),
 532                                   evalf_funcp(ef),diff_funcp(d),series_funcp(s)};
 533     registered_functions().push_back(rfi);
 534     return registered_functions().size()-1;
 535 }
 536 unsigned function::register_new(char const * nm, eval_funcp_4 e,
 537                                  evalf_funcp_4 ef, diff_funcp_4 d, series_funcp_4 s)
 538 {
 539     registered_function_info rfi={nm,4,0,eval_funcp(e),
 540                                   evalf_funcp(ef),diff_funcp(d),series_funcp(s)};
 541     registered_functions().push_back(rfi);
 542     return registered_functions().size()-1;
 543 }
 544 unsigned function::register_new(char const * nm, eval_funcp_5 e,
 545                                  evalf_funcp_5 ef, diff_funcp_5 d, series_funcp_5 s)
 546 {
 547     registered_function_info rfi={nm,5,0,eval_funcp(e),
 548                                   evalf_funcp(ef),diff_funcp(d),series_funcp(s)};
 549     registered_functions().push_back(rfi);
 550     return registered_functions().size()-1;
 551 }
 552 unsigned function::register_new(char const * nm, eval_funcp_6 e,
 553                                  evalf_funcp_6 ef, diff_funcp_6 d, series_funcp_6 s)
 554 {
 555     registered_function_info rfi={nm,6,0,eval_funcp(e),
 556                                   evalf_funcp(ef),diff_funcp(d),series_funcp(s)};
 557     registered_functions().push_back(rfi);
 558     return registered_functions().size()-1;
 559 }
 560 unsigned function::register_new(char const * nm, eval_funcp_7 e,
 561                                  evalf_funcp_7 ef, diff_funcp_7 d, series_funcp_7 s)
 562 {
 563     registered_function_info rfi={nm,7,0,eval_funcp(e),
 564                                   evalf_funcp(ef),diff_funcp(d),series_funcp(s)};
 565     registered_functions().push_back(rfi);
 566     return registered_functions().size()-1;
 567 }
 568 unsigned function::register_new(char const * nm, eval_funcp_8 e,
 569                                  evalf_funcp_8 ef, diff_funcp_8 d, series_funcp_8 s)
 570 {
 571     registered_function_info rfi={nm,8,0,eval_funcp(e),
 572                                   evalf_funcp(ef),diff_funcp(d),series_funcp(s)};
 573     registered_functions().push_back(rfi);
 574     return registered_functions().size()-1;
 575 }
 576 unsigned function::register_new(char const * nm, eval_funcp_9 e,
 577                                  evalf_funcp_9 ef, diff_funcp_9 d, series_funcp_9 s)
 578 {
 579     registered_function_info rfi={nm,9,0,eval_funcp(e),
 580                                   evalf_funcp(ef),diff_funcp(d),series_funcp(s)};
 581     registered_functions().push_back(rfi);
 582     return registered_functions().size()-1;
 583 }
 584 unsigned function::register_new(char const * nm, eval_funcp_10 e,
 585                                  evalf_funcp_10 ef, diff_funcp_10 d, series_funcp_10 s)
 586 {
 587     registered_function_info rfi={nm,10,0,eval_funcp(e),
 588                                   evalf_funcp(ef),diff_funcp(d),series_funcp(s)};
 589     registered_functions().push_back(rfi);
 590     return registered_functions().size()-1;
 591 }
 592
 593 // end of generated lines
 594
 595 //////////
 596 // static member variables
 597 //////////
 598
 599 // none
 600
 601 //////////
 602 // global constants
 603 //////////
 604
 605 const function some_function;
 606 type_info const & typeid_function=typeid(some_function);
 607