* computation, square-free factorization and rational function normalization. */
/*
- * GiNaC Copyright (C) 1999-2008 Johannes Gutenberg University Mainz, Germany
+ * GiNaC Copyright (C) 1999-2015 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.
return lcoeff * c / lcoeff.unit(x);
ex cont = _ex0;
for (int i=ldeg; i<=deg; i++)
- cont = gcd(r.coeff(x, i), cont, NULL, NULL, false);
+ cont = gcd(r.coeff(x, i), cont, nullptr, nullptr, false);
return cont * c;
}
// Remove content from c and d, to be attached to GCD later
ex cont_c = c.content(x);
ex cont_d = d.content(x);
- ex gamma = gcd(cont_c, cont_d, NULL, NULL, false);
+ ex gamma = gcd(cont_c, cont_d, nullptr, nullptr, false);
if (ddeg == 0)
return gamma;
c = c.primpart(x, cont_c);
*
* @param a first integer multivariate polynomial (expanded)
* @param b second integer multivariate polynomial (expanded)
- * @param ca cofactor of polynomial a (returned), NULL to suppress
+ * @param ca cofactor of polynomial a (returned), nullptr to suppress
* calculation of cofactor
- * @param cb cofactor of polynomial b (returned), NULL to suppress
+ * @param cb cofactor of polynomial b (returned), nullptr to suppress
* calculation of cofactor
* @param var iterator to first element of vector of sym_desc structs
* @param res the GCD (returned)
*
* @param a first rational multivariate polynomial (expanded)
* @param b second rational multivariate polynomial (expanded)
- * @param ca cofactor of polynomial a (returned), NULL to suppress
+ * @param ca cofactor of polynomial a (returned), nullptr to suppress
* calculation of cofactor
- * @param cb cofactor of polynomial b (returned), NULL to suppress
+ * @param cb cofactor of polynomial b (returned), nullptr to suppress
* calculation of cofactor
* @param var iterator to first element of vector of sym_desc structs
* @param res the GCD (returned)
*
* @param a first multivariate polynomial
* @param b second multivariate polynomial
- * @param ca pointer to expression that will receive the cofactor of a, or NULL
- * @param cb pointer to expression that will receive the cofactor of b, or NULL
+ * @param ca pointer to expression that will receive the cofactor of a, or nullptr
+ * @param cb pointer to expression that will receive the cofactor of b, or nullptr
* @param check_args check whether a and b are polynomials with rational
* coefficients (defaults to "true")
* @return the GCD as a new expression */
if (ca)
*ca = ex_to<numeric>(aex)/g;
if (cb)
- *cb = bex/g;
+ *cb = bex/g;
return g;
}
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.
*
}
ex oc = overall_coeff.to_rational(repl);
if (oc.info(info_flags::numeric))
- return thisexpairseq(s, overall_coeff);
+ return thisexpairseq(std::move(s), overall_coeff);
else
s.push_back(combine_ex_with_coeff_to_pair(oc, _ex1));
- return thisexpairseq(s, default_overall_coeff());
+ return thisexpairseq(std::move(s), default_overall_coeff());
}
/** Implementation of ex::to_polynomial() for expairseqs. */
}
ex oc = overall_coeff.to_polynomial(repl);
if (oc.info(info_flags::numeric))
- return thisexpairseq(s, overall_coeff);
+ return thisexpairseq(std::move(s), overall_coeff);
else
s.push_back(combine_ex_with_coeff_to_pair(oc, _ex1));
- return thisexpairseq(s, default_overall_coeff());
+ return thisexpairseq(std::move(s), default_overall_coeff());
}