ginac/series.cpp

   1 /** @file series.cpp
   2  *
   3  *  Implementation of class for extended truncated power-series and
   4  *  methods for series expansion. */
   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 "series.h"
  25 #include "add.h"
  26 #include "inifcns.h"
  27 #include "mul.h"
  28 #include "power.h"
  29 #include "relational.h"
  30 #include "symbol.h"
  31 #include "debugmsg.h"
  32 #include "utils.h"
  33
  34 #ifndef NO_GINAC_NAMESPACE
  35 namespace GiNaC {
  36 #endif // ndef NO_GINAC_NAMESPACE
  37
  38 /*
  39  *  Default constructor, destructor, copy constructor, assignment operator and helpers
  40  */
  41
  42 series::series() : basic(TINFO_series)
  43 {
  44     debugmsg("series default constructor", LOGLEVEL_CONSTRUCT);
  45 }
  46
  47 series::~series()
  48 {
  49     debugmsg("series destructor", LOGLEVEL_DESTRUCT);
  50     destroy(false);
  51 }
  52
  53 series::series(series const &other)
  54 {
  55     debugmsg("series copy constructor", LOGLEVEL_CONSTRUCT);
  56     copy(other);
  57 }
  58
  59 series const &series::operator=(series const & other)
  60 {
  61     debugmsg("series operator=", LOGLEVEL_ASSIGNMENT);
  62     if (this != &other) {
  63         destroy(true);
  64         copy(other);
  65     }
  66     return *this;
  67 }
  68
  69 void series::copy(series const &other)
  70 {
  71     inherited::copy(other);
  72     seq = other.seq;
  73     var = other.var;
  74     point = other.point;
  75 }
  76
  77 void series::destroy(bool call_parent)
  78 {
  79     if (call_parent)
  80         inherited::destroy(call_parent);
  81 }
  82
  83
  84 /*
  85  *  Other constructors
  86  */
  87
  88 /** Construct series from a vector of coefficients and powers.
  89  *  expair.rest holds the coefficient, expair.coeff holds the power.
  90  *  The powers must be integers (positive or negative) and in ascending order;
  91  *  the last coefficient can be Order(_ex1()) to represent a truncated,
  92  *  non-terminating series.
  93  *
  94  *  @param var_  series variable (must hold a symbol)
  95  *  @param point_  expansion point
  96  *  @param ops_  vector of {coefficient, power} pairs (coefficient must not be zero)
  97  *  @return newly constructed series */
  98 series::series(ex const &var_, ex const &point_, epvector const &ops_)
  99     : basic(TINFO_series), seq(ops_), var(var_), point(point_)
 100 {
 101     debugmsg("series constructor from ex,ex,epvector", LOGLEVEL_CONSTRUCT);
 102     GINAC_ASSERT(is_ex_exactly_of_type(var_, symbol));
 103 }
 104
 105
 106 /*
 107  *  Functions overriding virtual functions from base classes
 108  */
 109
 110 basic *series::duplicate() const
 111 {
 112     debugmsg("series duplicate", LOGLEVEL_DUPLICATE);
 113     return new series(*this);
 114 }
 115
 116 void series::print(ostream &os, unsigned upper_precedence) const
 117 {
 118         debugmsg("symbol print", LOGLEVEL_PRINT);
 119         convert_to_poly().print(os, upper_precedence);
 120 }
 121
 122 void series::printraw(ostream &os) const
 123 {
 124         debugmsg("symbol printraw", LOGLEVEL_PRINT);
 125         os << "series(" << var << ";" << point << ";";
 126         for (epvector::const_iterator i=seq.begin(); i!=seq.end(); i++) {
 127                 os << "(" << (*i).rest << "," << (*i).coeff << "),";
 128         }
 129         os << ")";
 130 }
 131
 132 // Highest degree of variable
 133 int series::degree(symbol const &s) const
 134 {
 135     if (var.is_equal(s)) {
 136         // Return last exponent
 137         if (seq.size())
 138             return ex_to_numeric((*(seq.end() - 1)).coeff).to_int();
 139         else
 140             return 0;
 141     } else {
 142         epvector::const_iterator it = seq.begin(), itend = seq.end();
 143         if (it == itend)
 144             return 0;
 145         int max_pow = INT_MIN;
 146         while (it != itend) {
 147             int pow = it->rest.degree(s);
 148             if (pow > max_pow)
 149                 max_pow = pow;
 150             it++;
 151         }
 152         return max_pow;
 153     }
 154 }
 155
 156 // Lowest degree of variable
 157 int series::ldegree(symbol const &s) const
 158 {
 159     if (var.is_equal(s)) {
 160         // Return first exponent
 161         if (seq.size())
 162             return ex_to_numeric((*(seq.begin())).coeff).to_int();
 163         else
 164             return 0;
 165     } else {
 166         epvector::const_iterator it = seq.begin(), itend = seq.end();
 167         if (it == itend)
 168             return 0;
 169         int min_pow = INT_MAX;
 170         while (it != itend) {
 171             int pow = it->rest.ldegree(s);
 172             if (pow < min_pow)
 173                 min_pow = pow;
 174             it++;
 175         }
 176         return min_pow;
 177     }
 178 }
 179
 180 // Coefficient of variable
 181 ex series::coeff(symbol const &s, int const n) const
 182 {
 183     if (var.is_equal(s)) {
 184         epvector::const_iterator it = seq.begin(), itend = seq.end();
 185         while (it != itend) {
 186             int pow = ex_to_numeric(it->coeff).to_int();
 187             if (pow == n)
 188                 return it->rest;
 189             if (pow > n)
 190                 return _ex0();
 191             it++;
 192         }
 193         return _ex0();
 194     } else
 195         return convert_to_poly().coeff(s, n);
 196 }
 197
 198 ex series::eval(int level) const
 199 {
 200     if (level == 1)
 201         return this->hold();
 202
 203     // Construct a new series with evaluated coefficients
 204     epvector new_seq;
 205     new_seq.reserve(seq.size());
 206     epvector::const_iterator it = seq.begin(), itend = seq.end();
 207     while (it != itend) {
 208         new_seq.push_back(expair(it->rest.eval(level-1), it->coeff));
 209         it++;
 210     }
 211     return (new series(var, point, new_seq))->setflag(status_flags::dynallocated | status_flags::evaluated);
 212 }
 213
 214 /** Evaluate numerically.  The order term is dropped. */
 215 ex series::evalf(int level) const
 216 {
 217     return convert_to_poly().evalf(level);
 218 }
 219
 220 /*
 221  *  Construct expression (polynomial) out of series
 222  */
 223
 224 /** Convert a series object to an ordinary polynomial.
 225  *
 226  *  @param no_order flag: discard higher order terms */
 227 ex series::convert_to_poly(bool no_order) const
 228 {
 229     ex e;
 230     epvector::const_iterator it = seq.begin(), itend = seq.end();
 231
 232     while (it != itend) {
 233         if (is_order_function(it->rest)) {
 234             if (!no_order)
 235                 e += Order(power(var - point, it->coeff));
 236         } else
 237             e += it->rest * power(var - point, it->coeff);
 238         it++;
 239     }
 240     return e;
 241 }
 242
 243
 244 /*
 245  *  Implementation of series expansion
 246  */
 247
 248 /** Default implementation of ex::series(). This performs Taylor expansion.
 249  *  @see ex::series */
 250 ex basic::series(symbol const & s, ex const & point, int order) const
 251 {
 252     epvector seq;
 253     numeric fac(1);
 254     ex deriv = *this;
 255     ex coeff = deriv.subs(s == point);
 256     if (!coeff.is_zero())
 257         seq.push_back(expair(coeff, numeric(0)));
 258
 259     int n;
 260     for (n=1; n<order; n++) {
 261         fac = fac.mul(numeric(n));
 262         deriv = deriv.diff(s).expand();
 263         if (deriv.is_zero()) {
 264             // Series terminates
 265             return series::series(s, point, seq);
 266         }
 267         coeff = power(fac, -1) * deriv.subs(s == point);
 268         if (!coeff.is_zero())
 269             seq.push_back(expair(coeff, numeric(n)));
 270     }
 271
 272     // Higher-order terms, if present
 273     deriv = deriv.diff(s);
 274     if (!deriv.is_zero())
 275         seq.push_back(expair(Order(_ex1()), numeric(n)));
 276     return series::series(s, point, seq);
 277 }
 278
 279
 280 /** Add one series object to another, producing a series object that represents
 281  *  the sum.
 282  *
 283  *  @param other  series object to add with
 284  *  @return the sum as a series */
 285 ex series::add_series(const series &other) const
 286 {
 287     // Adding two series with different variables or expansion points
 288     // results in an empty (constant) series
 289     if (!is_compatible_to(other)) {
 290         epvector nul;
 291         nul.push_back(expair(Order(_ex1()), _ex0()));
 292         return series(var, point, nul);
 293     }
 294
 295     // Series addition
 296     epvector new_seq;
 297     epvector::const_iterator a = seq.begin();
 298     epvector::const_iterator b = other.seq.begin();
 299     epvector::const_iterator a_end = seq.end();
 300     epvector::const_iterator b_end = other.seq.end();
 301     int pow_a = INT_MAX, pow_b = INT_MAX;
 302     for (;;) {
 303         // If a is empty, fill up with elements from b and stop
 304         if (a == a_end) {
 305             while (b != b_end) {
 306                 new_seq.push_back(*b);
 307                 b++;
 308             }
 309             break;
 310         } else
 311             pow_a = ex_to_numeric((*a).coeff).to_int();
 312
 313         // If b is empty, fill up with elements from a and stop
 314         if (b == b_end) {
 315             while (a != a_end) {
 316                 new_seq.push_back(*a);
 317                 a++;
 318             }
 319             break;
 320         } else
 321             pow_b = ex_to_numeric((*b).coeff).to_int();
 322
 323         // a and b are non-empty, compare powers
 324         if (pow_a < pow_b) {
 325             // a has lesser power, get coefficient from a
 326             new_seq.push_back(*a);
 327             if (is_order_function((*a).rest))
 328                 break;
 329             a++;
 330         } else if (pow_b < pow_a) {
 331             // b has lesser power, get coefficient from b
 332             new_seq.push_back(*b);
 333             if (is_order_function((*b).rest))
 334                 break;
 335             b++;
 336         } else {
 337             // Add coefficient of a and b
 338             if (is_order_function((*a).rest) || is_order_function((*b).rest)) {
 339                 new_seq.push_back(expair(Order(_ex1()), (*a).coeff));
 340                 break;  // Order term ends the sequence
 341             } else {
 342                 ex sum = (*a).rest + (*b).rest;
 343                 if (!(sum.is_zero()))
 344                     new_seq.push_back(expair(sum, numeric(pow_a)));
 345                 a++;
 346                 b++;
 347             }
 348         }
 349     }
 350     return series(var, point, new_seq);
 351 }
 352
 353
 354 /** Implementation of ex::series() for sums. This performs series addition when
 355  *  adding series objects.
 356  *  @see ex::series */
 357 /*
 358 ex add::series(symbol const & s, ex const & point, int order) const
 359 {
 360     ex acc; // Series accumulator
 361
 362     // Get first term
 363     epvector::const_iterator it = seq.begin();
 364     epvector::const_iterator itend = seq.end();
 365     if (it != itend) {
 366         if (is_ex_exactly_of_type(it->rest, series))
 367             acc = it->rest;
 368         else
 369             acc = it->rest.series(s, point, order);
 370         if (!it->coeff.is_equal(_ex1()))
 371             acc = ex_to_series(acc).mul_const(ex_to_numeric(it->coeff));
 372         it++;
 373     }
 374
 375     // Add remaining terms
 376     for (; it!=itend; it++) {
 377         ex op;
 378         if (is_ex_exactly_of_type(it->rest, series))
 379             op = it->rest;
 380         else
 381             op = it->rest.series(s, point, order);
 382         if (!it->coeff.is_equal(_ex1()))
 383             op = ex_to_series(op).mul_const(ex_to_numeric(it->coeff));
 384
 385         // Series addition
 386         acc = ex_to_series(acc).add_series(ex_to_series(op));
 387     }
 388     return acc;
 389 }
 390 */
 391 ex add::series(symbol const & s, ex const & point, int order) const
 392 {
 393     ex acc; // Series accumulator
 394
 395     // Get first term from overall_coeff
 396     acc = overall_coeff.series(s,point,order);
 397
 398     // Add remaining terms
 399     epvector::const_iterator it = seq.begin();
 400     epvector::const_iterator itend = seq.end();
 401     for (; it!=itend; it++) {
 402         ex op;
 403         if (is_ex_exactly_of_type(it->rest, series))
 404             op = it->rest;
 405         else
 406             op = it->rest.series(s, point, order);
 407         if (!it->coeff.is_equal(_ex1()))
 408             op = ex_to_series(op).mul_const(ex_to_numeric(it->coeff));
 409
 410         // Series addition
 411         acc = ex_to_series(acc).add_series(ex_to_series(op));
 412     }
 413     return acc;
 414 }
 415
 416
 417 /** Multiply a series object with a numeric constant, producing a series object
 418  *  that represents the product.
 419  *
 420  *  @param other  constant to multiply with
 421  *  @return the product as a series */
 422 ex series::mul_const(const numeric &other) const
 423 {
 424     epvector new_seq;
 425     new_seq.reserve(seq.size());
 426
 427     epvector::const_iterator it = seq.begin(), itend = seq.end();
 428     while (it != itend) {
 429         if (!is_order_function(it->rest))
 430             new_seq.push_back(expair(it->rest * other, it->coeff));
 431         else
 432             new_seq.push_back(*it);
 433         it++;
 434     }
 435     return series(var, point, new_seq);
 436 }
 437
 438
 439 /** Multiply one series object to another, producing a series object that
 440  *  represents the product.
 441  *
 442  *  @param other  series object to multiply with
 443  *  @return the product as a series */
 444 ex series::mul_series(const series &other) const
 445 {
 446     // Multiplying two series with different variables or expansion points
 447     // results in an empty (constant) series
 448     if (!is_compatible_to(other)) {
 449         epvector nul;
 450         nul.push_back(expair(Order(_ex1()), _ex0()));
 451         return series(var, point, nul);
 452     }
 453
 454     // Series multiplication
 455     epvector new_seq;
 456
 457     const symbol *s = static_cast<symbol *>(var.bp);
 458     int a_max = degree(*s);
 459     int b_max = other.degree(*s);
 460     int a_min = ldegree(*s);
 461     int b_min = other.ldegree(*s);
 462     int cdeg_min = a_min + b_min;
 463     int cdeg_max = a_max + b_max;
 464
 465     int higher_order_a = INT_MAX;
 466     int higher_order_b = INT_MAX;
 467     if (is_order_function(coeff(*s, a_max)))
 468         higher_order_a = a_max + b_min;
 469     if (is_order_function(other.coeff(*s, b_max)))
 470         higher_order_b = b_max + a_min;
 471     int higher_order_c = min(higher_order_a, higher_order_b);
 472     if (cdeg_max >= higher_order_c)
 473         cdeg_max = higher_order_c - 1;
 474
 475     for (int cdeg=cdeg_min; cdeg<=cdeg_max; cdeg++) {
 476         ex co = _ex0();
 477         // c(i)=a(0)b(i)+...+a(i)b(0)
 478         for (int i=a_min; cdeg-i>=b_min; i++) {
 479             ex a_coeff = coeff(*s, i);
 480             ex b_coeff = other.coeff(*s, cdeg-i);
 481             if (!is_order_function(a_coeff) && !is_order_function(b_coeff))
 482                 co += coeff(*s, i) * other.coeff(*s, cdeg-i);
 483         }
 484         if (!co.is_zero())
 485             new_seq.push_back(expair(co, numeric(cdeg)));
 486     }
 487     if (higher_order_c < INT_MAX)
 488         new_seq.push_back(expair(Order(_ex1()), numeric(higher_order_c)));
 489     return series::series(var, point, new_seq);
 490 }
 491
 492
 493 /*
 494 ex mul::series(symbol const & s, ex const & point, int order) const
 495 {
 496     ex acc; // Series accumulator
 497
 498     // Get first term
 499     epvector::const_iterator it = seq.begin();
 500     epvector::const_iterator itend = seq.end();
 501     if (it != itend) {
 502         if (is_ex_exactly_of_type(it->rest, series))
 503             acc = it->rest;
 504         else
 505             acc = it->rest.series(s, point, order);
 506         if (!it->coeff.is_equal(_ex1()))
 507             acc = ex_to_series(acc).power_const(ex_to_numeric(it->coeff), order);
 508         it++;
 509     }
 510
 511     // Multiply with remaining terms
 512     for (; it!=itend; it++) {
 513         ex op = it->rest;
 514         if (op.info(info_flags::numeric)) {
 515             // series * const (special case, faster)
 516             ex f = power(op, it->coeff);
 517             acc = ex_to_series(acc).mul_const(ex_to_numeric(f));
 518             continue;
 519         } else if (!is_ex_exactly_of_type(op, series))
 520             op = op.series(s, point, order);
 521         if (!it->coeff.is_equal(_ex1()))
 522             op = ex_to_series(op).power_const(ex_to_numeric(it->coeff), order);
 523
 524         // Series multiplication
 525         acc = ex_to_series(acc).mul_series(ex_to_series(op));
 526     }
 527     return acc;
 528 }
 529 */
 530
 531 /** Implementation of ex::series() for product. This performs series
 532  *  multiplication when multiplying series.
 533  *  @see ex::series */
 534 ex mul::series(symbol const & s, ex const & point, int order) const
 535 {
 536     ex acc; // Series accumulator
 537
 538     // Get first term from overall_coeff
 539     acc = overall_coeff.series(s, point, order);
 540
 541     // Multiply with remaining terms
 542     epvector::const_iterator it = seq.begin();
 543     epvector::const_iterator itend = seq.end();
 544     for (; it!=itend; it++) {
 545         ex op = it->rest;
 546         if (op.info(info_flags::numeric)) {
 547             // series * const (special case, faster)
 548             ex f = power(op, it->coeff);
 549             acc = ex_to_series(acc).mul_const(ex_to_numeric(f));
 550             continue;
 551         } else if (!is_ex_exactly_of_type(op, series))
 552             op = op.series(s, point, order);
 553         if (!it->coeff.is_equal(_ex1()))
 554             op = ex_to_series(op).power_const(ex_to_numeric(it->coeff), order);
 555
 556         // Series multiplication
 557         acc = ex_to_series(acc).mul_series(ex_to_series(op));
 558     }
 559     return acc;
 560 }
 561
 562
 563 /** Compute the p-th power of a series.
 564  *
 565  *  @param p  power to compute
 566  *  @param deg  truncation order of series calculation */
 567 ex series::power_const(const numeric &p, int deg) const
 568 {
 569     int i;
 570     const symbol *s = static_cast<symbol *>(var.bp);
 571     int ldeg = ldegree(*s);
 572
 573     // Calculate coefficients of powered series
 574     exvector co;
 575     co.reserve(deg);
 576     ex co0;
 577     co.push_back(co0 = power(coeff(*s, ldeg), p));
 578     bool all_sums_zero = true;
 579     for (i=1; i<deg; i++) {
 580         ex sum = _ex0();
 581         for (int j=1; j<=i; j++) {
 582             ex c = coeff(*s, j + ldeg);
 583             if (is_order_function(c)) {
 584                 co.push_back(Order(_ex1()));
 585                 break;
 586             } else
 587                 sum += (p * j - (i - j)) * co[i - j] * c;
 588         }
 589         if (!sum.is_zero())
 590             all_sums_zero = false;
 591         co.push_back(co0 * sum / numeric(i));
 592     }
 593
 594     // Construct new series (of non-zero coefficients)
 595     epvector new_seq;
 596     bool higher_order = false;
 597     for (i=0; i<deg; i++) {
 598         if (!co[i].is_zero())
 599             new_seq.push_back(expair(co[i], numeric(i) + p * ldeg));
 600         if (is_order_function(co[i])) {
 601             higher_order = true;
 602             break;
 603         }
 604     }
 605     if (!higher_order && !all_sums_zero)
 606         new_seq.push_back(expair(Order(_ex1()), numeric(deg) + p * ldeg));
 607     return series::series(var, point, new_seq);
 608 }
 609
 610
 611 /** Implementation of ex::series() for powers. This performs Laurent expansion
 612  *  of reciprocals of series at singularities.
 613  *  @see ex::series */
 614 ex power::series(symbol const & s, ex const & point, int order) const
 615 {
 616     ex e;
 617     if (!is_ex_exactly_of_type(basis, series)) {
 618         // Basis is not a series, may there be a singulary?
 619         if (!exponent.info(info_flags::negint))
 620             return basic::series(s, point, order);
 621
 622         // Expression is of type something^(-int), check for singularity
 623         if (!basis.subs(s == point).is_zero())
 624             return basic::series(s, point, order);
 625
 626         // Singularity encountered, expand basis into series
 627         e = basis.series(s, point, order);
 628     } else {
 629         // Basis is a series
 630         e = basis;
 631     }
 632
 633     // Power e
 634     return ex_to_series(e).power_const(ex_to_numeric(exponent), order);
 635 }
 636
 637
 638 /** Compute the truncated series expansion of an expression.
 639  *  This function returns an expression containing an object of class series to
 640  *  represent the series. If the series does not terminate within the given
 641  *  truncation order, the last term of the series will be an order term.
 642  *
 643  *  @param s  expansion variable
 644  *  @param point  expansion point
 645  *  @param order  truncation order of series calculations
 646  *  @return an expression holding a series object */
 647 ex ex::series(symbol const &s, ex const &point, int order) const
 648 {
 649     GINAC_ASSERT(bp!=0);
 650     return bp->series(s, point, order);
 651 }
 652
 653
 654 // Global constants
 655 const series some_series;
 656 type_info const & typeid_series = typeid(some_series);
 657
 658 #ifndef NO_GINAC_NAMESPACE
 659 } // namespace GiNaC
 660 #endif // ndef NO_GINAC_NAMESPACE