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