* Check polynomialism of resultant() args.

[ginac.git] / ginac / inifcns_gamma.cpp

diff --git a/ginac/inifcns_gamma.cpp b/ginac/inifcns_gamma.cpp
index fc4a992c97acc6db876bbb1c61ac9818fd0c21eb..8d01127b9fc53490ab1d633e45342839b4739733 100644 (file)
--- a/ginac/inifcns_gamma.cpp
+++ b/ginac/inifcns_gamma.cpp
@@ -4,7 +4,7 @@
  *  some related stuff. */
 
 /*
- *  GiNaC Copyright (C) 1999-2003 Johannes Gutenberg University Mainz, Germany
+ *  GiNaC Copyright (C) 1999-2004 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
@@ -98,7 +98,7 @@ static ex lgamma_series(const ex & arg,
        // from which follows
        //   series(lgamma(x),x==-m,order) ==
        //   series(lgamma(x+m+1)-log(x)...-log(x+m)),x==-m,order);
-       const ex arg_pt = arg.subs(rel);
+       const ex arg_pt = arg.subs(rel, subs_options::no_pattern);
        if (!arg_pt.info(info_flags::integer) || arg_pt.info(info_flags::positive))
                throw do_taylor();  // caught by function::series()
        // if we got here we have to care for a simple pole of tgamma(-m):
@@ -193,8 +193,8 @@ static ex tgamma_series(const ex & arg,
        //   tgamma(x) == tgamma(x+1) / x
        // from which follows
        //   series(tgamma(x),x==-m,order) ==
-       //   series(tgamma(x+m+1)/(x*(x+1)*...*(x+m)),x==-m,order+1);
-       const ex arg_pt = arg.subs(rel);
+       //   series(tgamma(x+m+1)/(x*(x+1)*...*(x+m)),x==-m,order);
+       const ex arg_pt = arg.subs(rel, subs_options::no_pattern);
        if (!arg_pt.info(info_flags::integer) || arg_pt.info(info_flags::positive))
                throw do_taylor();  // caught by function::series()
        // if we got here we have to care for a simple pole at -m:
@@ -202,7 +202,7 @@ static ex tgamma_series(const ex & arg,
        ex ser_denom = _ex1;
        for (numeric p; p<=m; ++p)
                ser_denom *= arg+p;
-       return (tgamma(arg+m+_ex1)/ser_denom).series(rel, order+1, options);
+       return (tgamma(arg+m+_ex1)/ser_denom).series(rel, order, options);
 }
 
 
@@ -294,8 +294,8 @@ static ex beta_series(const ex & arg1,
        // Taylor series where there is no pole of one of the tgamma functions
        // falls back to beta function evaluation.  Otherwise, fall back to
        // tgamma series directly.
-       const ex arg1_pt = arg1.subs(rel);
-       const ex arg2_pt = arg2.subs(rel);
+       const ex arg1_pt = arg1.subs(rel, subs_options::no_pattern);
+       const ex arg2_pt = arg2.subs(rel, subs_options::no_pattern);
        GINAC_ASSERT(is_a<symbol>(rel.lhs()));
        const symbol &s = ex_to<symbol>(rel.lhs());
        ex arg1_ser, arg2_ser, arg1arg2_ser;
@@ -304,19 +304,19 @@ static ex beta_series(const ex & arg1,
                throw do_taylor();  // caught by function::series()
        // trap the case where arg1 is on a pole:
        if (arg1.info(info_flags::integer) && !arg1.info(info_flags::positive))
-               arg1_ser = tgamma(arg1+s).series(rel, order, options);
+               arg1_ser = tgamma(arg1+s);
        else
-               arg1_ser = tgamma(arg1).series(rel,order);
+               arg1_ser = tgamma(arg1);
        // trap the case where arg2 is on a pole:
        if (arg2.info(info_flags::integer) && !arg2.info(info_flags::positive))
-               arg2_ser = tgamma(arg2+s).series(rel, order, options);
+               arg2_ser = tgamma(arg2+s);
        else
-               arg2_ser = tgamma(arg2).series(rel,order);
+               arg2_ser = tgamma(arg2);
        // trap the case where arg1+arg2 is on a pole:
        if ((arg1+arg2).info(info_flags::integer) && !(arg1+arg2).info(info_flags::positive))
-               arg1arg2_ser = tgamma(arg2+arg1+s).series(rel, order, options);
+               arg1arg2_ser = tgamma(arg2+arg1+s);
        else
-               arg1arg2_ser = tgamma(arg2+arg1).series(rel,order);
+               arg1arg2_ser = tgamma(arg2+arg1);
        // compose the result (expanding all the terms):
        return (arg1_ser*arg2_ser/arg1arg2_ser).series(rel, order, options).expand();
 }
@@ -411,7 +411,7 @@ static ex psi1_series(const ex & arg,
        // from which follows
        //   series(psi(x),x==-m,order) ==
        //   series(psi(x+m+1) - 1/x - 1/(x+1) - 1/(x+m)),x==-m,order);
-       const ex arg_pt = arg.subs(rel);
+       const ex arg_pt = arg.subs(rel, subs_options::no_pattern);
        if (!arg_pt.info(info_flags::integer) || arg_pt.info(info_flags::positive))
                throw do_taylor();  // caught by function::series()
        // if we got here we have to care for a simple pole at -m:
@@ -423,7 +423,7 @@ static ex psi1_series(const ex & arg,
 }
 
 unsigned psi1_SERIAL::serial =
-       function::register_new(function_options("psi").
+       function::register_new(function_options("psi", 1).
                               eval_func(psi1_eval).
                               evalf_func(psi1_evalf).
                               derivative_func(psi1_deriv).
@@ -538,7 +538,7 @@ static ex psi2_series(const ex & n,
        //   series(psi(x),x==-m,order) == 
        //   series(psi(x+m+1) - (-1)^n * n! * ((x)^(-n-1) + (x+1)^(-n-1) + ...
        //                                      ... + (x+m)^(-n-1))),x==-m,order);
-       const ex arg_pt = arg.subs(rel);
+       const ex arg_pt = arg.subs(rel, subs_options::no_pattern);
        if (!arg_pt.info(info_flags::integer) || arg_pt.info(info_flags::positive))
                throw do_taylor();  // caught by function::series()
        // if we got here we have to care for a pole of order n+1 at -m:
@@ -551,7 +551,7 @@ static ex psi2_series(const ex & n,
 }
 
 unsigned psi2_SERIAL::serial =
-       function::register_new(function_options("psi").
+       function::register_new(function_options("psi", 2).
                               eval_func(psi2_eval).
                               evalf_func(psi2_evalf).
                               derivative_func(psi2_deriv).