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