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