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