X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fpseries.cpp;h=a99725e56e98e93b61ad0ce2d73580ab0de1d974;hp=4cccdd2916ead73c28aa774dca197fc7f3c3263a;hb=f78b1f296310b5f1c01b74c9fb10dd33af2a8f4a;hpb=27d6204effdef95a00af461fff98024e290dbaa7

diff --git a/ginac/pseries.cpp b/ginac/pseries.cpp
index 4cccdd29..a99725e5 100644
--- a/ginac/pseries.cpp
+++ b/ginac/pseries.cpp
@@ -4,7 +4,7 @@
  *  methods for series expansion. */
 
 /*
- *  GiNaC Copyright (C) 1999-2001 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
@@ -21,6 +21,7 @@
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#include <iostream>
 #include <stdexcept>
 
 #include "pseries.h"
@@ -30,35 +31,26 @@
 #include "mul.h"
 #include "power.h"
 #include "relational.h"
+#include "operators.h"
 #include "symbol.h"
-#include "print.h"
 #include "archive.h"
 #include "utils.h"
-#include "debugmsg.h"
 
 namespace GiNaC {
 
-GINAC_IMPLEMENT_REGISTERED_CLASS(pseries, basic)
+GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(pseries, basic,
+  print_func<print_context>(&pseries::do_print).
+  print_func<print_latex>(&pseries::do_print_latex).
+  print_func<print_tree>(&pseries::do_print_tree).
+  print_func<print_python>(&pseries::do_print_python).
+  print_func<print_python_repr>(&pseries::do_print_python_repr))
 
 
 /*
- *  Default ctor, dtor, copy ctor, assignment operator and helpers
+ *  Default constructor
  */
 
-pseries::pseries() : basic(TINFO_pseries)
-{
-	debugmsg("pseries default ctor", LOGLEVEL_CONSTRUCT);
-}
-
-void pseries::copy(const pseries &other)
-{
-	inherited::copy(other);
-	seq = other.seq;
-	var = other.var;
-	point = other.point;
-}
-
-DEFAULT_DESTROY(pseries)
+pseries::pseries() : inherited(TINFO_pseries) { }
 
 
 /*
@@ -76,9 +68,8 @@ DEFAULT_DESTROY(pseries)
  *  @return newly constructed pseries */
 pseries::pseries(const ex &rel_, const epvector &ops_) : basic(TINFO_pseries), seq(ops_)
 {
-	debugmsg("pseries ctor from ex,epvector", LOGLEVEL_CONSTRUCT);
-	GINAC_ASSERT(is_exactly_a<relational>(rel_));
-	GINAC_ASSERT(is_exactly_a<symbol>(rel_.lhs()));
+	GINAC_ASSERT(is_a<relational>(rel_));
+	GINAC_ASSERT(is_a<symbol>(rel_.lhs()));
 	point = rel_.rhs();
 	var = rel_.lhs();
 }
@@ -88,9 +79,8 @@ pseries::pseries(const ex &rel_, const epvector &ops_) : basic(TINFO_pseries), s
  *  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)
 {
-	debugmsg("pseries ctor from archive_node", LOGLEVEL_CONSTRUCT);
 	for (unsigned int i=0; true; ++i) {
 		ex rest;
 		ex coeff;
@@ -122,88 +112,113 @@ DEFAULT_UNARCHIVE(pseries)
 // functions overriding virtual functions from base classes
 //////////
 
-void pseries::print(const print_context & c, unsigned level) const
+void pseries::print_series(const print_context & c, const char *openbrace, const char *closebrace, const char *mul_sym, const char *pow_sym, unsigned level) const
 {
-	debugmsg("pseries print", LOGLEVEL_PRINT);
+	if (precedence() <= level)
+		c.s << '(';
+		
+	// objects of type pseries must not have any zero entries, so the
+	// trivial (zero) pseries needs a special treatment here:
+	if (seq.empty())
+		c.s << '0';
 
-	if (is_a<print_tree>(c)) {
+	epvector::const_iterator i = seq.begin(), end = seq.end();
+	while (i != end) {
 
-		c.s << std::string(level, ' ') << class_name()
-		    << 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) {
-			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;
-		}
-		var.print(c, level + delta_indent);
-		point.print(c, level + delta_indent);
+		// print a sign, if needed
+		if (i != seq.begin())
+			c.s << '+';
 
-	} else {
+		if (!is_order_function(i->rest)) {
 
-		if (precedence() <= level)
-			c.s << "(";
-		
-		std::string par_open = is_a<print_latex>(c) ? "{(" : "(";
-		std::string par_close = is_a<print_latex>(c) ? ")}" : ")";
-		
-		// objects of type pseries must not have any zero entries, so the
-		// trivial (zero) pseries needs a special treatment here:
-		if (seq.empty())
-			c.s << '0';
-		epvector::const_iterator i = seq.begin(), end = seq.end();
-		while (i != end) {
-			// print a sign, if needed
-			if (i != seq.begin())
-				c.s << '+';
-			if (!is_order_function(i->rest)) {
-				// print 'rest', i.e. the expansion coefficient
-				if (i->rest.info(info_flags::numeric) &&
-					i->rest.info(info_flags::positive)) {
-					i->rest.print(c);
-				} else {
-					c.s << par_open;
-					i->rest.print(c);
-					c.s << par_close;
-				}
-				// print 'coeff', something like (x-1)^42
-				if (!i->coeff.is_zero()) {
-					if (is_a<print_latex>(c))
-						c.s << ' ';
-					else
-						c.s << '*';
-					if (!point.is_zero()) {
-						c.s << par_open;
-						(var-point).print(c);
-						c.s << par_close;
+			// print 'rest', i.e. the expansion coefficient
+			if (i->rest.info(info_flags::numeric) &&
+				i->rest.info(info_flags::positive)) {
+				i->rest.print(c);
+			} else {
+				c.s << openbrace << '(';
+				i->rest.print(c);
+				c.s << ')' << closebrace;
+			}
+
+			// print 'coeff', something like (x-1)^42
+			if (!i->coeff.is_zero()) {
+				c.s << mul_sym;
+				if (!point.is_zero()) {
+					c.s << openbrace << '(';
+					(var-point).print(c);
+					c.s << ')' << closebrace;
+				} else
+					var.print(c);
+				if (i->coeff.compare(_ex1)) {
+					c.s << pow_sym;
+					c.s << openbrace;
+					if (i->coeff.info(info_flags::negative)) {
+						c.s << '(';
+						i->coeff.print(c);
+						c.s << ')';
 					} else
-						var.print(c);
-					if (i->coeff.compare(_ex1)) {
-						c.s << '^';
-						if (i->coeff.info(info_flags::negative)) {
-							c.s << par_open;
-							i->coeff.print(c);
-							c.s << par_close;
-						} else {
-							if (is_a<print_latex>(c)) {
-								c.s << '{';
-								i->coeff.print(c);
-								c.s << '}';
-							} else
-								i->coeff.print(c);
-						}
-					}
+						i->coeff.print(c);
+					c.s << closebrace;
 				}
-			} else
-				Order(power(var-point,i->coeff)).print(c);
-			++i;
-		}
+			}
+		} else
+			Order(power(var-point,i->coeff)).print(c);
+		++i;
+	}
+
+	if (precedence() <= level)
+		c.s << ')';
+}
 
-		if (precedence() <= level)
-			c.s << ")";
+void pseries::do_print(const print_context & c, unsigned level) const
+{
+	print_series(c, "", "", "*", "^", level);
+}
+
+void pseries::do_print_latex(const print_latex & c, unsigned level) const
+{
+	print_series(c, "{", "}", " ", "^", level);
+}
+
+void pseries::do_print_python(const print_python & c, unsigned level) const
+{
+	print_series(c, "", "", "*", "**", level);
+}
+
+void pseries::do_print_tree(const print_tree & c, unsigned level) const
+{
+	c.s << std::string(level, ' ') << class_name() << " @" << this
+	    << std::hex << ", hash=0x" << hashvalue << ", flags=0x" << flags << std::dec
+	    << std::endl;
+	size_t num = seq.size();
+	for (size_t i=0; i<num; ++i) {
+		seq[i].rest.print(c, level + c.delta_indent);
+		seq[i].coeff.print(c, level + c.delta_indent);
+		c.s << std::string(level + c.delta_indent, ' ') << "-----" << std::endl;
 	}
+	var.print(c, level + c.delta_indent);
+	point.print(c, level + c.delta_indent);
+}
+
+void pseries::do_print_python_repr(const print_python_repr & c, unsigned level) const
+{
+	c.s << class_name() << "(relational(";
+	var.print(c);
+	c.s << ',';
+	point.print(c);
+	c.s << "),[";
+	size_t num = seq.size();
+	for (size_t i=0; i<num; ++i) {
+		if (i)
+			c.s << ',';
+		c.s << '(';
+		seq[i].rest.print(c);
+		c.s << ',';
+		seq[i].coeff.print(c);
+		c.s << ')';
+	}
+	c.s << "])";
 }
 
 int pseries::compare_same_type(const basic & other) const
@@ -240,22 +255,18 @@ int pseries::compare_same_type(const basic & other) const
 }
 
 /** 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
@@ -396,13 +407,13 @@ ex pseries::evalf(int level) const
 	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
@@ -410,10 +421,10 @@ ex pseries::subs(const lst & ls, const lst & lr, bool no_pattern) const
 	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
@@ -432,14 +443,14 @@ ex pseries::expand(unsigned options) const
 	        ->setflag(status_flags::dynallocated | (options == 0 ? status_flags::expanded : 0));
 }
 
-/** Implementation of ex::diff() for a power series.  It treats the series as a
- *  polynomial.
+/** Implementation of ex::diff() for a power series.
  *  @see ex::diff */
 ex pseries::derivative(const symbol & s) const
 {
+	epvector new_seq;
+	epvector::const_iterator it = seq.begin(), itend = seq.end();
+
 	if (s == var) {
-		epvector new_seq;
-		epvector::const_iterator it = seq.begin(), itend = seq.end();
 		
 		// FIXME: coeff might depend on var
 		while (it != itend) {
@@ -452,10 +463,22 @@ ex pseries::derivative(const symbol & s) const
 			}
 			++it;
 		}
-		return pseries(relational(var,point), new_seq);
+
 	} else {
-		return *this;
+
+		while (it != itend) {
+			if (is_order_function(it->rest)) {
+				new_seq.push_back(*it);
+			} else {
+				ex c = it->rest.diff(s);
+				if (!c.is_zero())
+					new_seq.push_back(expair(c, it->coeff));
+			}
+			++it;
+		}
 	}
+
+	return pseries(relational(var,point), new_seq);
 }
 
 ex pseries::convert_to_poly(bool no_order) const
@@ -474,7 +497,7 @@ ex pseries::convert_to_poly(bool no_order) const
 	return e;
 }
 
-bool pseries::is_terminating(void) const
+bool pseries::is_terminating() const
 {
 	return seq.empty() || !is_order_function((seq.end()-1)->rest);
 }
@@ -491,7 +514,7 @@ ex basic::series(const relational & r, int order, unsigned options) const
 	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())
@@ -507,7 +530,7 @@ ex basic::series(const relational & r, int order, unsigned options) const
 		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));
 	}
@@ -526,7 +549,7 @@ ex symbol::series(const relational & r, int order, unsigned options) const
 {
 	epvector seq;
 	const ex point = r.rhs();
-	GINAC_ASSERT(is_exactly_a<symbol>(r.lhs()));
+	GINAC_ASSERT(is_a<symbol>(r.lhs()));
 
 	if (this->is_equal_same_type(ex_to<symbol>(r.lhs()))) {
 		if (order > 0 && !point.is_zero())
@@ -630,7 +653,7 @@ ex add::series(const relational & r, int order, unsigned options) const
 	epvector::const_iterator itend = seq.end();
 	for (; it!=itend; ++it) {
 		ex op;
-		if (is_ex_exactly_of_type(it->rest, pseries))
+		if (is_exactly_a<pseries>(it->rest))
 			op = it->rest;
 		else
 			op = it->rest.series(r, order, options);
@@ -843,13 +866,13 @@ pseries pseries::shift_exponents(int deg) const
 ex power::series(const relational & r, int order, unsigned options) const
 {
 	// If basis is already a series, just power it
-	if (is_ex_exactly_of_type(basis, pseries))
+	if (is_exactly_a<pseries>(basis))
 		return ex_to<pseries>(basis).power_const(ex_to<numeric>(exponent), order);
 
 	// 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;
 	}
@@ -859,7 +882,7 @@ ex power::series(const relational & r, int order, unsigned options) const
 		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)?
@@ -882,7 +905,7 @@ ex power::series(const relational & r, int order, unsigned options) const
 ex pseries::series(const relational & r, int order, unsigned options) const
 {
 	const ex p = r.rhs();
-	GINAC_ASSERT(is_exactly_a<symbol>(r.lhs()));
+	GINAC_ASSERT(is_a<symbol>(r.lhs()));
 	const symbol &s = ex_to<symbol>(r.lhs());
 	
 	if (var.is_equal(s) && point.is_equal(p)) {
@@ -918,13 +941,12 @@ ex pseries::series(const relational & r, int order, unsigned options) const
  *  @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_ex_exactly_of_type(r,relational))
+	if (is_a<relational>(r))
 		rel_ = ex_to<relational>(r);
-	else if (is_ex_exactly_of_type(r,symbol))
+	else if (is_a<symbol>(r))
 		rel_ = relational(r,_ex0);
 	else
 		throw (std::logic_error("ex::series(): expansion point has unknown type"));