pseries::power_const: fix a critical bug that led to wrong computations.
[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-2001 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_) : basic(TINFO_pseries), seq(ops_)
104 {
105         debugmsg("pseries constructor from ex,epvector", LOGLEVEL_CONSTRUCT);
106         GINAC_ASSERT(is_ex_exactly_of_type(rel_, relational));
107         GINAC_ASSERT(is_ex_exactly_of_type(rel_.lhs(),symbol));
108         point = rel_.rhs();
109         var = *static_cast<symbol *>(rel_.lhs().bp);
110 }
111
112
113 /*
114  *  Archiving
115  */
116
117 /** Construct object from archive_node. */
118 pseries::pseries(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst)
119 {
120         debugmsg("pseries constructor from archive_node", LOGLEVEL_CONSTRUCT);
121         for (unsigned int i=0; true; ++i) {
122                 ex rest;
123                 ex coeff;
124                 if (n.find_ex("coeff", rest, sym_lst, i) && n.find_ex("power", coeff, sym_lst, i))
125                         seq.push_back(expair(rest, coeff));
126                 else
127                         break;
128         }
129         n.find_ex("var", var, sym_lst);
130         n.find_ex("point", point, sym_lst);
131 }
132
133 /** Unarchive the object. */
134 ex pseries::unarchive(const archive_node &n, const lst &sym_lst)
135 {
136         return (new pseries(n, sym_lst))->setflag(status_flags::dynallocated);
137 }
138
139 /** Archive the object. */
140 void pseries::archive(archive_node &n) const
141 {
142         inherited::archive(n);
143         epvector::const_iterator i = seq.begin(), iend = seq.end();
144         while (i != iend) {
145                 n.add_ex("coeff", i->rest);
146                 n.add_ex("power", i->coeff);
147                 ++i;
148         }
149         n.add_ex("var", var);
150         n.add_ex("point", point);
151 }
152
153 //////////
154 // functions overriding virtual functions from bases classes
155 //////////
156
157 basic *pseries::duplicate() const
158 {
159         debugmsg("pseries duplicate", LOGLEVEL_DUPLICATE);
160         return new pseries(*this);
161 }
162
163 void pseries::print(std::ostream &os, unsigned upper_precedence) const
164 {
165         debugmsg("pseries print", LOGLEVEL_PRINT);
166         if (precedence<=upper_precedence) os << "(";
167         for (epvector::const_iterator i=seq.begin(); i!=seq.end(); ++i) {
168                 // omit zero terms
169                 if (i->rest.is_zero())
170                         continue;
171                 // print a sign, if needed
172                 if (i!=seq.begin())
173                         os << '+';
174                 if (!is_order_function(i->rest)) {
175                         // print 'rest', i.e. the expansion coefficient
176                         if (i->rest.info(info_flags::numeric) &&
177                                 i->rest.info(info_flags::positive)) {
178                                 os << i->rest;
179                         } else
180                                 os << "(" << i->rest << ')';
181                         // print 'coeff', something like (x-1)^42
182                         if (!i->coeff.is_zero()) {
183                                 os << '*';
184                                 if (!point.is_zero())
185                                         os << '(' << var-point << ')';
186                                 else
187                                         os << var;
188                                 if (i->coeff.compare(_ex1())) {
189                                         os << '^';
190                                         if (i->coeff.info(info_flags::negative))
191                                                 os << '(' << i->coeff << ')';
192                                         else
193                                                 os << i->coeff;
194                                 }
195                         }
196                 } else {
197                         os << Order(power(var-point,i->coeff));
198                 }
199         }
200         if (precedence<=upper_precedence) os << ")";
201 }
202
203
204 void pseries::printraw(std::ostream &os) const
205 {
206         debugmsg("pseries printraw", LOGLEVEL_PRINT);
207         os << "pseries(" << var << ";" << point << ";";
208         for (epvector::const_iterator i=seq.begin(); i!=seq.end(); ++i) {
209                 os << "(" << (*i).rest << "," << (*i).coeff << "),";
210         }
211         os << ")";
212 }
213
214
215 void pseries::printtree(std::ostream & os, unsigned indent) const
216 {
217         debugmsg("pseries printtree",LOGLEVEL_PRINT);
218         os << std::string(indent,' ') << "pseries " 
219            << ", hash=" << hashvalue
220            << " (0x" << std::hex << hashvalue << std::dec << ")"
221            << ", flags=" << flags << std::endl;
222         for (unsigned i=0; i<seq.size(); ++i) {
223                 seq[i].rest.printtree(os,indent+delta_indent);
224                 seq[i].coeff.printtree(os,indent+delta_indent);
225                 if (i!=seq.size()-1)
226                         os << std::string(indent+delta_indent,' ') << "-----" << std::endl;
227         }
228         var.printtree(os, indent+delta_indent);
229         point.printtree(os, indent+delta_indent);
230 }
231
232 /** Return the number of operands including a possible order term. */
233 unsigned pseries::nops(void) const
234 {
235         return seq.size();
236 }
237
238
239 /** Return the ith term in the series when represented as a sum. */
240 ex pseries::op(int i) const
241 {
242         if (i < 0 || unsigned(i) >= seq.size())
243                 throw (std::out_of_range("op() out of range"));
244         return seq[i].rest * power(var - point, seq[i].coeff);
245 }
246
247
248 ex &pseries::let_op(int i)
249 {
250         throw (std::logic_error("let_op not defined for pseries"));
251 }
252
253
254 /** Return degree of highest power of the series.  This is usually the exponent
255  *  of the Order term.  If s is not the expansion variable of the series, the
256  *  series is examined termwise. */
257 int pseries::degree(const symbol &s) const
258 {
259         if (var.is_equal(s)) {
260                 // Return last exponent
261                 if (seq.size())
262                         return ex_to_numeric((*(seq.end() - 1)).coeff).to_int();
263                 else
264                         return 0;
265         } else {
266                 epvector::const_iterator it = seq.begin(), itend = seq.end();
267                 if (it == itend)
268                         return 0;
269                 int max_pow = INT_MIN;
270                 while (it != itend) {
271                         int pow = it->rest.degree(s);
272                         if (pow > max_pow)
273                                 max_pow = pow;
274                         ++it;
275                 }
276                 return max_pow;
277         }
278 }
279
280 /** Return degree of lowest power of the series.  This is usually the exponent
281  *  of the leading term.  If s is not the expansion variable of the series, the
282  *  series is examined termwise.  If s is the expansion variable but the
283  *  expansion point is not zero the series is not expanded to find the degree.
284  *  I.e.: (1-x) + (1-x)^2 + Order((1-x)^3) has ldegree(x) 1, not 0. */
285 int pseries::ldegree(const symbol &s) const
286 {
287         if (var.is_equal(s)) {
288                 // Return first exponent
289                 if (seq.size())
290                         return ex_to_numeric((*(seq.begin())).coeff).to_int();
291                 else
292                         return 0;
293         } else {
294                 epvector::const_iterator it = seq.begin(), itend = seq.end();
295                 if (it == itend)
296                         return 0;
297                 int min_pow = INT_MAX;
298                 while (it != itend) {
299                         int pow = it->rest.ldegree(s);
300                         if (pow < min_pow)
301                                 min_pow = pow;
302                         ++it;
303                 }
304                 return min_pow;
305         }
306 }
307
308 ex pseries::coeff(const symbol &s, int n) const
309 {
310         if (var.is_equal(s)) {
311                 if (seq.size() == 0)
312                         return _ex0();
313                 
314                 // Binary search in sequence for given power
315                 numeric looking_for = numeric(n);
316                 int lo = 0, hi = seq.size() - 1;
317                 while (lo <= hi) {
318                         int mid = (lo + hi) / 2;
319                         GINAC_ASSERT(is_ex_exactly_of_type(seq[mid].coeff, numeric));
320                         int cmp = ex_to_numeric(seq[mid].coeff).compare(looking_for);
321                         switch (cmp) {
322                                 case -1:
323                                         lo = mid + 1;
324                                         break;
325                                 case 0:
326                                         return seq[mid].rest;
327                                 case 1:
328                                         hi = mid - 1;
329                                         break;
330                                 default:
331                                         throw(std::logic_error("pseries::coeff: compare() didn't return -1, 0 or 1"));
332                         }
333                 }
334                 return _ex0();
335         } else
336                 return convert_to_poly().coeff(s, n);
337 }
338
339
340 ex pseries::collect(const symbol &s) const
341 {
342         return *this;
343 }
344
345
346 /** Evaluate coefficients. */
347 ex pseries::eval(int level) const
348 {
349         if (level == 1)
350                 return this->hold();
351         
352         if (level == -max_recursion_level)
353                 throw (std::runtime_error("pseries::eval(): recursion limit exceeded"));
354         
355         // Construct a new series with evaluated coefficients
356         epvector new_seq;
357         new_seq.reserve(seq.size());
358         epvector::const_iterator it = seq.begin(), itend = seq.end();
359         while (it != itend) {
360                 new_seq.push_back(expair(it->rest.eval(level-1), it->coeff));
361                 ++it;
362         }
363         return (new pseries(relational(var,point), new_seq))->setflag(status_flags::dynallocated | status_flags::evaluated);
364 }
365
366
367 /** Evaluate coefficients numerically. */
368 ex pseries::evalf(int level) const
369 {
370         if (level == 1)
371                 return *this;
372         
373         if (level == -max_recursion_level)
374                 throw (std::runtime_error("pseries::evalf(): recursion limit exceeded"));
375         
376         // Construct a new series with evaluated coefficients
377         epvector new_seq;
378         new_seq.reserve(seq.size());
379         epvector::const_iterator it = seq.begin(), itend = seq.end();
380         while (it != itend) {
381                 new_seq.push_back(expair(it->rest.evalf(level-1), it->coeff));
382                 ++it;
383         }
384         return (new pseries(relational(var,point), new_seq))->setflag(status_flags::dynallocated | status_flags::evaluated);
385 }
386
387
388 ex pseries::subs(const lst & ls, const lst & lr) const
389 {
390         // If expansion variable is being substituted, convert the series to a
391         // polynomial and do the substitution there because the result might
392         // no longer be a power series
393         if (ls.has(var))
394                 return convert_to_poly(true).subs(ls, lr);
395         
396         // Otherwise construct a new series with substituted coefficients and
397         // expansion point
398         epvector newseq;
399         newseq.reserve(seq.size());
400         epvector::const_iterator it = seq.begin(), itend = seq.end();
401         while (it != itend) {
402                 newseq.push_back(expair(it->rest.subs(ls, lr), it->coeff));
403                 ++it;
404         }
405         return (new pseries(relational(var,point.subs(ls, lr)), newseq))->setflag(status_flags::dynallocated);
406 }
407
408
409 /** Implementation of ex::expand() for a power series.  It expands all the
410  *  terms individually and returns the resulting series as a new pseries.
411  *  @see ex::diff */
412 ex pseries::expand(unsigned options) const
413 {
414         epvector newseq;
415         newseq.reserve(seq.size());
416         for (epvector::const_iterator i=seq.begin(); i!=seq.end(); ++i)
417                 newseq.push_back(expair(i->rest.expand(), i->coeff));
418         return (new pseries(relational(var,point), newseq))
419                 ->setflag(status_flags::dynallocated | status_flags::expanded);
420 }
421
422
423 /** Implementation of ex::diff() for a power series.  It treats the series as a
424  *  polynomial.
425  *  @see ex::diff */
426 ex pseries::derivative(const symbol & s) const
427 {
428         if (s == var) {
429                 epvector new_seq;
430                 epvector::const_iterator it = seq.begin(), itend = seq.end();
431                 
432                 // FIXME: coeff might depend on var
433                 while (it != itend) {
434                         if (is_order_function(it->rest)) {
435                                 new_seq.push_back(expair(it->rest, it->coeff - 1));
436                         } else {
437                                 ex c = it->rest * it->coeff;
438                                 if (!c.is_zero())
439                                         new_seq.push_back(expair(c, it->coeff - 1));
440                         }
441                         ++it;
442                 }
443                 return pseries(relational(var,point), new_seq);
444         } else {
445                 return *this;
446         }
447 }
448
449
450 /*
451  *  Construct ordinary polynomial out of series
452  */
453
454 /** Convert a pseries object to an ordinary polynomial.
455  *
456  *  @param no_order flag: discard higher order terms */
457 ex pseries::convert_to_poly(bool no_order) const
458 {
459         ex e;
460         epvector::const_iterator it = seq.begin(), itend = seq.end();
461         
462         while (it != itend) {
463                 if (is_order_function(it->rest)) {
464                         if (!no_order)
465                                 e += Order(power(var - point, it->coeff));
466                 } else
467                         e += it->rest * power(var - point, it->coeff);
468                 ++it;
469         }
470         return e;
471 }
472
473 /** Returns true if there is no order term, i.e. the series terminates and
474  *  false otherwise. */
475 bool pseries::is_terminating(void) const
476 {
477         return seq.size() == 0 || !is_order_function((seq.end()-1)->rest);
478 }
479
480
481 /*
482  *  Implementation of series expansion
483  */
484
485 /** Default implementation of ex::series(). This performs Taylor expansion.
486  *  @see ex::series */
487 ex basic::series(const relational & r, int order, unsigned options) const
488 {
489         epvector seq;
490         numeric fac(1);
491         ex deriv = *this;
492         ex coeff = deriv.subs(r);
493         const symbol *s = static_cast<symbol *>(r.lhs().bp);
494         
495         if (!coeff.is_zero())
496                 seq.push_back(expair(coeff, numeric(0)));
497         
498         int n;
499         for (n=1; n<order; ++n) {
500                 fac = fac.mul(numeric(n));
501                 deriv = deriv.diff(*s).expand();
502                 if (deriv.is_zero()) {
503                         // Series terminates
504                         return pseries(r, seq);
505                 }
506                 coeff = deriv.subs(r);
507                 if (!coeff.is_zero())
508                         seq.push_back(expair(fac.inverse() * coeff, numeric(n)));
509         }
510         
511         // Higher-order terms, if present
512         deriv = deriv.diff(*s);
513         if (!deriv.expand().is_zero())
514                 seq.push_back(expair(Order(_ex1()), numeric(n)));
515         return pseries(r, seq);
516 }
517
518
519 /** Implementation of ex::series() for symbols.
520  *  @see ex::series */
521 ex symbol::series(const relational & r, int order, unsigned options) const
522 {
523         epvector seq;
524         const ex point = r.rhs();
525         GINAC_ASSERT(is_ex_exactly_of_type(r.lhs(),symbol));
526         const symbol *s = static_cast<symbol *>(r.lhs().bp);
527         
528         if (this->is_equal(*s)) {
529                 if (order > 0 && !point.is_zero())
530                         seq.push_back(expair(point, _ex0()));
531                 if (order > 1)
532                         seq.push_back(expair(_ex1(), _ex1()));
533                 else
534                         seq.push_back(expair(Order(_ex1()), numeric(order)));
535         } else
536                 seq.push_back(expair(*this, _ex0()));
537         return pseries(r, seq);
538 }
539
540
541 /** Add one series object to another, producing a pseries object that
542  *  represents the sum.
543  *
544  *  @param other  pseries object to add with
545  *  @return the sum as a pseries */
546 ex pseries::add_series(const pseries &other) const
547 {
548         // Adding two series with different variables or expansion points
549         // results in an empty (constant) series 
550         if (!is_compatible_to(other)) {
551                 epvector nul;
552                 nul.push_back(expair(Order(_ex1()), _ex0()));
553                 return pseries(relational(var,point), nul);
554         }
555         
556         // Series addition
557         epvector new_seq;
558         epvector::const_iterator a = seq.begin();
559         epvector::const_iterator b = other.seq.begin();
560         epvector::const_iterator a_end = seq.end();
561         epvector::const_iterator b_end = other.seq.end();
562         int pow_a = INT_MAX, pow_b = INT_MAX;
563         for (;;) {
564                 // If a is empty, fill up with elements from b and stop
565                 if (a == a_end) {
566                         while (b != b_end) {
567                                 new_seq.push_back(*b);
568                                 ++b;
569                         }
570                         break;
571                 } else
572                         pow_a = ex_to_numeric((*a).coeff).to_int();
573                 
574                 // If b is empty, fill up with elements from a and stop
575                 if (b == b_end) {
576                         while (a != a_end) {
577                                 new_seq.push_back(*a);
578                                 ++a;
579                         }
580                         break;
581                 } else
582                         pow_b = ex_to_numeric((*b).coeff).to_int();
583                 
584                 // a and b are non-empty, compare powers
585                 if (pow_a < pow_b) {
586                         // a has lesser power, get coefficient from a
587                         new_seq.push_back(*a);
588                         if (is_order_function((*a).rest))
589                                 break;
590                         ++a;
591                 } else if (pow_b < pow_a) {
592                         // b has lesser power, get coefficient from b
593                         new_seq.push_back(*b);
594                         if (is_order_function((*b).rest))
595                                 break;
596                         ++b;
597                 } else {
598                         // Add coefficient of a and b
599                         if (is_order_function((*a).rest) || is_order_function((*b).rest)) {
600                                 new_seq.push_back(expair(Order(_ex1()), (*a).coeff));
601                                 break;  // Order term ends the sequence
602                         } else {
603                                 ex sum = (*a).rest + (*b).rest;
604                                 if (!(sum.is_zero()))
605                                         new_seq.push_back(expair(sum, numeric(pow_a)));
606                                 ++a;
607                                 ++b;
608                         }
609                 }
610         }
611         return pseries(relational(var,point), new_seq);
612 }
613
614
615 /** Implementation of ex::series() for sums. This performs series addition when
616  *  adding pseries objects.
617  *  @see ex::series */
618 ex add::series(const relational & r, int order, unsigned options) const
619 {
620         ex acc; // Series accumulator
621         
622         // Get first term from overall_coeff
623         acc = overall_coeff.series(r, order, options);
624         
625         // Add remaining terms
626         epvector::const_iterator it = seq.begin();
627         epvector::const_iterator itend = seq.end();
628         for (; it!=itend; ++it) {
629                 ex op;
630                 if (is_ex_exactly_of_type(it->rest, pseries))
631                         op = it->rest;
632                 else
633                         op = it->rest.series(r, order, options);
634                 if (!it->coeff.is_equal(_ex1()))
635                         op = ex_to_pseries(op).mul_const(ex_to_numeric(it->coeff));
636                 
637                 // Series addition
638                 acc = ex_to_pseries(acc).add_series(ex_to_pseries(op));
639         }
640         return acc;
641 }
642
643
644 /** Multiply a pseries object with a numeric constant, producing a pseries
645  *  object that represents the product.
646  *
647  *  @param other  constant to multiply with
648  *  @return the product as a pseries */
649 ex pseries::mul_const(const numeric &other) const
650 {
651         epvector new_seq;
652         new_seq.reserve(seq.size());
653         
654         epvector::const_iterator it = seq.begin(), itend = seq.end();
655         while (it != itend) {
656                 if (!is_order_function(it->rest))
657                         new_seq.push_back(expair(it->rest * other, it->coeff));
658                 else
659                         new_seq.push_back(*it);
660                 ++it;
661         }
662         return pseries(relational(var,point), new_seq);
663 }
664
665
666 /** Multiply one pseries object to another, producing a pseries object that
667  *  represents the product.
668  *
669  *  @param other  pseries object to multiply with
670  *  @return the product as a pseries */
671 ex pseries::mul_series(const pseries &other) const
672 {
673         // Multiplying two series with different variables or expansion points
674         // results in an empty (constant) series 
675         if (!is_compatible_to(other)) {
676                 epvector nul;
677                 nul.push_back(expair(Order(_ex1()), _ex0()));
678                 return pseries(relational(var,point), nul);
679         }
680         
681         // Series multiplication
682         epvector new_seq;
683         
684         const symbol *s = static_cast<symbol *>(var.bp);
685         int a_max = degree(*s);
686         int b_max = other.degree(*s);
687         int a_min = ldegree(*s);
688         int b_min = other.ldegree(*s);
689         int cdeg_min = a_min + b_min;
690         int cdeg_max = a_max + b_max;
691         
692         int higher_order_a = INT_MAX;
693         int higher_order_b = INT_MAX;
694         if (is_order_function(coeff(*s, a_max)))
695                 higher_order_a = a_max + b_min;
696         if (is_order_function(other.coeff(*s, b_max)))
697                 higher_order_b = b_max + a_min;
698         int higher_order_c = std::min(higher_order_a, higher_order_b);
699         if (cdeg_max >= higher_order_c)
700                 cdeg_max = higher_order_c - 1;
701         
702         for (int cdeg=cdeg_min; cdeg<=cdeg_max; ++cdeg) {
703                 ex co = _ex0();
704                 // c(i)=a(0)b(i)+...+a(i)b(0)
705                 for (int i=a_min; cdeg-i>=b_min; ++i) {
706                         ex a_coeff = coeff(*s, i);
707                         ex b_coeff = other.coeff(*s, cdeg-i);
708                         if (!is_order_function(a_coeff) && !is_order_function(b_coeff))
709                                 co += a_coeff * b_coeff;
710                 }
711                 if (!co.is_zero())
712                         new_seq.push_back(expair(co, numeric(cdeg)));
713         }
714         if (higher_order_c < INT_MAX)
715                 new_seq.push_back(expair(Order(_ex1()), numeric(higher_order_c)));
716         return pseries(relational(var,point), new_seq);
717 }
718
719
720 /** Implementation of ex::series() for product. This performs series
721  *  multiplication when multiplying series.
722  *  @see ex::series */
723 ex mul::series(const relational & r, int order, unsigned options) const
724 {
725         ex acc; // Series accumulator
726         
727         // Get first term from overall_coeff
728         acc = overall_coeff.series(r, order, options);
729         
730         // Multiply with remaining terms
731         epvector::const_iterator it = seq.begin();
732         epvector::const_iterator itend = seq.end();
733         for (; it!=itend; ++it) {
734                 ex op = it->rest;
735                 if (op.info(info_flags::numeric)) {
736                         // series * const (special case, faster)
737                         ex f = power(op, it->coeff);
738                         acc = ex_to_pseries(acc).mul_const(ex_to_numeric(f));
739                         continue;
740                 } else if (!is_ex_exactly_of_type(op, pseries))
741                         op = op.series(r, order, options);
742                 if (!it->coeff.is_equal(_ex1()))
743                         op = ex_to_pseries(op).power_const(ex_to_numeric(it->coeff), order);
744
745                 // Series multiplication
746                 acc = ex_to_pseries(acc).mul_series(ex_to_pseries(op));
747         }
748         return acc;
749 }
750
751
752 /** Compute the p-th power of a series.
753  *
754  *  @param p  power to compute
755  *  @param deg  truncation order of series calculation */
756 ex pseries::power_const(const numeric &p, int deg) const
757 {
758         // method:
759         // let A(x) be this series and for the time being let it start with a
760         // constant (later we'll generalize):
761         //     A(x) = a_0 + a_1*x + a_2*x^2 + ...
762         // We want to compute
763         //     C(x) = A(x)^p
764         //     C(x) = c_0 + c_1*x + c_2*x^2 + ...
765         // Taking the derivative on both sides and multiplying with A(x) one
766         // immediately arrives at
767         //     C'(x)*A(x) = p*C(x)*A'(x)
768         // Multiplying this out and comparing coefficients we get the recurrence
769         // formula
770         //     c_i = (i*p*a_i*c_0 + ((i-1)*p-1)*a_{i-1}*c_1 + ...
771         //                    ... + (p-(i-1))*a_1*c_{i-1})/(a_0*i)
772         // which can easily be solved given the starting value c_0 = (a_0)^p.
773         // For the more general case where the leading coefficient of A(x) is not
774         // a constant, just consider A2(x) = A(x)*x^m, with some integer m and
775         // repeat the above derivation.  The leading power of C2(x) = A2(x)^2 is
776         // then of course x^(p*m) but the recurrence formula still holds.
777         const symbol *s = static_cast<symbol *>(var.bp);
778         int ldeg = ldegree(*s);
779         
780         // Compute coefficients of the powered series
781         exvector co;
782         co.reserve(deg);
783         co.push_back(power(coeff(*s, ldeg), p));
784         bool all_sums_zero = true;
785         for (int i=1; i<deg; ++i) {
786                 ex sum = _ex0();
787                 for (int j=1; j<=i; ++j) {
788                         ex c = coeff(*s, j + ldeg);
789                         if (is_order_function(c)) {
790                                 co.push_back(Order(_ex1()));
791                                 break;
792                         } else
793                                 sum += (p * j - (i - j)) * co[i - j] * c;
794                 }
795                 if (!sum.is_zero())
796                         all_sums_zero = false;
797                 co.push_back(sum / coeff(*s, ldeg) / numeric(i));
798         }
799         
800         // Construct new series (of non-zero coefficients)
801         epvector new_seq;
802         bool higher_order = false;
803         for (int i=0; i<deg; ++i) {
804                 if (!co[i].is_zero())
805                         new_seq.push_back(expair(co[i], numeric(i) + p * ldeg));
806                 if (is_order_function(co[i])) {
807                         higher_order = true;
808                         break;
809                 }
810         }
811         if (!higher_order && !all_sums_zero)
812                 new_seq.push_back(expair(Order(_ex1()), numeric(deg) + p * ldeg));
813         return pseries(relational(var,point), new_seq);
814 }
815
816
817 /** Return a new pseries object with the powers shifted by deg. */
818 pseries pseries::shift_exponents(int deg) const
819 {
820         epvector newseq(seq);
821         for (epvector::iterator i=newseq.begin(); i!=newseq.end(); ++i)
822                 i->coeff = i->coeff + deg;
823         return pseries(relational(var, point), newseq);
824 }
825
826
827 /** Implementation of ex::series() for powers. This performs Laurent expansion
828  *  of reciprocals of series at singularities.
829  *  @see ex::series */
830 ex power::series(const relational & r, int order, unsigned options) const
831 {
832         ex e;
833         if (!is_ex_exactly_of_type(basis, pseries)) {
834                 // Basis is not a series, may there be a singularity?
835                 bool must_expand_basis = false;
836                 try {
837                         basis.subs(r);
838                 } catch (pole_error) {
839                         must_expand_basis = true;
840                 }
841                 
842                 // Is the expression of type something^(-int)?
843                 if (!must_expand_basis && !exponent.info(info_flags::negint))
844                         return basic::series(r, order, options);
845                 
846                 // Is the expression of type 0^something?
847                 if (!must_expand_basis && !basis.subs(r).is_zero())
848                         return basic::series(r, order, options);
849                 
850                 // Singularity encountered, expand basis into series
851                 e = basis.series(r, order, options);
852         } else {
853                 // Basis is a series
854                 e = basis;
855         }
856         
857         // Power e
858         return ex_to_pseries(e).power_const(ex_to_numeric(exponent), order);
859 }
860
861
862 /** Re-expansion of a pseries object. */
863 ex pseries::series(const relational & r, int order, unsigned options) const
864 {
865         const ex p = r.rhs();
866         GINAC_ASSERT(is_ex_exactly_of_type(r.lhs(),symbol));
867         const symbol *s = static_cast<symbol *>(r.lhs().bp);
868         
869         if (var.is_equal(*s) && point.is_equal(p)) {
870                 if (order > degree(*s))
871                         return *this;
872                 else {
873                         epvector new_seq;
874                         epvector::const_iterator it = seq.begin(), itend = seq.end();
875                         while (it != itend) {
876                                 int o = ex_to_numeric(it->coeff).to_int();
877                                 if (o >= order) {
878                                         new_seq.push_back(expair(Order(_ex1()), o));
879                                         break;
880                                 }
881                                 new_seq.push_back(*it);
882                                 ++it;
883                         }
884                         return pseries(r, new_seq);
885                 }
886         } else
887                 return convert_to_poly().series(r, order, options);
888 }
889
890
891 /** Compute the truncated series expansion of an expression.
892  *  This function returns an expression containing an object of class pseries 
893  *  to represent the series. If the series does not terminate within the given
894  *  truncation order, the last term of the series will be an order term.
895  *
896  *  @param r  expansion relation, lhs holds variable and rhs holds point
897  *  @param order  truncation order of series calculations
898  *  @param options  of class series_options
899  *  @return an expression holding a pseries object */
900 ex ex::series(const ex & r, int order, unsigned options) const
901 {
902         GINAC_ASSERT(bp!=0);
903         ex e;
904         relational rel_;
905         
906         if (is_ex_exactly_of_type(r,relational))
907                 rel_ = ex_to_relational(r);
908         else if (is_ex_exactly_of_type(r,symbol))
909                 rel_ = relational(r,_ex0());
910         else
911                 throw (std::logic_error("ex::series(): expansion point has unknown type"));
912         
913         try {
914                 e = bp->series(rel_, order, options);
915         } catch (std::exception &x) {
916                 throw (std::logic_error(std::string("unable to compute series (") + x.what() + ")"));
917         }
918         return e;
919 }
920
921 //////////
922 // static member variables
923 //////////
924
925 // protected
926
927 unsigned pseries::precedence = 38;  // for clarity just below add::precedence
928
929 #ifndef NO_NAMESPACE_GINAC
930 } // namespace GiNaC
931 #endif // ndef NO_NAMESPACE_GINAC