* methods for series expansion. */
/*
- * GiNaC Copyright (C) 1999-2002 Johannes Gutenberg University Mainz, Germany
+ * GiNaC Copyright (C) 1999-2003 Johannes Gutenberg University Mainz, Germany
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
#include "mul.h"
#include "power.h"
#include "relational.h"
+#include "operators.h"
#include "symbol.h"
-#include "print.h"
#include "archive.h"
#include "utils.h"
/*
- * Default ctor, dtor, copy ctor, assignment operator and helpers
+ * Default constructor
*/
pseries::pseries() : inherited(TINFO_pseries) { }
-void pseries::copy(const pseries &other)
-{
- inherited::copy(other);
- seq = other.seq;
- var = other.var;
- point = other.point;
-}
-
-DEFAULT_DESTROY(pseries)
-
/*
* Other ctors
* Archiving
*/
-pseries::pseries(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst)
+pseries::pseries(const archive_node &n, lst &sym_lst) : inherited(n, sym_lst)
{
for (unsigned int i=0; true; ++i) {
ex rest;
<< std::hex << ", hash=0x" << hashvalue << ", flags=0x" << flags << std::dec
<< std::endl;
unsigned delta_indent = static_cast<const print_tree &>(c).delta_indent;
- unsigned num = seq.size();
- for (unsigned i=0; i<num; ++i) {
+ size_t num = seq.size();
+ for (size_t i=0; i<num; ++i) {
seq[i].rest.print(c, level + delta_indent);
seq[i].coeff.print(c, level + delta_indent);
c.s << std::string(level + delta_indent, ' ') << "-----" << std::endl;
c.s << ',';
point.print(c);
c.s << "),[";
- unsigned num = seq.size();
- for (unsigned i=0; i<num; ++i) {
+ size_t num = seq.size();
+ for (size_t i=0; i<num; ++i) {
if (i)
c.s << ',';
c.s << '(';
}
/** Return the number of operands including a possible order term. */
-unsigned pseries::nops(void) const
+size_t pseries::nops() const
{
return seq.size();
}
/** Return the ith term in the series when represented as a sum. */
-ex pseries::op(int i) const
+ex pseries::op(size_t i) const
{
- if (i < 0 || unsigned(i) >= seq.size())
+ if (i >= seq.size())
throw (std::out_of_range("op() out of range"));
- return seq[i].rest * power(var - point, seq[i].coeff);
-}
-ex &pseries::let_op(int i)
-{
- throw (std::logic_error("let_op not defined for pseries"));
+ return seq[i].rest * power(var - point, seq[i].coeff);
}
/** Return degree of highest power of the series. This is usually the exponent
return (new pseries(relational(var,point), new_seq))->setflag(status_flags::dynallocated | status_flags::evaluated);
}
-ex pseries::subs(const lst & ls, const lst & lr, bool no_pattern) const
+ex pseries::subs(const exmap & m, unsigned options) const
{
// If expansion variable is being substituted, convert the series to a
// polynomial and do the substitution there because the result might
// no longer be a power series
- if (ls.has(var))
- return convert_to_poly(true).subs(ls, lr, no_pattern);
+ if (m.find(var) != m.end())
+ return convert_to_poly(true).subs(m, options);
// Otherwise construct a new series with substituted coefficients and
// expansion point
newseq.reserve(seq.size());
epvector::const_iterator it = seq.begin(), itend = seq.end();
while (it != itend) {
- newseq.push_back(expair(it->rest.subs(ls, lr, no_pattern), it->coeff));
+ newseq.push_back(expair(it->rest.subs(m, options), it->coeff));
++it;
}
- return (new pseries(relational(var,point.subs(ls, lr, no_pattern)), newseq))->setflag(status_flags::dynallocated);
+ return (new pseries(relational(var,point.subs(m, options)), newseq))->setflag(status_flags::dynallocated);
}
/** Implementation of ex::expand() for a power series. It expands all the
return e;
}
-bool pseries::is_terminating(void) const
+bool pseries::is_terminating() const
{
return seq.empty() || !is_order_function((seq.end()-1)->rest);
}
epvector seq;
numeric fac = 1;
ex deriv = *this;
- ex coeff = deriv.subs(r);
+ ex coeff = deriv.subs(r, subs_options::no_pattern);
const symbol &s = ex_to<symbol>(r.lhs());
if (!coeff.is_zero())
if (deriv.is_zero()) // Series terminates
return pseries(r, seq);
- coeff = deriv.subs(r);
+ coeff = deriv.subs(r, subs_options::no_pattern);
if (!coeff.is_zero())
seq.push_back(expair(fac.inverse() * coeff, n));
}
// Basis is not a series, may there be a singularity?
bool must_expand_basis = false;
try {
- basis.subs(r);
+ basis.subs(r, subs_options::no_pattern);
} catch (pole_error) {
must_expand_basis = true;
}
return basic::series(r, order, options);
// Is the expression of type 0^something?
- if (!must_expand_basis && !basis.subs(r).is_zero())
+ if (!must_expand_basis && !basis.subs(r, subs_options::no_pattern).is_zero())
return basic::series(r, order, options);
// Singularity encountered, is the basis equal to (var - point)?
* @return an expression holding a pseries object */
ex ex::series(const ex & r, int order, unsigned options) const
{
- GINAC_ASSERT(bp!=0);
ex e;
relational rel_;
- if (is_exactly_a<relational>(r))
+ if (is_a<relational>(r))
rel_ = ex_to<relational>(r);
else if (is_a<symbol>(r))
rel_ = relational(r,_ex0);