#include "relational.h"
#include "series.h"
#include "symbol.h"
+#include "utils.h"
#ifndef NO_GINAC_NAMESPACE
namespace GiNaC {
if (e.info(info_flags::rational))
return lcm(ex_to_numeric(e).denom(), l);
else if (is_ex_exactly_of_type(e, add) || is_ex_exactly_of_type(e, mul)) {
- numeric c = numONE();
+ numeric c = _num1();
for (int i=0; i<e.nops(); i++) {
c = lcmcoeff(e.op(i), c);
}
static numeric lcm_of_coefficients_denominators(const ex &e)
{
- return lcmcoeff(e.expand(), numONE());
+ return lcmcoeff(e.expand(), _num1());
}
numeric basic::integer_content(void) const
{
- return numONE();
+ return _num1();
}
numeric numeric::integer_content(void) const
{
epvector::const_iterator it = seq.begin();
epvector::const_iterator itend = seq.end();
- numeric c = numZERO();
+ numeric c = _num0();
while (it != itend) {
GINAC_ASSERT(!is_ex_exactly_of_type(it->rest,numeric));
GINAC_ASSERT(is_ex_exactly_of_type(it->coeff,numeric));
return a / b;
#if FAST_COMPARE
if (a.is_equal(b))
- return exONE();
+ return _ex1();
#endif
if (check_args && (!a.info(info_flags::rational_polynomial) || !b.info(info_flags::rational_polynomial)))
throw(std::invalid_argument("quo: arguments must be polynomials over the rationals"));
// Polynomial long division
- ex q = exZERO();
+ ex q = _ex0();
ex r = a.expand();
if (r.is_zero())
return r;
throw(std::overflow_error("rem: division by zero"));
if (is_ex_exactly_of_type(a, numeric)) {
if (is_ex_exactly_of_type(b, numeric))
- return exZERO();
+ return _ex0();
else
return b;
}
#if FAST_COMPARE
if (a.is_equal(b))
- return exZERO();
+ return _ex0();
#endif
if (check_args && (!a.info(info_flags::rational_polynomial) || !b.info(info_flags::rational_polynomial)))
throw(std::invalid_argument("rem: arguments must be polynomials over the rationals"));
throw(std::overflow_error("prem: division by zero"));
if (is_ex_exactly_of_type(a, numeric)) {
if (is_ex_exactly_of_type(b, numeric))
- return exZERO();
+ return _ex0();
else
return b;
}
if (bdeg <= rdeg) {
blcoeff = eb.coeff(x, bdeg);
if (bdeg == 0)
- eb = exZERO();
+ eb = _ex0();
else
eb -= blcoeff * power(x, bdeg);
} else
- blcoeff = exONE();
+ blcoeff = _ex1();
int delta = rdeg - bdeg + 1, i = 0;
while (rdeg >= bdeg && !r.is_zero()) {
ex rlcoeff = r.coeff(x, rdeg);
ex term = (power(x, rdeg - bdeg) * eb * rlcoeff).expand();
if (rdeg == 0)
- r = exZERO();
+ r = _ex0();
else
r -= rlcoeff * power(x, rdeg);
r = (blcoeff * r).expand() - term;
bool divide(const ex &a, const ex &b, ex &q, bool check_args)
{
- q = exZERO();
+ q = _ex0();
if (b.is_zero())
throw(std::overflow_error("divide: division by zero"));
if (is_ex_exactly_of_type(b, numeric)) {
return false;
#if FAST_COMPARE
if (a.is_equal(b)) {
- q = exONE();
+ q = _ex1();
return true;
}
#endif
* @see get_symbol_stats, heur_gcd */
static bool divide_in_z(const ex &a, const ex &b, ex &q, sym_desc_vec::const_iterator var)
{
- q = exZERO();
+ q = _ex0();
if (b.is_zero())
throw(std::overflow_error("divide_in_z: division by zero"));
- if (b.is_equal(exONE())) {
+ if (b.is_equal(_ex1())) {
q = a;
return true;
}
}
#if FAST_COMPARE
if (a.is_equal(b)) {
- q = exONE();
+ q = _ex1();
return true;
}
#endif
// Compute values at evaluation points 0..adeg
vector<numeric> alpha; alpha.reserve(adeg + 1);
exvector u; u.reserve(adeg + 1);
- numeric point = numZERO();
+ numeric point = _num0();
ex c;
for (i=0; i<=adeg; i++) {
ex bs = b.subs(*x == point);
while (bs.is_zero()) {
- point += numONE();
+ point += _num1();
bs = b.subs(*x == point);
}
if (!divide_in_z(a.subs(*x == point), bs, c, var+1))
return false;
alpha.push_back(point);
u.push_back(c);
- point += numONE();
+ point += _num1();
}
// Compute inverses
{
ex c = expand().lcoeff(x);
if (is_ex_exactly_of_type(c, numeric))
- return c < exZERO() ? exMINUSONE() : exONE();
+ return c < _ex0() ? _ex_1() : _ex1();
else {
const symbol *y;
if (get_first_symbol(c, y))
ex ex::content(const symbol &x) const
{
if (is_zero())
- return exZERO();
+ return _ex0();
if (is_ex_exactly_of_type(*this, numeric))
return info(info_flags::negative) ? -*this : *this;
ex e = expand();
if (e.is_zero())
- return exZERO();
+ return _ex0();
// First, try the integer content
ex c = e.integer_content();
int ldeg = e.ldegree(x);
if (deg == ldeg)
return e.lcoeff(x) / e.unit(x);
- c = exZERO();
+ c = _ex0();
for (int i=ldeg; i<=deg; i++)
c = gcd(e.coeff(x, i), c, NULL, NULL, false);
return c;
ex ex::primpart(const symbol &x) const
{
if (is_zero())
- return exZERO();
+ return _ex0();
if (is_ex_exactly_of_type(*this, numeric))
- return exONE();
+ return _ex1();
ex c = content(x);
if (c.is_zero())
- return exZERO();
+ return _ex0();
ex u = unit(x);
if (is_ex_exactly_of_type(c, numeric))
return *this / (c * u);
ex ex::primpart(const symbol &x, const ex &c) const
{
if (is_zero())
- return exZERO();
+ return _ex0();
if (c.is_zero())
- return exZERO();
+ return _ex0();
if (is_ex_exactly_of_type(*this, numeric))
- return exONE();
+ return _ex1();
ex u = unit(x);
if (is_ex_exactly_of_type(c, numeric))
d = d.primpart(*x, cont_d);
// First element of subresultant sequence
- ex r = exZERO(), ri = exONE(), psi = exONE();
+ ex r = _ex0(), ri = _ex1(), psi = _ex1();
int delta = cdeg - ddeg;
for (;;) {
numeric basic::max_coefficient(void) const
{
- return numONE();
+ return _num1();
}
numeric numeric::max_coefficient(void) const
}
-/** Exception thrown by heur_gcd() to signal failure */
+/** Exception thrown by heur_gcd() to signal failure. */
class gcdheu_failed {};
/** Compute GCD of multivariate polynomials using the heuristic GCD algorithm.
numeric mp = p.max_coefficient(), mq = q.max_coefficient();
numeric xi;
if (mp > mq)
- xi = mq * numTWO() + numTWO();
+ xi = mq * _num2() + _num2();
else
- xi = mp * numTWO() + numTWO();
+ xi = mp * _num2() + _num2();
// 6 tries maximum
for (int t=0; t<6; t++) {
if (!is_ex_exactly_of_type(gamma, fail)) {
// Reconstruct polynomial from GCD of mapped polynomials
- ex g = exZERO();
+ ex g = _ex0();
numeric rxi = xi.inverse();
for (int i=0; !gamma.is_zero(); i++) {
ex gi = gamma.smod(xi);
if (divide_in_z(p, g, ca ? *ca : dummy, var) && divide_in_z(q, g, cb ? *cb : dummy, var)) {
g *= gc;
ex lc = g.lcoeff(*x);
- if (is_ex_exactly_of_type(lc, numeric) && lc.compare(exZERO()) < 0)
+ if (is_ex_exactly_of_type(lc, numeric) && lc.compare(_ex0()) < 0)
return -g;
else
return g;
ex aex = a.expand(), bex = b.expand();
if (aex.is_zero()) {
if (ca)
- *ca = exZERO();
+ *ca = _ex0();
if (cb)
- *cb = exONE();
+ *cb = _ex1();
return b;
}
if (bex.is_zero()) {
if (ca)
- *ca = exONE();
+ *ca = _ex1();
if (cb)
- *cb = exZERO();
+ *cb = _ex0();
return a;
}
- if (aex.is_equal(exONE()) || bex.is_equal(exONE())) {
+ if (aex.is_equal(_ex1()) || bex.is_equal(_ex1())) {
if (ca)
*ca = a;
if (cb)
*cb = b;
- return exONE();
+ return _ex1();
}
#if FAST_COMPARE
if (a.is_equal(b)) {
if (ca)
- *ca = exONE();
+ *ca = _ex1();
if (cb)
- *cb = exONE();
+ *cb = _ex1();
return a;
}
#endif
g = *new ex(fail());
}
if (is_ex_exactly_of_type(g, fail)) {
-//clog << "heuristics failed\n";
+// clog << "heuristics failed" << endl;
g = sr_gcd(aex, bex, x);
if (ca)
divide(aex, g, *ca, false);
return b;
if (b.is_zero())
return a;
- if (a.is_equal(exONE()) || b.is_equal(exONE()))
- return exONE();
+ 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))
ex sqrfree(const ex &a, const symbol &x)
{
int i = 1;
- ex res = exONE();
+ ex res = _ex1();
ex b = a.diff(x);
ex c = univariate_gcd(a, b, x);
ex w;
- if (c.is_equal(exONE())) {
+ if (c.is_equal(_ex1())) {
w = a;
} else {
w = quo(a, c, x);
if (is_real())
if (is_rational())
return *this;
- else
- return replace_with_symbol(*this, sym_lst, repl_lst);
+ else
+ return replace_with_symbol(*this, sym_lst, repl_lst);
else { // complex
numeric re = real(), im = imag();
- ex re_ex = re.is_rational() ? re : replace_with_symbol(re, sym_lst, repl_lst);
- ex im_ex = im.is_rational() ? im : replace_with_symbol(im, sym_lst, repl_lst);
- return re_ex + im_ex * replace_with_symbol(I, sym_lst, repl_lst);
- }
+ ex re_ex = re.is_rational() ? re : replace_with_symbol(re, sym_lst, repl_lst);
+ ex im_ex = im.is_rational() ? im : replace_with_symbol(im, sym_lst, repl_lst);
+ return re_ex + im_ex * replace_with_symbol(I, sym_lst, repl_lst);
+ }
}
/*
* Helper function for fraction cancellation (returns cancelled fraction n/d)
*/
-
static ex frac_cancel(const ex &n, const ex &d)
{
ex num = n;
ex den = d;
- ex pre_factor = exONE();
+ ex pre_factor = _ex1();
// Handle special cases where numerator or denominator is 0
if (num.is_zero())
- return exZERO();
+ return _ex0();
if (den.expand().is_zero())
throw(std::overflow_error("frac_cancel: division by zero in frac_cancel"));
if (is_ex_exactly_of_type(den, numeric))
return num / den;
if (num.is_zero())
- return exZERO();
+ return _ex0();
// Bring numerator and denominator to Z[X] by multiplying with
// LCM of all coefficients' denominators
// Cancel GCD from numerator and denominator
ex cnum, cden;
- if (gcd(num, den, &cnum, &cden, false) != exONE()) {
+ if (gcd(num, den, &cnum, &cden, false) != _ex1()) {
num = cnum;
den = cden;
}
// as defined by get_first_symbol() is made positive)
const symbol *x;
if (get_first_symbol(den, x)) {
- if (den.unit(*x).compare(exZERO()) < 0) {
- num *= exMINUSONE();
- den *= exMINUSONE();
+ if (den.unit(*x).compare(_ex0()) < 0) {
+ num *= _ex_1();
+ den *= _ex_1();
}
}
return pre_factor * num / den;
o.push_back(overall_coeff.bp->normal(sym_lst, repl_lst, level-1));
// Determine common denominator
- ex den = exONE();
+ ex den = _ex1();
exvector::const_iterator ait = o.begin(), aitend = o.end();
while (ait != aitend) {
den = lcm((*ait).denom(false), den, false);
}
// Add fractions
- if (den.is_equal(exONE()))
+ if (den.is_equal(_ex1()))
return (new add(o))->setflag(status_flags::dynallocated);
else {
exvector num_seq;
git://www.ginac.de / ginac.git / blobdiff