268041325aebd1ce11cdff7e40bcfe5871e8df0a
[ginac.git] / ginac / pseries.cpp
1 /** @file pseries.cpp
2  *
3  *  Implementation of class for extended truncated power series and
4  *  methods for series expansion. */
5
6 /*
7  *  GiNaC Copyright (C) 1999-2000 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 <stdexcept>
25
26 #include "pseries.h"
27 #include "add.h"
28 #include "inifcns.h"
29 #include "lst.h"
30 #include "mul.h"
31 #include "power.h"
32 #include "relational.h"
33 #include "symbol.h"
34 #include "archive.h"
35 #include "utils.h"
36 #include "debugmsg.h"
37
38 #ifndef NO_NAMESPACE_GINAC
39 namespace GiNaC {
40 #endif // ndef NO_NAMESPACE_GINAC
41
42 GINAC_IMPLEMENT_REGISTERED_CLASS(pseries, basic)
43
44 /*
45  *  Default constructor, destructor, copy constructor, assignment operator and helpers
46  */
47
48 pseries::pseries() : basic(TINFO_pseries)
49 {
50     debugmsg("pseries default constructor", LOGLEVEL_CONSTRUCT);
51 }
52
53 pseries::~pseries()
54 {
55     debugmsg("pseries destructor", LOGLEVEL_DESTRUCT);
56     destroy(false);
57 }
58
59 pseries::pseries(const pseries &other)
60 {
61     debugmsg("pseries copy constructor", LOGLEVEL_CONSTRUCT);
62     copy(other);
63 }
64
65 const pseries &pseries::operator=(const pseries & other)
66 {
67     debugmsg("pseries operator=", LOGLEVEL_ASSIGNMENT);
68     if (this != &other) {
69         destroy(true);
70         copy(other);
71     }
72     return *this;
73 }
74
75 void pseries::copy(const pseries &other)
76 {
77     inherited::copy(other);
78     seq = other.seq;
79     var = other.var;
80     point = other.point;
81 }
82
83 void pseries::destroy(bool call_parent)
84 {
85     if (call_parent)
86         inherited::destroy(call_parent);
87 }
88
89
90 /*
91  *  Other constructors
92  */
93
94 /** Construct pseries from a vector of coefficients and powers.
95  *  expair.rest holds the coefficient, expair.coeff holds the power.
96  *  The powers must be integers (positive or negative) and in ascending order;
97  *  the last coefficient can be Order(_ex1()) to represent a truncated,
98  *  non-terminating series.
99  *
100  *  @param rel__  expansion variable and point (must hold a relational)
101  *  @param ops_  vector of {coefficient, power} pairs (coefficient must not be zero)
102  *  @return newly constructed pseries */
103 pseries::pseries(const ex &rel_, const epvector &ops_)
104     : basic(TINFO_pseries), seq(ops_)
105 {
106     debugmsg("pseries constructor from rel,epvector", LOGLEVEL_CONSTRUCT);
107     GINAC_ASSERT(is_ex_exactly_of_type(rel_, relational));
108     GINAC_ASSERT(is_ex_exactly_of_type(rel_.lhs(),symbol));
109     point = rel_.rhs();
110     var = *static_cast<symbol *>(rel_.lhs().bp);
111 }
112
113
114 /*
115  *  Archiving
116  */
117
118 /** Construct object from archive_node. */
119 pseries::pseries(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst)
120 {
121     debugmsg("pseries constructor from archive_node", LOGLEVEL_CONSTRUCT);
122     for (unsigned int i=0; true; i++) {
123         ex rest;
124         ex coeff;
125         if (n.find_ex("coeff", rest, sym_lst, i) && n.find_ex("power", coeff, sym_lst, i))
126             seq.push_back(expair(rest, coeff));
127         else
128             break;
129     }
130     n.find_ex("var", var, sym_lst);
131     n.find_ex("point", point, sym_lst);
132 }
133
134 /** Unarchive the object. */
135 ex pseries::unarchive(const archive_node &n, const lst &sym_lst)
136 {
137     return (new pseries(n, sym_lst))->setflag(status_flags::dynallocated);
138 }
139
140 /** Archive the object. */
141 void pseries::archive(archive_node &n) const
142 {
143     inherited::archive(n);
144     epvector::const_iterator i = seq.begin(), iend = seq.end();
145     while (i != iend) {
146         n.add_ex("coeff", i->rest);
147         n.add_ex("power", i->coeff);
148         i++;
149     }
150     n.add_ex("var", var);
151     n.add_ex("point", point);
152 }
153
154
155 /*
156  *  Functions overriding virtual functions from base classes
157  */
158
159 basic *pseries::duplicate() const
160 {
161     debugmsg("pseries duplicate", LOGLEVEL_DUPLICATE);
162     return new pseries(*this);
163 }
164
165 void pseries::print(ostream &os, unsigned upper_precedence) const
166 {
167     debugmsg("pseries print", LOGLEVEL_PRINT);
168     // This could be made better, since series expansion at x==1 might print
169     // -1+2*x+Order((-1+x)^2) instead of 1+2*(-1+x)+Order((-1+x)^2), which is
170     // correct but can be rather confusing.
171     convert_to_poly().print(os, upper_precedence);
172 }
173
174 void pseries::printraw(ostream &os) const
175 {
176         debugmsg("pseries printraw", LOGLEVEL_PRINT);
177         os << "pseries(" << var << ";" << point << ";";
178         for (epvector::const_iterator i=seq.begin(); i!=seq.end(); i++) {
179                 os << "(" << (*i).rest << "," << (*i).coeff << "),";
180         }
181         os << ")";
182 }
183
184 void pseries::printtree(ostream & os, unsigned indent) const
185 {
186     debugmsg("pseries printtree",LOGLEVEL_PRINT);
187     os << string(indent,' ') << "pseries " 
188        << ", hash=" << hashvalue << " (0x" << hex << hashvalue << dec << ")"
189        << ", flags=" << flags << endl;
190     for (unsigned i=0; i<seq.size(); ++i) {
191         seq[i].rest.printtree(os,indent+delta_indent);
192         seq[i].coeff.printtree(os,indent+delta_indent);
193         if (i!=seq.size()-1) {
194             os << string(indent+delta_indent,' ') << "-----" << endl;
195         }
196     }
197     var.printtree(os, indent+delta_indent);
198     point.printtree(os, indent+delta_indent);
199 }
200
201 unsigned pseries::nops(void) const
202 {
203     return seq.size();
204 }
205
206 ex pseries::op(int i) const
207 {
208     if (i < 0 || unsigned(i) >= seq.size())
209         throw (std::out_of_range("op() out of range"));
210     return seq[i].rest * power(var - point, seq[i].coeff);
211 }
212
213 ex &pseries::let_op(int i)
214 {
215     throw (std::logic_error("let_op not defined for pseries"));
216 }
217
218 int pseries::degree(const symbol &s) const
219 {
220     if (var.is_equal(s)) {
221         // Return last exponent
222         if (seq.size())
223             return ex_to_numeric((*(seq.end() - 1)).coeff).to_int();
224         else
225             return 0;
226     } else {
227         epvector::const_iterator it = seq.begin(), itend = seq.end();
228         if (it == itend)
229             return 0;
230         int max_pow = INT_MIN;
231         while (it != itend) {
232             int pow = it->rest.degree(s);
233             if (pow > max_pow)
234                 max_pow = pow;
235             it++;
236         }
237         return max_pow;
238     }
239 }
240
241 int pseries::ldegree(const symbol &s) const
242 {
243     if (var.is_equal(s)) {
244         // Return first exponent
245         if (seq.size())
246             return ex_to_numeric((*(seq.begin())).coeff).to_int();
247         else
248             return 0;
249     } else {
250         epvector::const_iterator it = seq.begin(), itend = seq.end();
251         if (it == itend)
252             return 0;
253         int min_pow = INT_MAX;
254         while (it != itend) {
255             int pow = it->rest.ldegree(s);
256             if (pow < min_pow)
257                 min_pow = pow;
258             it++;
259         }
260         return min_pow;
261     }
262 }
263
264 ex pseries::coeff(const symbol &s, int n) const
265 {
266     if (var.is_equal(s)) {
267                 if (seq.size() == 0)
268                         return _ex0();
269
270                 // Binary search in sequence for given power
271                 numeric looking_for = numeric(n);
272                 int lo = 0, hi = seq.size() - 1;
273                 while (lo <= hi) {
274                         int mid = (lo + hi) / 2;
275                         GINAC_ASSERT(is_ex_exactly_of_type(seq[mid].coeff, numeric));
276                         int cmp = ex_to_numeric(seq[mid].coeff).compare(looking_for);
277                         switch (cmp) {
278                                 case -1:
279                                         lo = mid + 1;
280                                         break;
281                                 case 0:
282                                         return seq[mid].rest;
283                                 case 1:
284                                         hi = mid - 1;
285                                         break;
286                                 default:
287                                         throw(std::logic_error("pseries::coeff: compare() didn't return -1, 0 or 1"));
288                         }
289                 }
290                 return _ex0();
291     } else
292         return convert_to_poly().coeff(s, n);
293 }
294
295 ex pseries::collect(const symbol &s) const
296 {
297         return *this;
298 }
299
300 /** Evaluate coefficients. */
301 ex pseries::eval(int level) const
302 {
303     if (level == 1)
304         return this->hold();
305
306         if (level == -max_recursion_level)
307                 throw (std::runtime_error("pseries::eval(): recursion limit exceeded"));
308     
309     // Construct a new series with evaluated coefficients
310     epvector new_seq;
311     new_seq.reserve(seq.size());
312     epvector::const_iterator it = seq.begin(), itend = seq.end();
313     while (it != itend) {
314         new_seq.push_back(expair(it->rest.eval(level-1), it->coeff));
315         it++;
316     }
317     return (new pseries(relational(var,point), new_seq))->setflag(status_flags::dynallocated | status_flags::evaluated);
318 }
319
320 /** Evaluate coefficients numerically. */
321 ex pseries::evalf(int level) const
322 {
323         if (level == 1)
324                 return *this;
325
326         if (level == -max_recursion_level)
327                 throw (std::runtime_error("pseries::evalf(): recursion limit exceeded"));
328
329     // Construct a new series with evaluated coefficients
330     epvector new_seq;
331     new_seq.reserve(seq.size());
332     epvector::const_iterator it = seq.begin(), itend = seq.end();
333     while (it != itend) {
334         new_seq.push_back(expair(it->rest.evalf(level-1), it->coeff));
335         it++;
336     }
337     return (new pseries(relational(var,point), new_seq))->setflag(status_flags::dynallocated | status_flags::evaluated);
338 }
339
340 ex pseries::subs(const lst & ls, const lst & lr) const
341 {
342         // If expansion variable is being substituted, convert the series to a
343         // polynomial and do the substitution there because the result might
344         // no longer be a power series
345         if (ls.has(var))
346                 return convert_to_poly(true).subs(ls, lr);
347
348         // Otherwise construct a new series with substituted coefficients and
349         // expansion point
350         epvector new_seq;
351         new_seq.reserve(seq.size());
352         epvector::const_iterator it = seq.begin(), itend = seq.end();
353         while (it != itend) {
354                 new_seq.push_back(expair(it->rest.subs(ls, lr), it->coeff));
355                 it++;
356         }
357     return (new pseries(relational(var,point.subs(ls, lr)), new_seq))->setflag(status_flags::dynallocated);
358 }
359
360 /** Implementation of ex::diff() for a power series.  It treats the series as a
361  *  polynomial.
362  *  @see ex::diff */
363 ex pseries::derivative(const symbol & s) const
364 {
365     if (s == var) {
366         epvector new_seq;
367         epvector::const_iterator it = seq.begin(), itend = seq.end();
368         
369         // FIXME: coeff might depend on var
370         while (it != itend) {
371             if (is_order_function(it->rest)) {
372                 new_seq.push_back(expair(it->rest, it->coeff - 1));
373             } else {
374                 ex c = it->rest * it->coeff;
375                 if (!c.is_zero())
376                     new_seq.push_back(expair(c, it->coeff - 1));
377             }
378             it++;
379         }
380         return pseries(relational(var,point), new_seq);
381     } else {
382         return *this;
383     }
384 }
385
386
387 /*
388  *  Construct ordinary polynomial out of series
389  */
390
391 /** Convert a pseries object to an ordinary polynomial.
392  *
393  *  @param no_order flag: discard higher order terms */
394 ex pseries::convert_to_poly(bool no_order) const
395 {
396     ex e;
397     epvector::const_iterator it = seq.begin(), itend = seq.end();
398     
399     while (it != itend) {
400         if (is_order_function(it->rest)) {
401             if (!no_order)
402                 e += Order(power(var - point, it->coeff));
403         } else
404             e += it->rest * power(var - point, it->coeff);
405         it++;
406     }
407     return e;
408 }
409
410
411 /*
412  *  Implementation of series expansion
413  */
414
415 /** Default implementation of ex::series(). This performs Taylor expansion.
416  *  @see ex::series */
417 ex basic::series(const relational & r, int order) const
418 {
419     epvector seq;
420     numeric fac(1);
421     ex deriv = *this;
422     ex coeff = deriv.subs(r);
423     const symbol *s = static_cast<symbol *>(r.lhs().bp);
424     
425     if (!coeff.is_zero())
426         seq.push_back(expair(coeff, numeric(0)));
427     
428     int n;
429     for (n=1; n<order; n++) {
430         fac = fac.mul(numeric(n));
431         deriv = deriv.diff(*s).expand();
432         if (deriv.is_zero()) {
433             // Series terminates
434             return pseries(r, seq);
435         }
436         coeff = fac.inverse() * deriv.subs(r);
437         if (!coeff.is_zero())
438             seq.push_back(expair(coeff, numeric(n)));
439     }
440     
441     // Higher-order terms, if present
442     deriv = deriv.diff(*s);
443     if (!deriv.is_zero())
444         seq.push_back(expair(Order(_ex1()), numeric(n)));
445     return pseries(r, seq);
446 }
447
448
449 /** Implementation of ex::series() for symbols.
450  *  @see ex::series */
451 ex symbol::series(const relational & r, int order) const
452 {
453         epvector seq;
454     const ex point = r.rhs();
455     GINAC_ASSERT(is_ex_exactly_of_type(r.lhs(),symbol));
456     const symbol *s = static_cast<symbol *>(r.lhs().bp);
457     
458         if (this->is_equal(*s)) {
459                 if (order > 0 && !point.is_zero())
460                         seq.push_back(expair(point, _ex0()));
461                 if (order > 1)
462                         seq.push_back(expair(_ex1(), _ex1()));
463                 else
464                         seq.push_back(expair(Order(_ex1()), numeric(order)));
465         } else
466                 seq.push_back(expair(*this, _ex0()));
467         return pseries(r, seq);
468 }
469
470
471 /** Add one series object to another, producing a pseries object that
472  *  represents the sum.
473  *
474  *  @param other  pseries object to add with
475  *  @return the sum as a pseries */
476 ex pseries::add_series(const pseries &other) const
477 {
478     // Adding two series with different variables or expansion points
479     // results in an empty (constant) series 
480     if (!is_compatible_to(other)) {
481         epvector nul;
482         nul.push_back(expair(Order(_ex1()), _ex0()));
483         return pseries(relational(var,point), nul);
484     }
485     
486     // Series addition
487     epvector new_seq;
488     epvector::const_iterator a = seq.begin();
489     epvector::const_iterator b = other.seq.begin();
490     epvector::const_iterator a_end = seq.end();
491     epvector::const_iterator b_end = other.seq.end();
492     int pow_a = INT_MAX, pow_b = INT_MAX;
493     for (;;) {
494         // If a is empty, fill up with elements from b and stop
495         if (a == a_end) {
496             while (b != b_end) {
497                 new_seq.push_back(*b);
498                 b++;
499             }
500             break;
501         } else
502             pow_a = ex_to_numeric((*a).coeff).to_int();
503         
504         // If b is empty, fill up with elements from a and stop
505         if (b == b_end) {
506             while (a != a_end) {
507                 new_seq.push_back(*a);
508                 a++;
509             }
510             break;
511         } else
512             pow_b = ex_to_numeric((*b).coeff).to_int();
513         
514         // a and b are non-empty, compare powers
515         if (pow_a < pow_b) {
516             // a has lesser power, get coefficient from a
517             new_seq.push_back(*a);
518             if (is_order_function((*a).rest))
519                 break;
520             a++;
521         } else if (pow_b < pow_a) {
522             // b has lesser power, get coefficient from b
523             new_seq.push_back(*b);
524             if (is_order_function((*b).rest))
525                 break;
526             b++;
527         } else {
528             // Add coefficient of a and b
529             if (is_order_function((*a).rest) || is_order_function((*b).rest)) {
530                 new_seq.push_back(expair(Order(_ex1()), (*a).coeff));
531                 break;  // Order term ends the sequence
532             } else {
533                 ex sum = (*a).rest + (*b).rest;
534                 if (!(sum.is_zero()))
535                     new_seq.push_back(expair(sum, numeric(pow_a)));
536                 a++;
537                 b++;
538             }
539         }
540     }
541     return pseries(relational(var,point), new_seq);
542 }
543
544
545 /** Implementation of ex::series() for sums. This performs series addition when
546  *  adding pseries objects.
547  *  @see ex::series */
548 ex add::series(const relational & r, int order) const
549 {
550     ex acc; // Series accumulator
551     
552     // Get first term from overall_coeff
553     acc = overall_coeff.series(r, order);
554
555     // Add remaining terms
556     epvector::const_iterator it = seq.begin();
557     epvector::const_iterator itend = seq.end();
558     for (; it!=itend; it++) {
559         ex op;
560         if (is_ex_exactly_of_type(it->rest, pseries))
561             op = it->rest;
562         else
563             op = it->rest.series(r, order);
564         if (!it->coeff.is_equal(_ex1()))
565             op = ex_to_pseries(op).mul_const(ex_to_numeric(it->coeff));
566         
567         // Series addition
568         acc = ex_to_pseries(acc).add_series(ex_to_pseries(op));
569     }
570     return acc;
571 }
572
573
574 /** Multiply a pseries object with a numeric constant, producing a pseries
575  *  object that represents the product.
576  *
577  *  @param other  constant to multiply with
578  *  @return the product as a pseries */
579 ex pseries::mul_const(const numeric &other) const
580 {
581     epvector new_seq;
582     new_seq.reserve(seq.size());
583     
584     epvector::const_iterator it = seq.begin(), itend = seq.end();
585     while (it != itend) {
586         if (!is_order_function(it->rest))
587             new_seq.push_back(expair(it->rest * other, it->coeff));
588         else
589             new_seq.push_back(*it);
590         it++;
591     }
592     return pseries(relational(var,point), new_seq);
593 }
594
595
596 /** Multiply one pseries object to another, producing a pseries object that
597  *  represents the product.
598  *
599  *  @param other  pseries object to multiply with
600  *  @return the product as a pseries */
601 ex pseries::mul_series(const pseries &other) const
602 {
603     // Multiplying two series with different variables or expansion points
604     // results in an empty (constant) series 
605     if (!is_compatible_to(other)) {
606         epvector nul;
607         nul.push_back(expair(Order(_ex1()), _ex0()));
608         return pseries(relational(var,point), nul);
609     }
610
611     // Series multiplication
612     epvector new_seq;
613     
614     const symbol *s = static_cast<symbol *>(var.bp);
615     int a_max = degree(*s);
616     int b_max = other.degree(*s);
617     int a_min = ldegree(*s);
618     int b_min = other.ldegree(*s);
619     int cdeg_min = a_min + b_min;
620     int cdeg_max = a_max + b_max;
621     
622     int higher_order_a = INT_MAX;
623     int higher_order_b = INT_MAX;
624     if (is_order_function(coeff(*s, a_max)))
625         higher_order_a = a_max + b_min;
626     if (is_order_function(other.coeff(*s, b_max)))
627         higher_order_b = b_max + a_min;
628     int higher_order_c = min(higher_order_a, higher_order_b);
629     if (cdeg_max >= higher_order_c)
630         cdeg_max = higher_order_c - 1;
631     
632     for (int cdeg=cdeg_min; cdeg<=cdeg_max; cdeg++) {
633         ex co = _ex0();
634         // c(i)=a(0)b(i)+...+a(i)b(0)
635         for (int i=a_min; cdeg-i>=b_min; i++) {
636             ex a_coeff = coeff(*s, i);
637             ex b_coeff = other.coeff(*s, cdeg-i);
638             if (!is_order_function(a_coeff) && !is_order_function(b_coeff))
639                 co += coeff(*s, i) * other.coeff(*s, cdeg-i);
640         }
641         if (!co.is_zero())
642             new_seq.push_back(expair(co, numeric(cdeg)));
643     }
644     if (higher_order_c < INT_MAX)
645         new_seq.push_back(expair(Order(_ex1()), numeric(higher_order_c)));
646     return pseries(relational(var,point), new_seq);
647 }
648
649
650 /** Implementation of ex::series() for product. This performs series
651  *  multiplication when multiplying series.
652  *  @see ex::series */
653 ex mul::series(const relational & r, int order) const
654 {
655     ex acc; // Series accumulator
656     
657     // Get first term from overall_coeff
658     acc = overall_coeff.series(r, order);
659     
660     // Multiply with remaining terms
661     epvector::const_iterator it = seq.begin();
662     epvector::const_iterator itend = seq.end();
663     for (; it!=itend; it++) {
664         ex op = it->rest;
665         if (op.info(info_flags::numeric)) {
666             // series * const (special case, faster)
667             ex f = power(op, it->coeff);
668             acc = ex_to_pseries(acc).mul_const(ex_to_numeric(f));
669             continue;
670         } else if (!is_ex_exactly_of_type(op, pseries))
671             op = op.series(r, order);
672         if (!it->coeff.is_equal(_ex1()))
673             op = ex_to_pseries(op).power_const(ex_to_numeric(it->coeff), order);
674
675         // Series multiplication
676         acc = ex_to_pseries(acc).mul_series(ex_to_pseries(op));
677     }
678     return acc;
679 }
680
681
682 /** Compute the p-th power of a series.
683  *
684  *  @param p  power to compute
685  *  @param deg  truncation order of series calculation */
686 ex pseries::power_const(const numeric &p, int deg) const
687 {
688     int i;
689     const symbol *s = static_cast<symbol *>(var.bp);
690     int ldeg = ldegree(*s);
691     
692     // Calculate coefficients of powered series
693     exvector co;
694     co.reserve(deg);
695     ex co0;
696     co.push_back(co0 = power(coeff(*s, ldeg), p));
697     bool all_sums_zero = true;
698     for (i=1; i<deg; i++) {
699         ex sum = _ex0();
700         for (int j=1; j<=i; j++) {
701             ex c = coeff(*s, j + ldeg);
702             if (is_order_function(c)) {
703                 co.push_back(Order(_ex1()));
704                 break;
705             } else
706                 sum += (p * j - (i - j)) * co[i - j] * c;
707         }
708         if (!sum.is_zero())
709             all_sums_zero = false;
710         co.push_back(co0 * sum / numeric(i));
711     }
712     
713     // Construct new series (of non-zero coefficients)
714     epvector new_seq;
715     bool higher_order = false;
716     for (i=0; i<deg; i++) {
717         if (!co[i].is_zero())
718             new_seq.push_back(expair(co[i], numeric(i) + p * ldeg));
719         if (is_order_function(co[i])) {
720             higher_order = true;
721             break;
722         }
723     }
724     if (!higher_order && !all_sums_zero)
725         new_seq.push_back(expair(Order(_ex1()), numeric(deg) + p * ldeg));
726     return pseries(relational(var,point), new_seq);
727 }
728
729
730 /** Implementation of ex::series() for powers. This performs Laurent expansion
731  *  of reciprocals of series at singularities.
732  *  @see ex::series */
733 ex power::series(const relational & r, int order) const
734 {
735     ex e;
736     if (!is_ex_exactly_of_type(basis, pseries)) {
737         // Basis is not a series, may there be a singulary?
738         if (!exponent.info(info_flags::negint))
739             return basic::series(r, order);
740         
741         // Expression is of type something^(-int), check for singularity
742         if (!basis.subs(r).is_zero())
743             return basic::series(r, order);
744         
745         // Singularity encountered, expand basis into series
746         e = basis.series(r, order);
747     } else {
748         // Basis is a series
749         e = basis;
750     }
751     
752     // Power e
753     return ex_to_pseries(e).power_const(ex_to_numeric(exponent), order);
754 }
755
756
757 /** Re-expansion of a pseries object. */
758 ex pseries::series(const relational & r, int order) const
759 {
760     const ex p = r.rhs();
761     GINAC_ASSERT(is_ex_exactly_of_type(r.lhs(),symbol));
762     const symbol *s = static_cast<symbol *>(r.lhs().bp);
763     
764         if (var.is_equal(*s) && point.is_equal(p)) {
765                 if (order > degree(*s))
766                         return *this;
767                 else {
768                 epvector new_seq;
769                 epvector::const_iterator it = seq.begin(), itend = seq.end();
770                         while (it != itend) {
771                                 int o = ex_to_numeric(it->coeff).to_int();
772                                 if (o >= order) {
773                                         new_seq.push_back(expair(Order(_ex1()), o));
774                                         break;
775                                 }
776                                 new_seq.push_back(*it);
777                                 it++;
778                         }
779                         return pseries(r, new_seq);
780                 }
781         } else
782                 return convert_to_poly().series(r, order);
783 }
784
785
786 /** Compute the truncated series expansion of an expression.
787  *  This function returns an expression containing an object of class pseries 
788  *  to represent the series. If the series does not terminate within the given
789  *  truncation order, the last term of the series will be an order term.
790  *
791  *  @param r  expansion relation, lhs holds variable and rhs holds point
792  *  @param order  truncation order of series calculations
793  *  @return an expression holding a pseries object */
794 ex ex::series(const ex & r, int order) const
795 {
796     GINAC_ASSERT(bp!=0);
797     ex e;
798     relational rel_;
799     
800     if (is_ex_exactly_of_type(r,relational))
801         rel_ = ex_to_relational(r);
802     else if (is_ex_exactly_of_type(r,symbol))
803         rel_ = relational(r,_ex0());
804     else
805         throw (std::logic_error("ex::series(): expansion point has unknown type"));
806     
807     try {
808         e = bp->series(rel_, order);
809     } catch (exception &x) {
810         throw (std::logic_error(string("unable to compute series (") + x.what() + ")"));
811     }
812     return e;
813 }
814
815
816 // Global constants
817 const pseries some_pseries;
818 const type_info & typeid_pseries = typeid(some_pseries);
819
820 #ifndef NO_NAMESPACE_GINAC
821 } // namespace GiNaC
822 #endif // ndef NO_NAMESPACE_GINAC