* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
-#include <stdexcept>
#include <algorithm>
#include <map>
#include "constant.h"
#include "expairseq.h"
#include "fail.h"
-#include "indexed.h"
#include "inifcns.h"
#include "lst.h"
#include "mul.h"
-#include "ncmul.h"
#include "numeric.h"
#include "power.h"
#include "relational.h"
#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
/** 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
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++;
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++;
}
for (unsigned i=0; i<e.nops(); i++)
c *= lcmcoeff(e.op(i), _num1());
return lcm(c, l);
- } else if (is_ex_exactly_of_type(e, power))
- return pow(lcmcoeff(e.op(0), l), ex_to_numeric(e.op(1)));
+ } else if (is_ex_exactly_of_type(e, power)) {
+ if (is_ex_exactly_of_type(e.op(0), symbol))
+ return l;
+ else
+ return pow(lcmcoeff(e.op(0), l), ex_to_numeric(e.op(1)));
+ }
return l;
}
c += multiply_lcm(e.op(i), lcm);
return c;
} else if (is_ex_exactly_of_type(e, power)) {
- return pow(multiply_lcm(e.op(0), lcm.power(ex_to_numeric(e.op(1)).inverse())), e.op(1));
+ if (is_ex_exactly_of_type(e.op(0), symbol))
+ return e * lcm;
+ else
+ return pow(multiply_lcm(e.op(0), lcm.power(ex_to_numeric(e.op(1)).inverse())), e.op(1));
} else
return e * lcm;
}
term = rcoeff / blcoeff;
else {
if (!divide(rcoeff, blcoeff, term, false))
- return *new ex(fail());
+ return (new fail())->setflag(status_flags::dynallocated);
}
term *= power(x, rdeg - bdeg);
q += term;
term = rcoeff / blcoeff;
else {
if (!divide(rcoeff, blcoeff, term, false))
- return *new ex(fail());
+ return (new fail())->setflag(status_flags::dynallocated);
}
term *= power(x, rdeg - bdeg);
r -= (term * b).expand();
typedef std::pair<ex, bool> 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));
}
};
return bp->max_coefficient();
}
+/** Implementation ex::max_coefficient().
+ * @see heur_gcd */
numeric basic::max_coefficient(void) const
{
return _num1();
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
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);
}
it++;
}
#endif // def DO_GINAC_ASSERT
- mul * mulcopyp=new mul(*this);
+ 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);
// Algorithms only works for non-vanishing input polynomials
if (a.is_zero() || b.is_zero())
- return *new ex(fail());
+ return (new fail())->setflag(status_flags::dynallocated);
// GCD of two numeric values -> CLN
if (is_ex_exactly_of_type(a, numeric) && is_ex_exactly_of_type(b, numeric)) {
// 6 tries maximum
for (int t=0; t<6; t++) {
if (xi.int_length() * maxdeg > 100000) {
-//std::clog << "giving up heur_gcd, xi.int_length = " << xi.int_length() << ", maxdeg = " << maxdeg << endl;
+//std::clog << "giving up heur_gcd, xi.int_length = " << xi.int_length() << ", maxdeg = " << maxdeg << std::endl;
throw gcdheu_failed();
}
// Next evaluation point
xi = iquo(xi * isqrt(isqrt(xi)) * numeric(73794), numeric(27011));
}
- return *new ex(fail());
+ return (new fail())->setflag(status_flags::dynallocated);
}
int min_ldeg = std::min(ldeg_a,ldeg_b);
if (min_ldeg > 0) {
ex common = power(x, min_ldeg);
-//std::clog << "trivial common factor " << common << endl;
+//std::clog << "trivial common factor " << common << std::endl;
return gcd((aex / common).expand(), (bex / common).expand(), ca, cb, false) * common;
}
// Try to eliminate variables
if (var->deg_a == 0) {
-//std::clog << "eliminating variable " << x << " from b" << endl;
+//std::clog << "eliminating variable " << x << " from b" << std::endl;
ex c = bex.content(x);
ex g = gcd(aex, c, ca, cb, false);
if (cb)
*cb *= bex.unit(x) * bex.primpart(x, c);
return g;
} else if (var->deg_b == 0) {
-//std::clog << "eliminating variable " << x << " from a" << endl;
+//std::clog << "eliminating variable " << x << " from a" << std::endl;
ex c = aex.content(x);
ex g = gcd(c, bex, ca, cb, false);
if (ca)
try {
g = heur_gcd(aex, bex, ca, cb, var);
} catch (gcdheu_failed) {
- g = *new ex(fail());
+ g = fail();
}
if (is_ex_exactly_of_type(g, fail)) {
-//std::clog << "heuristics failed" << endl;
+//std::clog << "heuristics failed" << std::endl;
#if STATISTICS
heur_gcd_failed++;
#endif
* 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);
+ 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);
+ } 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)
-{
- 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;
+ * @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)
+{
+ 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; i<args.nops(); ++i)
+ newargs.append(args.op(i));
+ // recurse down the factors in remaining vars
+ if (newargs.nops()>0) {
+ 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();
}
ex den = d;
numeric pre_factor = _num1();
-//std::clog << "frac_cancel num = " << num << ", den = " << den << endl;
+//std::clog << "frac_cancel num = " << num << ", den = " << den << std::endl;
// Handle trivial case where denominator is 1
if (den.is_equal(_ex1()))
}
// Return result as list
-//std::clog << " returns num = " << num << ", den = " << den << ", pre_factor = " << pre_factor << endl;
+//std::clog << " returns num = " << num << ", den = " << den << ", pre_factor = " << pre_factor << std::endl;
return (new lst(num * pre_factor.numer(), den * pre_factor.denom()))->setflag(status_flags::dynallocated);
}
// 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 << " num = " << *num_it << ", den = " << *den_it << endl;
+//std::clog << " num = " << *num_it << ", den = " << *den_it << std::endl;
ex num = *num_it++, den = *den_it++;
while (num_it != num_itend) {
-//std::clog << " num = " << *num_it << ", den = " << *den_it << endl;
+//std::clog << " num = " << *num_it << ", den = " << *den_it << std::endl;
ex next_num = *num_it++, next_den = *den_it++;
// Trivially add sequences of fractions with identical denominators
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;
+//std::clog << " common denominator = " << den << std::endl;
// Cancel common factors from num/den
return frac_cancel(num, den);
}
-/** 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
{
return e.op(0) / e.op(1);
}
-/** Numerator of an expression. If the expression is not of the normal form
- * "numerator/denominator", it is first converted to this form and then the
- * numerator is returned.
+/** Get numerator of an expression. If the expression is not of the normal
+ * form "numerator/denominator", it is first converted to this form and
+ * then the numerator is returned.
*
* @see ex::normal
* @return numerator */
return e.op(0);
}
-/** Denominator of an expression. If the expression is not of the normal form
- * "numerator/denominator", it is first converted to this form and then the
- * denominator is returned.
+/** Get denominator of an expression. If the expression is not of the normal
+ * form "numerator/denominator", it is first converted to this form and
+ * then the denominator is returned.
*
* @see ex::normal
* @return denominator */
return e.op(1);
}
+/** Get numerator and denominator of an expression. If the expresison is not
+ * of the normal form "numerator/denominator", it is first converted to this
+ * form and then a list [numerator, denominator] is returned.
+ *
+ * @see ex::normal
+ * @return a list [numerator, denominator] */
+ex ex::numer_denom(void) const
+{
+ lst sym_lst, repl_lst;
+
+ ex e = bp->normal(sym_lst, repl_lst, 0);
+ GINAC_ASSERT(is_ex_of_type(e, lst));
+
+ // Re-insert replaced symbols
+ if (sym_lst.nops() > 0)
+ return e.subs(sym_lst, repl_lst);
+ else
+ return e;
+}
+
/** Default implementation of ex::to_rational(). It replaces the object with a
* temporary symbol.
}
-#ifndef NO_NAMESPACE_GINAC
} // namespace GiNaC
-#endif // ndef NO_NAMESPACE_GINAC
git://www.ginac.de / ginac.git / blobdiff