0afb41ebe03b728427542c20795e2744c78f2c3f
[ginac.git] / 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