ginac/function.cpp

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