#ifndef around namespace GiNaC { }
[ginac.git] / ginac / inifcns_trans.cpp
1 /** @file inifcns_trans.cpp
2  *
3  *  Implementation of transcendental (and trigonometric and hyperbolic)
4  *  functions. */
5
6 /*
7  *  GiNaC Copyright (C) 1999 Johannes Gutenberg University Mainz, Germany
8  *
9  *  This program is free software; you can redistribute it and/or modify
10  *  it under the terms of the GNU General Public License as published by
11  *  the Free Software Foundation; either version 2 of the License, or
12  *  (at your option) any later version.
13  *
14  *  This program is distributed in the hope that it will be useful,
15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  *  GNU General Public License for more details.
18  *
19  *  You should have received a copy of the GNU General Public License
20  *  along with this program; if not, write to the Free Software
21  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
22  */
23
24 #include <vector>
25 #include <stdexcept>
26
27 #include "inifcns.h"
28 #include "ex.h"
29 #include "constant.h"
30 #include "numeric.h"
31 #include "power.h"
32
33 #ifndef NO_GINAC_NAMESPACE
34 namespace GiNaC {
35 #endif // ndef NO_GINAC_NAMESPACE
36
37 //////////
38 // exponential function
39 //////////
40
41 static ex exp_evalf(ex const & x)
42 {
43     BEGIN_TYPECHECK
44         TYPECHECK(x,numeric)
45     END_TYPECHECK(exp(x))
46     
47     return exp(ex_to_numeric(x)); // -> numeric exp(numeric)
48 }
49
50 static ex exp_eval(ex const & x)
51 {
52     // exp(0) -> 1
53     if (x.is_zero()) {
54         return exONE();
55     }
56     // exp(n*Pi*I/2) -> {+1|+I|-1|-I}
57     ex TwoExOverPiI=(2*x)/(Pi*I);
58     if (TwoExOverPiI.info(info_flags::integer)) {
59         numeric z=mod(ex_to_numeric(TwoExOverPiI),numeric(4));
60         if (z.is_equal(numZERO()))
61             return exONE();
62         if (z.is_equal(numONE()))
63             return ex(I);
64         if (z.is_equal(numTWO()))
65             return exMINUSONE();
66         if (z.is_equal(numTHREE()))
67             return ex(-I);
68     }
69     // exp(log(x)) -> x
70     if (is_ex_the_function(x, log))
71         return x.op(0);
72     
73     // exp(float)
74     if (x.info(info_flags::numeric) && !x.info(info_flags::rational))
75         return exp_evalf(x);
76     
77     return exp(x).hold();
78 }    
79
80 static ex exp_diff(ex const & x, unsigned diff_param)
81 {
82     GINAC_ASSERT(diff_param==0);
83
84     return exp(x);
85 }
86
87 REGISTER_FUNCTION(exp, exp_eval, exp_evalf, exp_diff, NULL);
88
89 //////////
90 // natural logarithm
91 //////////
92
93 static ex log_evalf(ex const & x)
94 {
95     BEGIN_TYPECHECK
96         TYPECHECK(x,numeric)
97     END_TYPECHECK(log(x))
98     
99     return log(ex_to_numeric(x)); // -> numeric log(numeric)
100 }
101
102 static ex log_eval(ex const & x)
103 {
104     if (x.info(info_flags::numeric)) {
105         // log(1) -> 0
106         if (x.is_equal(exONE()))
107             return exZERO();
108         // log(-1) -> I*Pi
109         if (x.is_equal(exMINUSONE()))
110             return (I*Pi);
111         // log(I) -> Pi*I/2
112         if (x.is_equal(I))
113             return (I*Pi*numeric(1,2));
114         // log(-I) -> -Pi*I/2
115         if (x.is_equal(-I))
116             return (I*Pi*numeric(-1,2));
117         // log(0) -> throw singularity
118         if (x.is_equal(exZERO()))
119             throw(std::domain_error("log_eval(): log(0)"));
120         // log(float)
121         if (!x.info(info_flags::rational))
122             return log_evalf(x);
123     }
124     
125     return log(x).hold();
126 }    
127
128 static ex log_diff(ex const & x, unsigned diff_param)
129 {
130     GINAC_ASSERT(diff_param==0);
131
132     return power(x, -1);
133 }
134
135 REGISTER_FUNCTION(log, log_eval, log_evalf, log_diff, NULL);
136
137 //////////
138 // sine (trigonometric function)
139 //////////
140
141 static ex sin_evalf(ex const & x)
142 {
143     BEGIN_TYPECHECK
144        TYPECHECK(x,numeric)
145     END_TYPECHECK(sin(x))
146     
147     return sin(ex_to_numeric(x)); // -> numeric sin(numeric)
148 }
149
150 static ex sin_eval(ex const & x)
151 {
152     // sin(n*Pi) -> 0
153     ex xOverPi=x/Pi;
154     if (xOverPi.info(info_flags::integer))
155         return exZERO();
156     
157     // sin((2n+1)*Pi/2) -> {+|-}1
158     ex xOverPiMinusHalf=xOverPi-exHALF();
159     if (xOverPiMinusHalf.info(info_flags::even))
160         return exONE();
161     else if (xOverPiMinusHalf.info(info_flags::odd))
162         return exMINUSONE();
163     
164     if (is_ex_exactly_of_type(x, function)) {
165         ex t=x.op(0);
166         // sin(asin(x)) -> x
167         if (is_ex_the_function(x, asin))
168             return t;
169         // sin(acos(x)) -> (1-x^2)^(1/2)
170         if (is_ex_the_function(x, acos))
171             return power(exONE()-power(t,exTWO()),exHALF());
172         // sin(atan(x)) -> x*(1+x^2)^(-1/2)
173         if (is_ex_the_function(x, atan))
174             return t*power(exONE()+power(t,exTWO()),exMINUSHALF());
175     }
176     
177     // sin(float) -> float
178     if (x.info(info_flags::numeric) && !x.info(info_flags::rational))
179         return sin_evalf(x);
180     
181     return sin(x).hold();
182 }
183
184 static ex sin_diff(ex const & x, unsigned diff_param)
185 {
186     GINAC_ASSERT(diff_param==0);
187     
188     return cos(x);
189 }
190
191 REGISTER_FUNCTION(sin, sin_eval, sin_evalf, sin_diff, NULL);
192
193 //////////
194 // cosine (trigonometric function)
195 //////////
196
197 static ex cos_evalf(ex const & x)
198 {
199     BEGIN_TYPECHECK
200         TYPECHECK(x,numeric)
201     END_TYPECHECK(cos(x))
202     
203     return cos(ex_to_numeric(x)); // -> numeric cos(numeric)
204 }
205
206 static ex cos_eval(ex const & x)
207 {
208     // cos(n*Pi) -> {+|-}1
209     ex xOverPi=x/Pi;
210     if (xOverPi.info(info_flags::even))
211         return exONE();
212     else if (xOverPi.info(info_flags::odd))
213         return exMINUSONE();
214     
215     // cos((2n+1)*Pi/2) -> 0
216     ex xOverPiMinusHalf=xOverPi-exHALF();
217     if (xOverPiMinusHalf.info(info_flags::integer))
218         return exZERO();
219     
220     if (is_ex_exactly_of_type(x, function)) {
221         ex t=x.op(0);
222         // cos(acos(x)) -> x
223         if (is_ex_the_function(x, acos))
224             return t;
225         // cos(asin(x)) -> (1-x^2)^(1/2)
226         if (is_ex_the_function(x, asin))
227             return power(exONE()-power(t,exTWO()),exHALF());
228         // cos(atan(x)) -> (1+x^2)^(-1/2)
229         if (is_ex_the_function(x, atan))
230             return power(exONE()+power(t,exTWO()),exMINUSHALF());
231     }
232     
233     // cos(float) -> float
234     if (x.info(info_flags::numeric) && !x.info(info_flags::rational))
235         return cos_evalf(x);
236     
237     return cos(x).hold();
238 }
239
240 static ex cos_diff(ex const & x, unsigned diff_param)
241 {
242     GINAC_ASSERT(diff_param==0);
243
244     return numMINUSONE()*sin(x);
245 }
246
247 REGISTER_FUNCTION(cos, cos_eval, cos_evalf, cos_diff, NULL);
248
249 //////////
250 // tangent (trigonometric function)
251 //////////
252
253 static ex tan_evalf(ex const & x)
254 {
255     BEGIN_TYPECHECK
256        TYPECHECK(x,numeric)
257     END_TYPECHECK(tan(x)) // -> numeric tan(numeric)
258     
259     return tan(ex_to_numeric(x));
260 }
261
262 static ex tan_eval(ex const & x)
263 {
264     // tan(n*Pi/3) -> {0|3^(1/2)|-(3^(1/2))}
265     ex ThreeExOverPi=numTHREE()*x/Pi;
266     if (ThreeExOverPi.info(info_flags::integer)) {
267         numeric z=mod(ex_to_numeric(ThreeExOverPi),numeric(3));
268         if (z.is_equal(numZERO()))
269             return exZERO();
270         if (z.is_equal(numONE()))
271             return power(exTHREE(),exHALF());
272         if (z.is_equal(numTWO()))
273             return -power(exTHREE(),exHALF());
274     }
275     
276     // tan((2n+1)*Pi/2) -> throw
277     ex ExOverPiMinusHalf=x/Pi-exHALF();
278     if (ExOverPiMinusHalf.info(info_flags::integer))
279         throw (std::domain_error("tan_eval(): infinity"));
280     
281     if (is_ex_exactly_of_type(x, function)) {
282         ex t=x.op(0);
283         // tan(atan(x)) -> x
284         if (is_ex_the_function(x, atan))
285             return t;
286         // tan(asin(x)) -> x*(1+x^2)^(-1/2)
287         if (is_ex_the_function(x, asin))
288             return t*power(exONE()-power(t,exTWO()),exMINUSHALF());
289         // tan(acos(x)) -> (1-x^2)^(1/2)/x
290         if (is_ex_the_function(x, acos))
291             return power(t,exMINUSONE())*power(exONE()-power(t,exTWO()),exHALF());
292     }
293     
294     // tan(float) -> float
295     if (x.info(info_flags::numeric) && !x.info(info_flags::rational)) {
296         return tan_evalf(x);
297     }
298     
299     return tan(x).hold();
300 }
301
302 static ex tan_diff(ex const & x, unsigned diff_param)
303 {
304     GINAC_ASSERT(diff_param==0);
305     
306     return (1+power(tan(x),exTWO()));
307 }
308
309 REGISTER_FUNCTION(tan, tan_eval, tan_evalf, tan_diff, NULL);
310
311 //////////
312 // inverse sine (arc sine)
313 //////////
314
315 static ex asin_evalf(ex const & x)
316 {
317     BEGIN_TYPECHECK
318        TYPECHECK(x,numeric)
319     END_TYPECHECK(asin(x))
320     
321     return asin(ex_to_numeric(x)); // -> numeric asin(numeric)
322 }
323
324 static ex asin_eval(ex const & x)
325 {
326     if (x.info(info_flags::numeric)) {
327         // asin(0) -> 0
328         if (x.is_zero())
329             return x;
330         // asin(1/2) -> Pi/6
331         if (x.is_equal(exHALF()))
332             return numeric(1,6)*Pi;
333         // asin(1) -> Pi/2
334         if (x.is_equal(exONE()))
335             return numeric(1,2)*Pi;
336         // asin(-1/2) -> -Pi/6
337         if (x.is_equal(exMINUSHALF()))
338             return numeric(-1,6)*Pi;
339         // asin(-1) -> -Pi/2
340         if (x.is_equal(exMINUSONE()))
341             return numeric(-1,2)*Pi;
342         // asin(float) -> float
343         if (!x.info(info_flags::rational))
344             return asin_evalf(x);
345     }
346     
347     return asin(x).hold();
348 }
349
350 static ex asin_diff(ex const & x, unsigned diff_param)
351 {
352     GINAC_ASSERT(diff_param==0);
353     
354     return power(1-power(x,exTWO()),exMINUSHALF());
355 }
356
357 REGISTER_FUNCTION(asin, asin_eval, asin_evalf, asin_diff, NULL);
358
359 //////////
360 // inverse cosine (arc cosine)
361 //////////
362
363 static ex acos_evalf(ex const & x)
364 {
365     BEGIN_TYPECHECK
366        TYPECHECK(x,numeric)
367     END_TYPECHECK(acos(x))
368     
369     return acos(ex_to_numeric(x)); // -> numeric acos(numeric)
370 }
371
372 static ex acos_eval(ex const & x)
373 {
374     if (x.info(info_flags::numeric)) {
375         // acos(1) -> 0
376         if (x.is_equal(exONE()))
377             return exZERO();
378         // acos(1/2) -> Pi/3
379         if (x.is_equal(exHALF()))
380             return numeric(1,3)*Pi;
381         // acos(0) -> Pi/2
382         if (x.is_zero())
383             return numeric(1,2)*Pi;
384         // acos(-1/2) -> 2/3*Pi
385         if (x.is_equal(exMINUSHALF()))
386             return numeric(2,3)*Pi;
387         // acos(-1) -> Pi
388         if (x.is_equal(exMINUSONE()))
389             return Pi;
390         // acos(float) -> float
391         if (!x.info(info_flags::rational))
392             return acos_evalf(x);
393     }
394     
395     return acos(x).hold();
396 }
397
398 static ex acos_diff(ex const & x, unsigned diff_param)
399 {
400     GINAC_ASSERT(diff_param==0);
401     
402     return numMINUSONE()*power(1-power(x,exTWO()),exMINUSHALF());
403 }
404
405 REGISTER_FUNCTION(acos, acos_eval, acos_evalf, acos_diff, NULL);
406
407 //////////
408 // inverse tangent (arc tangent)
409 //////////
410
411 static ex atan_evalf(ex const & x)
412 {
413     BEGIN_TYPECHECK
414         TYPECHECK(x,numeric)
415     END_TYPECHECK(atan(x))
416     
417     return atan(ex_to_numeric(x)); // -> numeric atan(numeric)
418 }
419
420 static ex atan_eval(ex const & x)
421 {
422     if (x.info(info_flags::numeric)) {
423         // atan(0) -> 0
424         if (x.is_equal(exZERO()))
425             return exZERO();
426         // atan(float) -> float
427         if (!x.info(info_flags::rational))
428             return atan_evalf(x);
429     }
430     
431     return atan(x).hold();
432 }    
433
434 static ex atan_diff(ex const & x, unsigned diff_param)
435 {
436     GINAC_ASSERT(diff_param==0);
437
438     return power(1+x*x, -1);
439 }
440
441 REGISTER_FUNCTION(atan, atan_eval, atan_evalf, atan_diff, NULL);
442
443 //////////
444 // inverse tangent (atan2(y,x))
445 //////////
446
447 static ex atan2_evalf(ex const & y, ex const & x)
448 {
449     BEGIN_TYPECHECK
450         TYPECHECK(y,numeric)
451         TYPECHECK(x,numeric)
452     END_TYPECHECK(atan2(y,x))
453     
454     return atan(ex_to_numeric(y),ex_to_numeric(x)); // -> numeric atan(numeric)
455 }
456
457 static ex atan2_eval(ex const & y, ex const & x)
458 {
459     if (y.info(info_flags::numeric) && !y.info(info_flags::rational) &&
460         x.info(info_flags::numeric) && !x.info(info_flags::rational)) {
461         return atan2_evalf(y,x);
462     }
463     
464     return atan2(y,x).hold();
465 }    
466
467 static ex atan2_diff(ex const & y, ex const & x, unsigned diff_param)
468 {
469     GINAC_ASSERT(diff_param<2);
470     
471     if (diff_param==0) {
472         // d/dy atan(y,x)
473         return x*pow(pow(x,2)+pow(y,2),-1);
474     }
475     // d/dx atan(y,x)
476     return -y*pow(pow(x,2)+pow(y,2),-1);
477 }
478
479 REGISTER_FUNCTION(atan2, atan2_eval, atan2_evalf, atan2_diff, NULL);
480
481 //////////
482 // hyperbolic sine (trigonometric function)
483 //////////
484
485 static ex sinh_evalf(ex const & x)
486 {
487     BEGIN_TYPECHECK
488        TYPECHECK(x,numeric)
489     END_TYPECHECK(sinh(x))
490     
491     return sinh(ex_to_numeric(x)); // -> numeric sinh(numeric)
492 }
493
494 static ex sinh_eval(ex const & x)
495 {
496     if (x.info(info_flags::numeric)) {
497         // sinh(0) -> 0
498         if (x.is_zero())
499             return exZERO();
500         // sinh(float) -> float
501         if (!x.info(info_flags::rational))
502             return sinh_evalf(x);
503     }
504     
505     if (is_ex_exactly_of_type(x, function)) {
506         ex t=x.op(0);
507         // sinh(asinh(x)) -> x
508         if (is_ex_the_function(x, asinh))
509             return t;
510         // sinh(acosh(x)) -> (x-1)^(1/2) * (x+1)^(1/2)
511         if (is_ex_the_function(x, acosh))
512             return power(t-exONE(),exHALF())*power(t+exONE(),exHALF());
513         // sinh(atanh(x)) -> x*(1-x^2)^(-1/2)
514         if (is_ex_the_function(x, atanh))
515             return t*power(exONE()-power(t,exTWO()),exMINUSHALF());
516     }
517     
518     return sinh(x).hold();
519 }
520
521 static ex sinh_diff(ex const & x, unsigned diff_param)
522 {
523     GINAC_ASSERT(diff_param==0);
524     
525     return cosh(x);
526 }
527
528 REGISTER_FUNCTION(sinh, sinh_eval, sinh_evalf, sinh_diff, NULL);
529
530 //////////
531 // hyperbolic cosine (trigonometric function)
532 //////////
533
534 static ex cosh_evalf(ex const & x)
535 {
536     BEGIN_TYPECHECK
537        TYPECHECK(x,numeric)
538     END_TYPECHECK(cosh(x))
539     
540     return cosh(ex_to_numeric(x)); // -> numeric cosh(numeric)
541 }
542
543 static ex cosh_eval(ex const & x)
544 {
545     if (x.info(info_flags::numeric)) {
546         // cosh(0) -> 1
547         if (x.is_zero())
548             return exONE();
549         // cosh(float) -> float
550         if (!x.info(info_flags::rational))
551             return cosh_evalf(x);
552     }
553     
554     if (is_ex_exactly_of_type(x, function)) {
555         ex t=x.op(0);
556         // cosh(acosh(x)) -> x
557         if (is_ex_the_function(x, acosh))
558             return t;
559         // cosh(asinh(x)) -> (1+x^2)^(1/2)
560         if (is_ex_the_function(x, asinh))
561             return power(exONE()+power(t,exTWO()),exHALF());
562         // cosh(atanh(x)) -> (1-x^2)^(-1/2)
563         if (is_ex_the_function(x, atanh))
564             return power(exONE()-power(t,exTWO()),exMINUSHALF());
565     }
566     
567     return cosh(x).hold();
568 }
569
570 static ex cosh_diff(ex const & x, unsigned diff_param)
571 {
572     GINAC_ASSERT(diff_param==0);
573     
574     return sinh(x);
575 }
576
577 REGISTER_FUNCTION(cosh, cosh_eval, cosh_evalf, cosh_diff, NULL);
578
579 //////////
580 // hyperbolic tangent (trigonometric function)
581 //////////
582
583 static ex tanh_evalf(ex const & x)
584 {
585     BEGIN_TYPECHECK
586        TYPECHECK(x,numeric)
587     END_TYPECHECK(tanh(x))
588     
589     return tanh(ex_to_numeric(x)); // -> numeric tanh(numeric)
590 }
591
592 static ex tanh_eval(ex const & x)
593 {
594     if (x.info(info_flags::numeric)) {
595         // tanh(0) -> 0
596         if (x.is_zero())
597             return exZERO();
598         // tanh(float) -> float
599         if (!x.info(info_flags::rational))
600             return tanh_evalf(x);
601     }
602     
603     if (is_ex_exactly_of_type(x, function)) {
604         ex t=x.op(0);
605         // tanh(atanh(x)) -> x
606         if (is_ex_the_function(x, atanh))
607             return t;
608         // tanh(asinh(x)) -> x*(1+x^2)^(-1/2)
609         if (is_ex_the_function(x, asinh))
610             return t*power(exONE()+power(t,exTWO()),exMINUSHALF());
611         // tanh(acosh(x)) -> (x-1)^(1/2)*(x+1)^(1/2)/x
612         if (is_ex_the_function(x, acosh))
613             return power(t-exONE(),exHALF())*power(t+exONE(),exHALF())*power(t,exMINUSONE());
614     }
615     
616     return tanh(x).hold();
617 }
618
619 static ex tanh_diff(ex const & x, unsigned diff_param)
620 {
621     GINAC_ASSERT(diff_param==0);
622     
623     return exONE()-power(tanh(x),exTWO());
624 }
625
626 REGISTER_FUNCTION(tanh, tanh_eval, tanh_evalf, tanh_diff, NULL);
627
628 //////////
629 // inverse hyperbolic sine (trigonometric function)
630 //////////
631
632 static ex asinh_evalf(ex const & x)
633 {
634     BEGIN_TYPECHECK
635        TYPECHECK(x,numeric)
636     END_TYPECHECK(asinh(x))
637     
638     return asinh(ex_to_numeric(x)); // -> numeric asinh(numeric)
639 }
640
641 static ex asinh_eval(ex const & x)
642 {
643     if (x.info(info_flags::numeric)) {
644         // asinh(0) -> 0
645         if (x.is_zero())
646             return exZERO();
647         // asinh(float) -> float
648         if (!x.info(info_flags::rational))
649             return asinh_evalf(x);
650     }
651     
652     return asinh(x).hold();
653 }
654
655 static ex asinh_diff(ex const & x, unsigned diff_param)
656 {
657     GINAC_ASSERT(diff_param==0);
658     
659     return power(1+power(x,exTWO()),exMINUSHALF());
660 }
661
662 REGISTER_FUNCTION(asinh, asinh_eval, asinh_evalf, asinh_diff, NULL);
663
664 //////////
665 // inverse hyperbolic cosine (trigonometric function)
666 //////////
667
668 static ex acosh_evalf(ex const & x)
669 {
670     BEGIN_TYPECHECK
671        TYPECHECK(x,numeric)
672     END_TYPECHECK(acosh(x))
673     
674     return acosh(ex_to_numeric(x)); // -> numeric acosh(numeric)
675 }
676
677 static ex acosh_eval(ex const & x)
678 {
679     if (x.info(info_flags::numeric)) {
680         // acosh(0) -> Pi*I/2
681         if (x.is_zero())
682             return Pi*I*numeric(1,2);
683         // acosh(1) -> 0
684         if (x.is_equal(exONE()))
685             return exZERO();
686         // acosh(-1) -> Pi*I
687         if (x.is_equal(exMINUSONE()))
688             return Pi*I;
689         // acosh(float) -> float
690         if (!x.info(info_flags::rational))
691             return acosh_evalf(x);
692     }
693     
694     return acosh(x).hold();
695 }
696
697 static ex acosh_diff(ex const & x, unsigned diff_param)
698 {
699     GINAC_ASSERT(diff_param==0);
700     
701     return power(x-1,exMINUSHALF())*power(x+1,exMINUSHALF());
702 }
703
704 REGISTER_FUNCTION(acosh, acosh_eval, acosh_evalf, acosh_diff, NULL);
705
706 //////////
707 // inverse hyperbolic tangent (trigonometric function)
708 //////////
709
710 static ex atanh_evalf(ex const & x)
711 {
712     BEGIN_TYPECHECK
713        TYPECHECK(x,numeric)
714     END_TYPECHECK(atanh(x))
715     
716     return atanh(ex_to_numeric(x)); // -> numeric atanh(numeric)
717 }
718
719 static ex atanh_eval(ex const & x)
720 {
721     if (x.info(info_flags::numeric)) {
722         // atanh(0) -> 0
723         if (x.is_zero())
724             return exZERO();
725         // atanh({+|-}1) -> throw
726         if (x.is_equal(exONE()) || x.is_equal(exONE()))
727             throw (std::domain_error("atanh_eval(): infinity"));
728         // atanh(float) -> float
729         if (!x.info(info_flags::rational))
730             return atanh_evalf(x);
731     }
732     
733     return atanh(x).hold();
734 }
735
736 static ex atanh_diff(ex const & x, unsigned diff_param)
737 {
738     GINAC_ASSERT(diff_param==0);
739     
740     return power(exONE()-power(x,exTWO()),exMINUSONE());
741 }
742
743 REGISTER_FUNCTION(atanh, atanh_eval, atanh_evalf, atanh_diff, NULL);
744
745 #ifndef NO_GINAC_NAMESPACE
746 } // namespace GiNaC
747 #endif // ndef NO_GINAC_NAMESPACE