- modified the comment blocks so the copyright message no longer appears in
[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 /*
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