X-Git-Url: https://ginac.de/ginac.git//ginac.git?a=blobdiff_plain;f=ginac%2Fnormal.cpp;h=334bf95ae78647b496a193cd5d47b2f60269b090;hb=85ce9664ddba79c28a6945b1e5b4e2b71f77cb51;hp=067670ced9f380b7aff2623755bde19f72704293;hpb=075877089921f3555f040cd953a6ce75d0d544d8;p=ginac.git diff --git a/ginac/normal.cpp b/ginac/normal.cpp index 067670ce..334bf95a 100644 --- a/ginac/normal.cpp +++ b/ginac/normal.cpp @@ -23,7 +23,6 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ -#include #include #include @@ -34,7 +33,6 @@ #include "constant.h" #include "expairseq.h" #include "fail.h" -#include "indexed.h" #include "inifcns.h" #include "lst.h" #include "mul.h" @@ -46,9 +44,7 @@ #include "symbol.h" #include "utils.h" -#ifndef NO_NAMESPACE_GINAC namespace GiNaC { -#endif // ndef NO_NAMESPACE_GINAC // If comparing expressions (ex::compare()) is fast, you can set this to 1. // Some routines like quo(), rem() and gcd() will then return a quick answer @@ -140,8 +136,17 @@ struct sym_desc { /** Maximum of deg_a and deg_b (Used for sorting) */ int max_deg; + /** Maximum number of terms of leading coefficient of symbol in both polynomials */ + int max_lcnops; + /** Commparison operator for sorting */ - bool operator<(const sym_desc &x) const {return max_deg < x.max_deg;} + bool operator<(const sym_desc &x) const + { + if (max_deg == x.max_deg) + return max_lcnops < x.max_lcnops; + else + return max_deg < x.max_deg; + } }; // Vector of sym_desc structures @@ -196,7 +201,8 @@ static void get_symbol_stats(const ex &a, const ex &b, sym_desc_vec &v) int deg_b = b.degree(*(it->sym)); it->deg_a = deg_a; it->deg_b = deg_b; - it->max_deg = std::max(deg_a,deg_b); + it->max_deg = std::max(deg_a, deg_b); + it->max_lcnops = std::max(a.lcoeff(*(it->sym)).nops(), b.lcoeff(*(it->sym)).nops()); it->ldeg_a = a.ldegree(*(it->sym)); it->ldeg_b = b.ldegree(*(it->sym)); it++; @@ -206,7 +212,7 @@ static void get_symbol_stats(const ex &a, const ex &b, sym_desc_vec &v) std::clog << "Symbols:\n"; it = v.begin(); itend = v.end(); while (it != itend) { - std::clog << " " << *it->sym << ": deg_a=" << it->deg_a << ", deg_b=" << it->deg_b << ", ldeg_a=" << it->ldeg_a << ", ldeg_b=" << it->ldeg_b << ", max_deg=" << it->max_deg << endl; + std::clog << " " << *it->sym << ": deg_a=" << it->deg_a << ", deg_b=" << it->deg_b << ", ldeg_a=" << it->ldeg_a << ", ldeg_b=" << it->ldeg_b << ", max_deg=" << it->max_deg << ", max_lcnops=" << it->max_lcnops << endl; std::clog << " lcoeff_a=" << a.lcoeff(*(it->sym)) << ", lcoeff_b=" << b.lcoeff(*(it->sym)) << endl; it++; } @@ -234,8 +240,12 @@ static numeric lcmcoeff(const ex &e, const numeric &l) for (unsigned i=0; i ex2; typedef std::pair exbool; struct ex2_less { - bool operator() (const ex2 p, const ex2 q) const + bool operator() (const ex2 &p, const ex2 &q) const { - return p.first.compare(q.first) < 0 || (!(q.first.compare(p.first) < 0) && p.second.compare(q.second) < 0); + int cmp = p.first.compare(q.first); + return ((cmp<0) || (!(cmp>0) && p.second.compare(q.second)<0)); } }; @@ -1174,6 +1188,8 @@ numeric ex::max_coefficient(void) const return bp->max_coefficient(); } +/** Implementation ex::max_coefficient(). + * @see heur_gcd */ numeric basic::max_coefficient(void) const { return _num1(); @@ -1236,11 +1252,7 @@ ex basic::smod(const numeric &xi) const ex numeric::smod(const numeric &xi) const { -#ifndef NO_NAMESPACE_GINAC return GiNaC::smod(*this, xi); -#else // ndef NO_NAMESPACE_GINAC - return ::smod(*this, xi); -#endif // ndef NO_NAMESPACE_GINAC } ex add::smod(const numeric &xi) const @@ -1251,21 +1263,13 @@ ex add::smod(const numeric &xi) const epvector::const_iterator itend = seq.end(); while (it != itend) { GINAC_ASSERT(!is_ex_exactly_of_type(it->rest,numeric)); -#ifndef NO_NAMESPACE_GINAC numeric coeff = GiNaC::smod(ex_to_numeric(it->coeff), xi); -#else // ndef NO_NAMESPACE_GINAC - numeric coeff = ::smod(ex_to_numeric(it->coeff), xi); -#endif // ndef NO_NAMESPACE_GINAC if (!coeff.is_zero()) newseq.push_back(expair(it->rest, coeff)); it++; } GINAC_ASSERT(is_ex_exactly_of_type(overall_coeff,numeric)); -#ifndef NO_NAMESPACE_GINAC numeric coeff = GiNaC::smod(ex_to_numeric(overall_coeff), xi); -#else // ndef NO_NAMESPACE_GINAC - numeric coeff = ::smod(ex_to_numeric(overall_coeff), xi); -#endif // ndef NO_NAMESPACE_GINAC return (new add(newseq,coeff))->setflag(status_flags::dynallocated); } @@ -1281,11 +1285,7 @@ ex mul::smod(const numeric &xi) const #endif // def DO_GINAC_ASSERT mul * mulcopyp=new mul(*this); GINAC_ASSERT(is_ex_exactly_of_type(overall_coeff,numeric)); -#ifndef NO_NAMESPACE_GINAC mulcopyp->overall_coeff = GiNaC::smod(ex_to_numeric(overall_coeff),xi); -#else // ndef NO_NAMESPACE_GINAC - mulcopyp->overall_coeff = ::smod(ex_to_numeric(overall_coeff),xi); -#endif // ndef NO_NAMESPACE_GINAC mulcopyp->clearflag(status_flags::evaluated); mulcopyp->clearflag(status_flags::hash_calculated); return mulcopyp->setflag(status_flags::dynallocated); @@ -1464,7 +1464,7 @@ ex gcd(const ex &a, const ex &b, ex *ca, ex *cb, bool check_args) } // Check arguments - if (check_args && !a.info(info_flags::rational_polynomial) || !b.info(info_flags::rational_polynomial)) { + if (check_args && (!a.info(info_flags::rational_polynomial) || !b.info(info_flags::rational_polynomial))) { throw(std::invalid_argument("gcd: arguments must be polynomials over the rationals")); } @@ -1678,7 +1678,7 @@ ex lcm(const ex &a, const ex &b, bool check_args) { if (is_ex_exactly_of_type(a, numeric) && is_ex_exactly_of_type(b, numeric)) return lcm(ex_to_numeric(a), ex_to_numeric(b)); - if (check_args && !a.info(info_flags::rational_polynomial) || !b.info(info_flags::rational_polynomial)) + if (check_args && (!a.info(info_flags::rational_polynomial) || !b.info(info_flags::rational_polynomial))) throw(std::invalid_argument("lcm: arguments must be polynomials over the rationals")); ex ca, cb; @@ -1691,70 +1691,85 @@ ex lcm(const ex &a, const ex &b, bool check_args) * Square-free factorization */ -// Univariate GCD of polynomials in Q[x] (used internally by sqrfree()). -// a and b can be multivariate polynomials but they are treated as univariate polynomials in x. -static ex univariate_gcd(const ex &a, const ex &b, const symbol &x) +/** Compute square-free factorization of multivariate polynomial a(x) using + * Yun´s algorithm. Used internally by sqrfree(). + * + * @param a multivariate polynomial over Z[X], treated here as univariate + * polynomial in x. + * @param x variable to factor in + * @return vector of factors sorted in ascending degree */ +static exvector sqrfree_yun(const ex &a, const symbol &x) { - if (a.is_zero()) - return b; - if (b.is_zero()) - return a; - if (a.is_equal(_ex1()) || b.is_equal(_ex1())) - return _ex1(); - if (is_ex_of_type(a, numeric) && is_ex_of_type(b, numeric)) - return gcd(ex_to_numeric(a), ex_to_numeric(b)); - if (!a.info(info_flags::rational_polynomial) || !b.info(info_flags::rational_polynomial)) - throw(std::invalid_argument("univariate_gcd: arguments must be polynomials over the rationals")); - - // Euclidean algorithm - ex c, d, r; - if (a.degree(x) >= b.degree(x)) { - c = a; - d = b; - } else { - c = b; - d = a; - } - for (;;) { - r = rem(c, d, x, false); - if (r.is_zero()) - break; - c = d; - d = r; - } - return d / d.lcoeff(x); + int i = 0; + exvector res; + ex w = a; + ex z = w.diff(x); + ex g = gcd(w, z); + if (g.is_equal(_ex1())) { + res.push_back(a); + return res; + } + ex y; + do { + w = quo(w, g, x); + y = quo(z, g, x); + z = y - w.diff(x); + g = gcd(w, z); + res.push_back(g); + ++i; + } while (!z.is_zero()); + return res; } - - -/** Compute square-free factorization of multivariate polynomial a(x) using - * Yun´s algorithm. +/** Compute square-free factorization of multivariate polynomial in Q[X]. * - * @param a multivariate polynomial - * @param x variable to factor in - * @return factored polynomial */ -ex sqrfree(const ex &a, const symbol &x) + * @param a multivariate polynomial over Q[X] + * @param x lst of variables to factor in, may be left empty for autodetection + * @return polynomail a in square-free factored form. */ +ex sqrfree(const ex &a, const lst &l) { - int i = 1; - ex res = _ex1(); - ex b = a.diff(x); - ex c = univariate_gcd(a, b, x); - ex w; - if (c.is_equal(_ex1())) { - w = a; + if (is_ex_of_type(a,numeric) || // algorithm does not trap a==0 + is_ex_of_type(a,symbol)) // shortcut + return a; + // If no lst of variables to factorize in was specified we have to + // invent one now. Maybe one can optimize here by reversing the order + // or so, I don't know. + lst args; + if (l.nops()==0) { + sym_desc_vec sdv; + get_symbol_stats(a, _ex0(), sdv); + for (sym_desc_vec::iterator it=sdv.begin(); it!=sdv.end(); ++it) + args.append(*it->sym); } else { - w = quo(a, c, x); - ex y = quo(b, c, x); - ex z = y - w.diff(x); - while (!z.is_zero()) { - ex g = univariate_gcd(w, z, x); - res *= power(g, i); - w = quo(w, g, x); - y = quo(z, g, x); - z = y - w.diff(x); - i++; - } - } - return res * power(w, i); + args = l; + } + // Find the symbol to factor in at this stage + if (!is_ex_of_type(args.op(0), symbol)) + throw (std::runtime_error("sqrfree(): invalid factorization variable")); + const symbol x = ex_to_symbol(args.op(0)); + // convert the argument from something in Q[X] to something in Z[X] + numeric lcm = lcm_of_coefficients_denominators(a); + ex tmp = multiply_lcm(a,lcm); + // find the factors + exvector factors = sqrfree_yun(tmp,x); + // construct the next list of symbols with the first element popped + lst newargs; + for (int i=1; i0) { + for (exvector::iterator i=factors.begin(); i!=factors.end(); ++i) + *i = sqrfree(*i, newargs); + } + // Done with recursion, now construct the final result + ex result = _ex1(); + exvector::iterator it = factors.begin(); + for (int p = 1; it!=factors.end(); ++it, ++p) + result *= power(*it, p); + // Yun's algorithm does not account for constant factors. (For + // univariate polynomials it works only in the monic case.) We can + // correct this by inserting what has been lost back into the result: + result = result * quo(tmp, result, x); + return result * lcm.inverse(); } @@ -1866,9 +1881,13 @@ static ex frac_cancel(const ex &n, const ex &d) //std::clog << "frac_cancel num = " << num << ", den = " << den << endl; + // Handle trivial case where denominator is 1 + if (den.is_equal(_ex1())) + return (new lst(num, den))->setflag(status_flags::dynallocated); + // Handle special cases where numerator or denominator is 0 if (num.is_zero()) - return (new lst(_ex0(), _ex1()))->setflag(status_flags::dynallocated); + return (new lst(num, _ex1()))->setflag(status_flags::dynallocated); if (den.expand().is_zero()) throw(std::overflow_error("frac_cancel: division by zero in frac_cancel")); @@ -1914,36 +1933,15 @@ ex add::normal(lst &sym_lst, lst &repl_lst, int level) const else if (level == -max_recursion_level) throw(std::runtime_error("max recursion level reached")); - // Normalize and expand children, chop into summands and split each - // one into numerator and denominator + // Normalize children and split each one into numerator and denominator exvector nums, dens; nums.reserve(seq.size()+1); dens.reserve(seq.size()+1); epvector::const_iterator it = seq.begin(), itend = seq.end(); while (it != itend) { - - // Normalize and expand child - ex n = recombine_pair_to_ex(*it).bp->normal(sym_lst, repl_lst, level-1).expand(); - - // If numerator is a sum, chop into summands - if (is_ex_exactly_of_type(n.op(0), add)) { - epvector::const_iterator bit = ex_to_add(n.op(0)).seq.begin(), bitend = ex_to_add(n.op(0)).seq.end(); - while (bit != bitend) { - nums.push_back(recombine_pair_to_ex(*bit)); - dens.push_back(n.op(1)); - bit++; - } - - // The overall_coeff is already normalized (== rational), we just - // split it into numerator and denominator - GINAC_ASSERT(ex_to_numeric(ex_to_add(n.op(0)).overall_coeff).is_rational()); - numeric overall = ex_to_numeric(ex_to_add(n.op(0)).overall_coeff); - nums.push_back(overall.numer()); - dens.push_back(overall.denom() * n.op(1)); - } else { - nums.push_back(n.op(0)); - dens.push_back(n.op(1)); - } + ex n = recombine_pair_to_ex(*it).bp->normal(sym_lst, repl_lst, level-1); + nums.push_back(n.op(0)); + dens.push_back(n.op(1)); it++; } ex n = overall_coeff.bp->normal(sym_lst, repl_lst, level-1); @@ -1953,20 +1951,29 @@ ex add::normal(lst &sym_lst, lst &repl_lst, int level) const // Now, nums is a vector of all numerators and dens is a vector of // all denominators +//std::clog << "add::normal uses " << nums.size() << " summands:\n"; // Add fractions sequentially exvector::const_iterator num_it = nums.begin(), num_itend = nums.end(); exvector::const_iterator den_it = dens.begin(), den_itend = dens.end(); -//std::clog << "add::normal uses the following summands:\n"; //std::clog << " num = " << *num_it << ", den = " << *den_it << endl; ex num = *num_it++, den = *den_it++; while (num_it != num_itend) { //std::clog << " num = " << *num_it << ", den = " << *den_it << endl; + ex next_num = *num_it++, next_den = *den_it++; + + // Trivially add sequences of fractions with identical denominators + while ((den_it != den_itend) && next_den.is_equal(*den_it)) { + next_num += *num_it; + num_it++; den_it++; + } + + // Additiion of two fractions, taking advantage of the fact that + // the heuristic GCD algorithm computes the cofactors at no extra cost ex co_den1, co_den2; - ex g = gcd(den, *den_it, &co_den1, &co_den2, false); - num = (num * co_den2) + (*num_it * co_den1); - den *= co_den2; // this is the lcm(den, *den_it) - num_it++; den_it++; + ex g = gcd(den, next_den, &co_den1, &co_den2, false); + num = ((num * co_den2) + (next_num * co_den1)).expand(); + den *= co_den2; // this is the lcm(den, next_den) } //std::clog << " common denominator = " << den << endl; @@ -2016,65 +2023,65 @@ ex power::normal(lst &sym_lst, lst &repl_lst, int level) const else if (level == -max_recursion_level) throw(std::runtime_error("max recursion level reached")); - // Normalize basis - ex n = basis.bp->normal(sym_lst, repl_lst, level-1); + // Normalize basis and exponent (exponent gets reassembled) + ex n_basis = basis.bp->normal(sym_lst, repl_lst, level-1); + ex n_exponent = exponent.bp->normal(sym_lst, repl_lst, level-1); + n_exponent = n_exponent.op(0) / n_exponent.op(1); - if (exponent.info(info_flags::integer)) { + if (n_exponent.info(info_flags::integer)) { - if (exponent.info(info_flags::positive)) { + if (n_exponent.info(info_flags::positive)) { // (a/b)^n -> {a^n, b^n} - return (new lst(power(n.op(0), exponent), power(n.op(1), exponent)))->setflag(status_flags::dynallocated); + return (new lst(power(n_basis.op(0), n_exponent), power(n_basis.op(1), n_exponent)))->setflag(status_flags::dynallocated); - } else if (exponent.info(info_flags::negative)) { + } else if (n_exponent.info(info_flags::negative)) { // (a/b)^-n -> {b^n, a^n} - return (new lst(power(n.op(1), -exponent), power(n.op(0), -exponent)))->setflag(status_flags::dynallocated); + return (new lst(power(n_basis.op(1), -n_exponent), power(n_basis.op(0), -n_exponent)))->setflag(status_flags::dynallocated); } } else { - if (exponent.info(info_flags::positive)) { + if (n_exponent.info(info_flags::positive)) { // (a/b)^x -> {sym((a/b)^x), 1} - return (new lst(replace_with_symbol(power(n.op(0) / n.op(1), exponent), sym_lst, repl_lst), _ex1()))->setflag(status_flags::dynallocated); + return (new lst(replace_with_symbol(power(n_basis.op(0) / n_basis.op(1), n_exponent), sym_lst, repl_lst), _ex1()))->setflag(status_flags::dynallocated); - } else if (exponent.info(info_flags::negative)) { + } else if (n_exponent.info(info_flags::negative)) { - if (n.op(1).is_equal(_ex1())) { + if (n_basis.op(1).is_equal(_ex1())) { // a^-x -> {1, sym(a^x)} - return (new lst(_ex1(), replace_with_symbol(power(n.op(0), -exponent), sym_lst, repl_lst)))->setflag(status_flags::dynallocated); + return (new lst(_ex1(), replace_with_symbol(power(n_basis.op(0), -n_exponent), sym_lst, repl_lst)))->setflag(status_flags::dynallocated); } else { // (a/b)^-x -> {sym((b/a)^x), 1} - return (new lst(replace_with_symbol(power(n.op(1) / n.op(0), -exponent), sym_lst, repl_lst), _ex1()))->setflag(status_flags::dynallocated); + return (new lst(replace_with_symbol(power(n_basis.op(1) / n_basis.op(0), -n_exponent), sym_lst, repl_lst), _ex1()))->setflag(status_flags::dynallocated); } - } else { // exponent not numeric + } else { // n_exponent not numeric // (a/b)^x -> {sym((a/b)^x, 1} - return (new lst(replace_with_symbol(power(n.op(0) / n.op(1), exponent), sym_lst, repl_lst), _ex1()))->setflag(status_flags::dynallocated); + return (new lst(replace_with_symbol(power(n_basis.op(0) / n_basis.op(1), n_exponent), sym_lst, repl_lst), _ex1()))->setflag(status_flags::dynallocated); } } } -/** Implementation of ex::normal() for pseries. It normalizes each coefficient and - * replaces the series by a temporary symbol. +/** Implementation of ex::normal() for pseries. It normalizes each coefficient + * and replaces the series by a temporary symbol. * @see ex::normal */ ex pseries::normal(lst &sym_lst, lst &repl_lst, int level) const { - epvector new_seq; - new_seq.reserve(seq.size()); - - epvector::const_iterator it = seq.begin(), itend = seq.end(); - while (it != itend) { - new_seq.push_back(expair(it->rest.normal(), it->coeff)); - it++; + epvector newseq; + for (epvector::const_iterator i=seq.begin(); i!=seq.end(); ++i) { + ex restexp = i->rest.normal(); + if (!restexp.is_zero()) + newseq.push_back(expair(restexp, i->coeff)); } - ex n = pseries(relational(var,point), new_seq); + ex n = pseries(relational(var,point), newseq); return (new lst(replace_with_symbol(n, sym_lst, repl_lst), _ex1()))->setflag(status_flags::dynallocated); } @@ -2243,6 +2250,4 @@ ex ex::to_rational(lst &repl_lst) const } -#ifndef NO_NAMESPACE_GINAC } // namespace GiNaC -#endif // ndef NO_NAMESPACE_GINAC