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