* computation, square-free factorization and rational function normalization. */
/*
- * GiNaC Copyright (C) 1999-2008 Johannes Gutenberg University Mainz, Germany
+ * GiNaC Copyright (C) 1999-2016 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
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
-#include <algorithm>
-#include <map>
-
#include "normal.h"
#include "basic.h"
#include "ex.h"
#include "utils.h"
#include "polynomial/chinrem_gcd.h"
+#include <algorithm>
+#include <map>
+
namespace GiNaC {
// If comparing expressions (ex::compare()) is fast, you can set this to 1.
} else if (is_exactly_a<power>(e)) {
if (is_a<symbol>(e.op(0)))
return e * lcm;
- else
- return pow(multiply_lcm(e.op(0), lcm.power(ex_to<numeric>(e.op(1)).inverse())), e.op(1));
+ else {
+ numeric root_of_lcm = lcm.power(ex_to<numeric>(e.op(1)).inverse());
+ if (root_of_lcm.is_rational())
+ return pow(multiply_lcm(e.op(0), root_of_lcm), e.op(1));
+ else
+ return e * lcm;
+ }
} else
return e * lcm;
}
if (ca)
*ca = ex_to<numeric>(aex)/g;
if (cb)
- *cb = bex/g;
+ *cb = bex/g;
return g;
}
* Yun's algorithm. Used internally by sqrfree().
*
* @param a multivariate polynomial over Z[X], treated here as univariate
- * polynomial in x.
+ * polynomial in x (needs not be expanded).
* @param x variable to factor in
* @return vector of factors sorted in ascending degree */
static exvector sqrfree_yun(const ex &a, const symbol &x)
ex w = a;
ex z = w.diff(x);
ex g = gcd(w, z);
+ if (g.is_zero()) {
+ return res;
+ }
if (g.is_equal(_ex1)) {
res.push_back(a);
return res;
ex y;
do {
w = quo(w, g, x);
+ if (w.is_zero()) {
+ return res;
+ }
y = quo(z, g, x);
z = y - w.diff(x);
g = gcd(w, z);
/** Compute a square-free factorization of a multivariate polynomial in Q[X].
*
- * @param a multivariate polynomial over Q[X]
+ * @param a multivariate polynomial over Q[X] (needs not be expanded)
* @param l lst of variables to factor in, may be left empty for autodetection
* @return a square-free factorization of \p a.
*
*/
ex sqrfree(const ex &a, const lst &l)
{
- if (is_exactly_a<numeric>(a) || // algorithm does not trap a==0
- is_a<symbol>(a)) // shortcut
+ if (is_exactly_a<numeric>(a) ||
+ is_a<symbol>(a)) // shortcuts
return a;
// If no lst of variables to factorize in was specified we have to
else
result *= quo(tmp, result, x);
- // Put in the reational overall factor again and return
+ // Put in the rational overall factor again and return
return result * lcm.inverse();
}
* @see ex::normal */
static ex replace_with_symbol(const ex & e, exmap & repl, exmap & rev_lookup)
{
+ // Since the repl contains replaced expressions we should search for them
+ ex e_replaced = e.subs(repl, subs_options::no_pattern);
+
// Expression already replaced? Then return the assigned symbol
- exmap::const_iterator it = rev_lookup.find(e);
+ exmap::const_iterator it = rev_lookup.find(e_replaced);
if (it != rev_lookup.end())
return it->second;
-
+
// Otherwise create new symbol and add to list, taking care that the
// replacement expression doesn't itself contain symbols from repl,
// because subs() is not recursive
ex es = (new symbol)->setflag(status_flags::dynallocated);
- ex e_replaced = e.subs(repl, subs_options::no_pattern);
repl.insert(std::make_pair(es, e_replaced));
rev_lookup.insert(std::make_pair(e_replaced, es));
return es;
* @see basic::to_polynomial */
static ex replace_with_symbol(const ex & e, exmap & repl)
{
+ // Since the repl contains replaced expressions we should search for them
+ ex e_replaced = e.subs(repl, subs_options::no_pattern);
+
// Expression already replaced? Then return the assigned symbol
for (exmap::const_iterator it = repl.begin(); it != repl.end(); ++it)
- if (it->second.is_equal(e))
+ if (it->second.is_equal(e_replaced))
return it->first;
-
+
// Otherwise create new symbol and add to list, taking care that the
// replacement expression doesn't itself contain symbols from repl,
// because subs() is not recursive
ex es = (new symbol)->setflag(status_flags::dynallocated);
- ex e_replaced = e.subs(repl, subs_options::no_pattern);
repl.insert(std::make_pair(es, e_replaced));
return es;
}
num_it++; den_it++;
}
- // Additiion of two fractions, taking advantage of the fact that
+ // Addition 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, next_den, &co_den1, &co_den2, false);
return e.op(1).subs(repl, subs_options::no_pattern);
}
-/** Get numerator and denominator of an expression. If the expresison is not
+/** Get numerator and denominator of an expression. If the expression is not
* of the normal form "numerator/denominator", it is first converted to this
* form and then a list [numerator, denominator] is returned.
*