- ASSERT macro renamed to GINAC_ASSERT
[ginac.git] / 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     GINAC_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     GINAC_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     GINAC_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     GINAC_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     GINAC_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     GINAC_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     GINAC_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     GINAC_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     GINAC_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     GINAC_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