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