#include "numeric.h"
#include "power.h"
#include "relational.h"
+#include "matrix.h"
#include "pseries.h"
#include "symbol.h"
#include "utils.h"
static struct _stat_print {
_stat_print() {}
~_stat_print() {
- cout << "gcd() called " << gcd_called << " times\n";
- cout << "sr_gcd() called " << sr_gcd_called << " times\n";
- cout << "heur_gcd() called " << heur_gcd_called << " times\n";
- cout << "heur_gcd() failed " << heur_gcd_failed << " times\n";
+ std::cout << "gcd() called " << gcd_called << " times\n";
+ std::cout << "sr_gcd() called " << sr_gcd_called << " times\n";
+ std::cout << "heur_gcd() called " << heur_gcd_called << " times\n";
+ std::cout << "heur_gcd() failed " << heur_gcd_failed << " times\n";
}
} stat_print;
#endif
static bool get_first_symbol(const ex &e, const symbol *&x)
{
if (is_ex_exactly_of_type(e, symbol)) {
- x = static_cast<symbol *>(e.bp);
+ x = &ex_to<symbol>(e);
return true;
} else if (is_ex_exactly_of_type(e, add) || is_ex_exactly_of_type(e, mul)) {
for (unsigned i=0; i<e.nops(); i++)
// Add symbol the sym_desc_vec (used internally by get_symbol_stats())
static void add_symbol(const symbol *s, sym_desc_vec &v)
{
- sym_desc_vec::iterator it = v.begin(), itend = v.end();
+ sym_desc_vec::const_iterator it = v.begin(), itend = v.end();
while (it != itend) {
if (it->sym->compare(*s) == 0) // If it's already in there, don't add it a second time
return;
- it++;
+ ++it;
}
sym_desc d;
d.sym = s;
static void collect_symbols(const ex &e, sym_desc_vec &v)
{
if (is_ex_exactly_of_type(e, symbol)) {
- add_symbol(static_cast<symbol *>(e.bp), v);
+ add_symbol(&ex_to<symbol>(e), v);
} else if (is_ex_exactly_of_type(e, add) || is_ex_exactly_of_type(e, mul)) {
for (unsigned i=0; i<e.nops(); i++)
collect_symbols(e.op(i), v);
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++;
+ ++it;
}
- sort(v.begin(), v.end());
+ std::sort(v.begin(), v.end());
#if 0
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 << ", max_lcnops=" << it->max_lcnops << endl;
std::clog << " lcoeff_a=" << a.lcoeff(*(it->sym)) << ", lcoeff_b=" << b.lcoeff(*(it->sym)) << endl;
- it++;
+ ++it;
}
#endif
}
static numeric lcmcoeff(const ex &e, const numeric &l)
{
if (e.info(info_flags::rational))
- return lcm(ex_to_numeric(e).denom(), l);
+ return lcm(ex_to<numeric>(e).denom(), l);
else if (is_ex_exactly_of_type(e, add)) {
- numeric c = _num1();
+ numeric c = _num1;
for (unsigned i=0; i<e.nops(); i++)
c = lcmcoeff(e.op(i), c);
return lcm(c, l);
} else if (is_ex_exactly_of_type(e, mul)) {
- numeric c = _num1();
+ numeric c = _num1;
for (unsigned i=0; i<e.nops(); i++)
- c *= lcmcoeff(e.op(i), _num1());
+ c *= lcmcoeff(e.op(i), _num1);
return lcm(c, l);
} 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 pow(lcmcoeff(e.op(0), l), ex_to<numeric>(e.op(1)));
}
return l;
}
* @return LCM of denominators of coefficients */
static numeric lcm_of_coefficients_denominators(const ex &e)
{
- return lcmcoeff(e, _num1());
+ return lcmcoeff(e, _num1);
}
/** Bring polynomial from Q[X] to Z[X] by multiplying in the previously
static ex multiply_lcm(const ex &e, const numeric &lcm)
{
if (is_ex_exactly_of_type(e, mul)) {
- ex c = _ex1();
- numeric lcm_accum = _num1();
+ unsigned num = e.nops();
+ exvector v; v.reserve(num + 1);
+ numeric lcm_accum = _num1;
for (unsigned i=0; i<e.nops(); i++) {
- numeric op_lcm = lcmcoeff(e.op(i), _num1());
- c *= multiply_lcm(e.op(i), op_lcm);
+ numeric op_lcm = lcmcoeff(e.op(i), _num1);
+ v.push_back(multiply_lcm(e.op(i), op_lcm));
lcm_accum *= op_lcm;
}
- c *= lcm / lcm_accum;
- return c;
+ v.push_back(lcm / lcm_accum);
+ return (new mul(v))->setflag(status_flags::dynallocated);
} else if (is_ex_exactly_of_type(e, add)) {
- ex c = _ex0();
- for (unsigned i=0; i<e.nops(); i++)
- c += multiply_lcm(e.op(i), lcm);
- return c;
+ unsigned num = e.nops();
+ exvector v; v.reserve(num);
+ for (unsigned i=0; i<num; i++)
+ v.push_back(multiply_lcm(e.op(i), lcm));
+ return (new add(v))->setflag(status_flags::dynallocated);
} else if (is_ex_exactly_of_type(e, power)) {
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));
+ return pow(multiply_lcm(e.op(0), lcm.power(ex_to<numeric>(e.op(1)).inverse())), e.op(1));
} else
return e * lcm;
}
numeric basic::integer_content(void) const
{
- return _num1();
+ return _num1;
}
numeric numeric::integer_content(void) const
{
epvector::const_iterator it = seq.begin();
epvector::const_iterator itend = seq.end();
- numeric c = _num0();
+ 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));
- c = gcd(ex_to_numeric(it->coeff), c);
+ GINAC_ASSERT(!is_exactly_a<numeric>(it->rest));
+ GINAC_ASSERT(is_exactly_a<numeric>(it->coeff));
+ c = gcd(ex_to<numeric>(it->coeff), c);
it++;
}
- GINAC_ASSERT(is_ex_exactly_of_type(overall_coeff,numeric));
- c = gcd(ex_to_numeric(overall_coeff),c);
+ GINAC_ASSERT(is_exactly_a<numeric>(overall_coeff));
+ c = gcd(ex_to<numeric>(overall_coeff),c);
return c;
}
epvector::const_iterator it = seq.begin();
epvector::const_iterator itend = seq.end();
while (it != itend) {
- GINAC_ASSERT(!is_ex_exactly_of_type(recombine_pair_to_ex(*it),numeric));
+ GINAC_ASSERT(!is_exactly_a<numeric>(recombine_pair_to_ex(*it)));
++it;
}
#endif // def DO_GINAC_ASSERT
- GINAC_ASSERT(is_ex_exactly_of_type(overall_coeff,numeric));
- return abs(ex_to_numeric(overall_coeff));
+ GINAC_ASSERT(is_exactly_a<numeric>(overall_coeff));
+ return abs(ex_to<numeric>(overall_coeff));
}
return a / b;
#if FAST_COMPARE
if (a.is_equal(b))
- return _ex1();
+ 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 = _ex0();
ex r = a.expand();
if (r.is_zero())
return r;
int rdeg = r.degree(x);
ex blcoeff = b.expand().coeff(x, bdeg);
bool blcoeff_is_numeric = is_ex_exactly_of_type(blcoeff, numeric);
+ exvector v; v.reserve(std::max(rdeg - bdeg + 1, 0));
while (rdeg >= bdeg) {
ex term, rcoeff = r.coeff(x, rdeg);
if (blcoeff_is_numeric)
return (new fail())->setflag(status_flags::dynallocated);
}
term *= power(x, rdeg - bdeg);
- q += term;
+ v.push_back(term);
r -= (term * b).expand();
if (r.is_zero())
break;
rdeg = r.degree(x);
}
- return q;
+ return (new add(v))->setflag(status_flags::dynallocated);
}
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 _ex0();
+ return _ex0;
else
- return b;
+ return a;
}
#if FAST_COMPARE
if (a.is_equal(b))
- return _ex0();
+ 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"));
}
+/** Decompose rational function a(x)=N(x)/D(x) into P(x)+n(x)/D(x)
+ * with degree(n, x) < degree(D, x).
+ *
+ * @param a rational function in x
+ * @param x a is a function of x
+ * @return decomposed function. */
+ex decomp_rational(const ex &a, const symbol &x)
+{
+ ex nd = numer_denom(a);
+ ex numer = nd.op(0), denom = nd.op(1);
+ ex q = quo(numer, denom, x);
+ if (is_ex_exactly_of_type(q, fail))
+ return a;
+ else
+ return q + rem(numer, denom, x) / denom;
+}
+
+
/** Pseudo-remainder of polynomials a(x) and b(x) in Z[x].
*
* @param a first polynomial in x (dividend)
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 _ex0();
+ return _ex0;
else
return b;
}
if (bdeg <= rdeg) {
blcoeff = eb.coeff(x, bdeg);
if (bdeg == 0)
- eb = _ex0();
+ eb = _ex0;
else
eb -= blcoeff * power(x, bdeg);
} else
- blcoeff = _ex1();
+ 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 = _ex0();
+ r = _ex0;
else
r -= rlcoeff * power(x, rdeg);
r = (blcoeff * r).expand() - term;
* @param check_args check whether a and b are polynomials with rational
* coefficients (defaults to "true")
* @return sparse pseudo-remainder of a(x) and b(x) in Z[x] */
-
ex sprem(const ex &a, const ex &b, const symbol &x, bool check_args)
{
if (b.is_zero())
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 _ex0();
+ return _ex0;
else
return b;
}
if (bdeg <= rdeg) {
blcoeff = eb.coeff(x, bdeg);
if (bdeg == 0)
- eb = _ex0();
+ eb = _ex0;
else
eb -= blcoeff * power(x, bdeg);
} else
- blcoeff = _ex1();
+ blcoeff = _ex1;
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 = _ex0();
+ r = _ex0;
else
r -= rlcoeff * power(x, rdeg);
r = (blcoeff * r).expand() - term;
* @param check_args check whether a and b are polynomials with rational
* coefficients (defaults to "true")
* @return "true" when exact division succeeds (quotient returned in q),
- * "false" otherwise */
+ * "false" otherwise (q left untouched) */
bool divide(const ex &a, const ex &b, ex &q, bool check_args)
{
- q = _ex0();
if (b.is_zero())
throw(std::overflow_error("divide: division by zero"));
- if (a.is_zero())
+ if (a.is_zero()) {
+ q = _ex0;
return true;
+ }
if (is_ex_exactly_of_type(b, numeric)) {
q = a / b;
return true;
return false;
#if FAST_COMPARE
if (a.is_equal(b)) {
- q = _ex1();
+ q = _ex1;
return true;
}
#endif
// Polynomial long division (recursive)
ex r = a.expand();
- if (r.is_zero())
+ if (r.is_zero()) {
+ q = _ex0;
return true;
+ }
int bdeg = b.degree(*x);
int rdeg = r.degree(*x);
ex blcoeff = b.expand().coeff(*x, bdeg);
bool blcoeff_is_numeric = is_ex_exactly_of_type(blcoeff, numeric);
+ exvector v; v.reserve(std::max(rdeg - bdeg + 1, 0));
while (rdeg >= bdeg) {
ex term, rcoeff = r.coeff(*x, rdeg);
if (blcoeff_is_numeric)
if (!divide(rcoeff, blcoeff, term, false))
return false;
term *= power(*x, rdeg - bdeg);
- q += term;
+ v.push_back(term);
r -= (term * b).expand();
- if (r.is_zero())
+ if (r.is_zero()) {
+ q = (new add(v))->setflag(status_flags::dynallocated);
return true;
+ }
rdeg = r.degree(*x);
}
return false;
* @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 = _ex0();
+ q = _ex0;
if (b.is_zero())
throw(std::overflow_error("divide_in_z: division by zero"));
- if (b.is_equal(_ex1())) {
+ if (b.is_equal(_ex1)) {
q = a;
return true;
}
}
#if FAST_COMPARE
if (a.is_equal(b)) {
- q = _ex1();
+ 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 = _num0();
+ numeric point = _num0;
ex c;
for (i=0; i<=adeg; i++) {
ex bs = b.subs(*x == point);
while (bs.is_zero()) {
- point += _num1();
+ 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 += _num1();
+ point += _num1;
}
// Compute inverses
vector<numeric> rcp; rcp.reserve(adeg + 1);
- rcp.push_back(_num0());
+ rcp.push_back(_num0);
for (k=1; k<=adeg; k++) {
numeric product = alpha[k] - alpha[0];
for (i=1; i<k; i++)
int rdeg = adeg;
ex eb = b.expand();
ex blcoeff = eb.coeff(*x, bdeg);
+ exvector v; v.reserve(std::max(rdeg - bdeg + 1, 0));
while (rdeg >= bdeg) {
ex term, rcoeff = r.coeff(*x, rdeg);
if (!divide_in_z(rcoeff, blcoeff, term, var+1))
break;
term = (term * power(*x, rdeg - bdeg)).expand();
- q += term;
+ v.push_back(term);
r -= (term * eb).expand();
if (r.is_zero()) {
+ q = (new add(v))->setflag(status_flags::dynallocated);
#if USE_REMEMBER
dr_remember[ex2(a, b)] = exbool(q, true);
#endif
{
ex c = expand().lcoeff(x);
if (is_ex_exactly_of_type(c, numeric))
- return c < _ex0() ? _ex_1() : _ex1();
+ 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 _ex0();
+ 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 _ex0();
+ 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 = _ex0();
+ 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 _ex0();
+ return _ex0;
if (is_ex_exactly_of_type(*this, numeric))
- return _ex1();
+ return _ex1;
ex c = content(x);
if (c.is_zero())
- return _ex0();
+ 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 _ex0();
+ return _ex0;
if (c.is_zero())
- return _ex0();
+ return _ex0;
if (is_ex_exactly_of_type(*this, numeric))
- return _ex1();
+ return _ex1;
ex u = unit(x);
if (is_ex_exactly_of_type(c, numeric))
d = d.primpart(*x, cont_d);
// First element of divisor sequence
- ex r, ri = _ex1();
+ ex r, ri = _ex1;
int delta = cdeg - ddeg;
for (;;) {
//std::clog << " content " << gamma << " removed, continuing with sr_gcd(" << c << "," << d << ")\n";
// First element of subresultant sequence
- ex r = _ex0(), ri = _ex1(), psi = _ex1();
+ ex r = _ex0, ri = _ex1, psi = _ex1;
int delta = cdeg - ddeg;
for (;;) {
* @see heur_gcd */
numeric basic::max_coefficient(void) const
{
- return _num1();
+ return _num1;
}
numeric numeric::max_coefficient(void) const
{
epvector::const_iterator it = seq.begin();
epvector::const_iterator itend = seq.end();
- GINAC_ASSERT(is_ex_exactly_of_type(overall_coeff,numeric));
- numeric cur_max = abs(ex_to_numeric(overall_coeff));
+ GINAC_ASSERT(is_exactly_a<numeric>(overall_coeff));
+ numeric cur_max = abs(ex_to<numeric>(overall_coeff));
while (it != itend) {
numeric a;
- GINAC_ASSERT(!is_ex_exactly_of_type(it->rest,numeric));
- a = abs(ex_to_numeric(it->coeff));
+ GINAC_ASSERT(!is_exactly_a<numeric>(it->rest));
+ a = abs(ex_to<numeric>(it->coeff));
if (a > cur_max)
cur_max = a;
it++;
epvector::const_iterator it = seq.begin();
epvector::const_iterator itend = seq.end();
while (it != itend) {
- GINAC_ASSERT(!is_ex_exactly_of_type(recombine_pair_to_ex(*it),numeric));
+ GINAC_ASSERT(!is_exactly_a<numeric>(recombine_pair_to_ex(*it)));
it++;
}
#endif // def DO_GINAC_ASSERT
- GINAC_ASSERT(is_ex_exactly_of_type(overall_coeff,numeric));
- return abs(ex_to_numeric(overall_coeff));
+ GINAC_ASSERT(is_exactly_a<numeric>(overall_coeff));
+ return abs(ex_to<numeric>(overall_coeff));
}
-/** Apply symmetric modular homomorphism to a multivariate polynomial.
- * This function is used internally by heur_gcd().
+/** Apply symmetric modular homomorphism to an expanded multivariate
+ * polynomial. This function is usually used internally by heur_gcd().
*
- * @param e expanded multivariate polynomial
* @param xi modulus
* @return mapped polynomial
* @see heur_gcd */
-ex ex::smod(const numeric &xi) const
-{
- GINAC_ASSERT(bp!=0);
- return bp->smod(xi);
-}
-
ex basic::smod(const numeric &xi) const
{
return *this;
epvector::const_iterator it = seq.begin();
epvector::const_iterator itend = seq.end();
while (it != itend) {
- GINAC_ASSERT(!is_ex_exactly_of_type(it->rest,numeric));
- numeric coeff = GiNaC::smod(ex_to_numeric(it->coeff), xi);
+ GINAC_ASSERT(!is_exactly_a<numeric>(it->rest));
+ numeric coeff = GiNaC::smod(ex_to<numeric>(it->coeff), xi);
if (!coeff.is_zero())
newseq.push_back(expair(it->rest, coeff));
it++;
}
- GINAC_ASSERT(is_ex_exactly_of_type(overall_coeff,numeric));
- numeric coeff = GiNaC::smod(ex_to_numeric(overall_coeff), xi);
+ GINAC_ASSERT(is_exactly_a<numeric>(overall_coeff));
+ numeric coeff = GiNaC::smod(ex_to<numeric>(overall_coeff), xi);
return (new add(newseq,coeff))->setflag(status_flags::dynallocated);
}
epvector::const_iterator it = seq.begin();
epvector::const_iterator itend = seq.end();
while (it != itend) {
- GINAC_ASSERT(!is_ex_exactly_of_type(recombine_pair_to_ex(*it),numeric));
+ GINAC_ASSERT(!is_exactly_a<numeric>(recombine_pair_to_ex(*it)));
it++;
}
#endif // def DO_GINAC_ASSERT
mul * mulcopyp = new mul(*this);
- GINAC_ASSERT(is_ex_exactly_of_type(overall_coeff,numeric));
- mulcopyp->overall_coeff = GiNaC::smod(ex_to_numeric(overall_coeff),xi);
+ GINAC_ASSERT(is_exactly_a<numeric>(overall_coeff));
+ mulcopyp->overall_coeff = GiNaC::smod(ex_to<numeric>(overall_coeff),xi);
mulcopyp->clearflag(status_flags::evaluated);
mulcopyp->clearflag(status_flags::hash_calculated);
return mulcopyp->setflag(status_flags::dynallocated);
/** xi-adic polynomial interpolation */
-static ex interpolate(const ex &gamma, const numeric &xi, const symbol &x)
+static ex interpolate(const ex &gamma, const numeric &xi, const symbol &x, int degree_hint = 1)
{
- ex g = _ex0();
+ exvector g; g.reserve(degree_hint);
ex e = gamma;
numeric rxi = xi.inverse();
for (int i=0; !e.is_zero(); i++) {
ex gi = e.smod(xi);
- g += gi * power(x, i);
+ g.push_back(gi * power(x, i));
e = (e - gi) * rxi;
}
- return g;
+ return (new add(g))->setflag(status_flags::dynallocated);
}
/** Exception thrown by heur_gcd() to signal failure. */
heur_gcd_called++;
#endif
- // Algorithms only works for non-vanishing input polynomials
+ // Algorithm only works for non-vanishing input polynomials
if (a.is_zero() || b.is_zero())
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)) {
- numeric g = gcd(ex_to_numeric(a), ex_to_numeric(b));
+ numeric g = gcd(ex_to<numeric>(a), ex_to<numeric>(b));
if (ca)
- *ca = ex_to_numeric(a) / g;
+ *ca = ex_to<numeric>(a) / g;
if (cb)
- *cb = ex_to_numeric(b) / g;
+ *cb = ex_to<numeric>(b) / g;
return g;
}
numeric rgc = gc.inverse();
ex p = a * rgc;
ex q = b * rgc;
- int maxdeg = std::max(p.degree(x),q.degree(x));
+ int maxdeg = std::max(p.degree(x), q.degree(x));
// Find evaluation point
numeric mp = p.max_coefficient();
numeric mq = q.max_coefficient();
numeric xi;
if (mp > mq)
- xi = mq * _num2() + _num2();
+ xi = mq * _num2 + _num2;
else
- xi = mp * _num2() + _num2();
+ 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 = interpolate(gamma, xi, x);
+ ex g = interpolate(gamma, xi, x, maxdeg);
// Remove integer content
g /= g.integer_content();
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) && ex_to_numeric(lc).is_negative())
+ if (is_ex_exactly_of_type(lc, numeric) && ex_to<numeric>(lc).is_negative())
return -g;
else
return g;
if (ca)
*ca = cp;
ex lc = g.lcoeff(x);
- if (is_ex_exactly_of_type(lc, numeric) && ex_to_numeric(lc).is_negative())
+ if (is_ex_exactly_of_type(lc, numeric) && ex_to<numeric>(lc).is_negative())
return -g;
else
return g;
if (cb)
*cb = cq;
ex lc = g.lcoeff(x);
- if (is_ex_exactly_of_type(lc, numeric) && ex_to_numeric(lc).is_negative())
+ if (is_ex_exactly_of_type(lc, numeric) && ex_to<numeric>(lc).is_negative())
return -g;
else
return g;
// GCD of numerics -> CLN
if (is_ex_exactly_of_type(a, numeric) && is_ex_exactly_of_type(b, numeric)) {
- numeric g = gcd(ex_to_numeric(a), ex_to_numeric(b));
+ numeric g = gcd(ex_to<numeric>(a), ex_to<numeric>(b));
if (ca || cb) {
if (g.is_zero()) {
if (ca)
- *ca = _ex0();
+ *ca = _ex0;
if (cb)
- *cb = _ex0();
+ *cb = _ex0;
} else {
if (ca)
- *ca = ex_to_numeric(a) / g;
+ *ca = ex_to<numeric>(a) / g;
if (cb)
- *cb = ex_to_numeric(b) / g;
+ *cb = ex_to<numeric>(b) / g;
}
}
return g;
if (is_ex_exactly_of_type(b, mul) && b.nops() > a.nops())
goto factored_b;
factored_a:
- ex g = _ex1();
- ex acc_ca = _ex1();
+ unsigned num = a.nops();
+ exvector g; g.reserve(num);
+ exvector acc_ca; acc_ca.reserve(num);
ex part_b = b;
- for (unsigned i=0; i<a.nops(); i++) {
+ for (unsigned i=0; i<num; i++) {
ex part_ca, part_cb;
- g *= gcd(a.op(i), part_b, &part_ca, &part_cb, check_args);
- acc_ca *= part_ca;
+ g.push_back(gcd(a.op(i), part_b, &part_ca, &part_cb, check_args));
+ acc_ca.push_back(part_ca);
part_b = part_cb;
}
if (ca)
- *ca = acc_ca;
+ *ca = (new mul(acc_ca))->setflag(status_flags::dynallocated);
if (cb)
*cb = part_b;
- return g;
+ return (new mul(g))->setflag(status_flags::dynallocated);
} else if (is_ex_exactly_of_type(b, mul)) {
if (is_ex_exactly_of_type(a, mul) && a.nops() > b.nops())
goto factored_a;
factored_b:
- ex g = _ex1();
- ex acc_cb = _ex1();
+ unsigned num = b.nops();
+ exvector g; g.reserve(num);
+ exvector acc_cb; acc_cb.reserve(num);
ex part_a = a;
- for (unsigned i=0; i<b.nops(); i++) {
+ for (unsigned i=0; i<num; i++) {
ex part_ca, part_cb;
- g *= gcd(part_a, b.op(i), &part_ca, &part_cb, check_args);
- acc_cb *= part_cb;
+ g.push_back(gcd(part_a, b.op(i), &part_ca, &part_cb, check_args));
+ acc_cb.push_back(part_cb);
part_a = part_ca;
}
if (ca)
*ca = part_a;
if (cb)
- *cb = acc_cb;
- return g;
+ *cb = (new mul(acc_cb))->setflag(status_flags::dynallocated);
+ return (new mul(g))->setflag(status_flags::dynallocated);
}
#if FAST_COMPARE
ex exp_a = a.op(1), exp_b = b.op(1);
if (exp_a < exp_b) {
if (ca)
- *ca = _ex1();
+ *ca = _ex1;
if (cb)
*cb = power(p, exp_b - exp_a);
return power(p, exp_a);
if (ca)
*ca = power(p, exp_a - exp_b);
if (cb)
- *cb = _ex1();
+ *cb = _ex1;
return power(p, exp_b);
}
}
if (ca)
*ca = power(p, a.op(1) - 1);
if (cb)
- *cb = _ex1();
+ *cb = _ex1;
return p;
}
}
if (p.is_equal(a)) {
// a = p, b = p^n, gcd = p
if (ca)
- *ca = _ex1();
+ *ca = _ex1;
if (cb)
*cb = power(p, b.op(1) - 1);
return p;
ex aex = a.expand(), bex = b.expand();
if (aex.is_zero()) {
if (ca)
- *ca = _ex0();
+ *ca = _ex0;
if (cb)
- *cb = _ex1();
+ *cb = _ex1;
return b;
}
if (bex.is_zero()) {
if (ca)
- *ca = _ex1();
+ *ca = _ex1;
if (cb)
- *cb = _ex0();
+ *cb = _ex0;
return a;
}
- if (aex.is_equal(_ex1()) || bex.is_equal(_ex1())) {
+ if (aex.is_equal(_ex1) || bex.is_equal(_ex1)) {
if (ca)
*ca = a;
if (cb)
*cb = b;
- return _ex1();
+ return _ex1;
}
#if FAST_COMPARE
if (a.is_equal(b)) {
if (ca)
- *ca = _ex1();
+ *ca = _ex1;
if (cb)
- *cb = _ex1();
+ *cb = _ex1;
return a;
}
#endif
// g = peu_gcd(aex, bex, &x);
// g = red_gcd(aex, bex, &x);
g = sr_gcd(aex, bex, var);
- if (g.is_equal(_ex1())) {
+ if (g.is_equal(_ex1)) {
// Keep cofactors factored if possible
if (ca)
*ca = a;
}
#if 1
} else {
- if (g.is_equal(_ex1())) {
+ if (g.is_equal(_ex1)) {
// Keep cofactors factored if possible
if (ca)
*ca = a;
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));
+ 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)))
throw(std::invalid_argument("lcm: arguments must be polynomials over the rationals"));
ex w = a;
ex z = w.diff(x);
ex g = gcd(w, z);
- if (g.is_equal(_ex1())) {
+ if (g.is_equal(_ex1)) {
res.push_back(a);
return res;
}
} while (!z.is_zero());
return res;
}
-/** Compute square-free factorization of multivariate polynomial in Q[X].
+
+/** Compute a square-free factorization of a multivariate polynomial in Q[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. */
+ * @return a square-free factorization of \p a.
+ *
+ * \note
+ * A polynomial \f$p(X) \in C[X]\f$ is said <EM>square-free</EM>
+ * if, whenever any two polynomials \f$q(X)\f$ and \f$r(X)\f$
+ * are such that
+ * \f[
+ * p(X) = q(X)^2 r(X),
+ * \f]
+ * we have \f$q(X) \in C\f$.
+ * This means that \f$p(X)\f$ has no repeated factors, apart
+ * eventually from constants.
+ * Given a polynomial \f$p(X) \in C[X]\f$, we say that the
+ * decomposition
+ * \f[
+ * p(X) = b \cdot p_1(X)^{a_1} \cdot p_2(X)^{a_2} \cdots p_r(X)^{a_r}
+ * \f]
+ * is a <EM>square-free factorization</EM> of \f$p(X)\f$ if the
+ * following conditions hold:
+ * -# \f$b \in C\f$ and \f$b \neq 0\f$;
+ * -# \f$a_i\f$ is a positive integer for \f$i = 1, \ldots, r\f$;
+ * -# the degree of the polynomial \f$p_i\f$ is strictly positive
+ * for \f$i = 1, \ldots, r\f$;
+ * -# the polynomial \f$\Pi_{i=1}^r p_i(X)\f$ is square-free.
+ *
+ * Square-free factorizations need not be unique. For example, if
+ * \f$a_i\f$ is even, we could change the polynomial \f$p_i(X)\f$
+ * into \f$-p_i(X)\f$.
+ * Observe also that the factors \f$p_i(X)\f$ need not be irreducible
+ * polynomials.
+ */
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
+ if (is_a<numeric>(a) || // algorithm does not trap a==0
+ is_a<symbol>(a)) // 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)
+ get_symbol_stats(a, _ex0, sdv);
+ sym_desc_vec::const_iterator it = sdv.begin(), itend = sdv.end();
+ while (it != itend) {
args.append(*it->sym);
+ ++it;
+ }
} else {
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));
+ 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);
+ const numeric lcm = lcm_of_coefficients_denominators(a);
+ const 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
+ lst newargs = args;
+ newargs.remove_first();
+
+ // recurse down the factors in remaining variables
if (newargs.nops()>0) {
- for (exvector::iterator i=factors.begin(); i!=factors.end(); ++i)
+ exvector::iterator i = factors.begin();
+ while (i != factors.end()) {
*i = sqrfree(*i, newargs);
+ ++i;
+ }
}
+
// 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)
+ ex result = _ex1;
+ exvector::const_iterator it = factors.begin(), itend = factors.end();
+ for (int p = 1; it!=itend; ++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);
+
+ // 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. For completeness
+ // we'll also have to recurse down that factor in the remaining variables.
+ if (newargs.nops()>0)
+ result *= sqrfree(quo(tmp, result, x), newargs);
+ else
+ result *= quo(tmp, result, x);
+
+ // Put in the reational overall factor again and return
return result * lcm.inverse();
}
+/** Compute square-free partial fraction decomposition of rational function
+ * a(x).
+ *
+ * @param a rational function over Z[x], treated as univariate polynomial
+ * in x
+ * @param x variable to factor in
+ * @return decomposed rational function */
+ex sqrfree_parfrac(const ex & a, const symbol & x)
+{
+ // Find numerator and denominator
+ ex nd = numer_denom(a);
+ ex numer = nd.op(0), denom = nd.op(1);
+//clog << "numer = " << numer << ", denom = " << denom << endl;
+
+ // Convert N(x)/D(x) -> Q(x) + R(x)/D(x), so degree(R) < degree(D)
+ ex red_poly = quo(numer, denom, x), red_numer = rem(numer, denom, x).expand();
+//clog << "red_poly = " << red_poly << ", red_numer = " << red_numer << endl;
+
+ // Factorize denominator and compute cofactors
+ exvector yun = sqrfree_yun(denom, x);
+//clog << "yun factors: " << exprseq(yun) << endl;
+ unsigned num_yun = yun.size();
+ exvector factor; factor.reserve(num_yun);
+ exvector cofac; cofac.reserve(num_yun);
+ for (unsigned i=0; i<num_yun; i++) {
+ if (!yun[i].is_equal(_ex1)) {
+ for (unsigned j=0; j<=i; j++) {
+ factor.push_back(pow(yun[i], j+1));
+ ex prod = _ex1;
+ for (unsigned k=0; k<num_yun; k++) {
+ if (k == i)
+ prod *= pow(yun[k], i-j);
+ else
+ prod *= pow(yun[k], k+1);
+ }
+ cofac.push_back(prod.expand());
+ }
+ }
+ }
+ unsigned num_factors = factor.size();
+//clog << "factors : " << exprseq(factor) << endl;
+//clog << "cofactors: " << exprseq(cofac) << endl;
+
+ // Construct coefficient matrix for decomposition
+ int max_denom_deg = denom.degree(x);
+ matrix sys(max_denom_deg + 1, num_factors);
+ matrix rhs(max_denom_deg + 1, 1);
+ for (int i=0; i<=max_denom_deg; i++) {
+ for (unsigned j=0; j<num_factors; j++)
+ sys(i, j) = cofac[j].coeff(x, i);
+ rhs(i, 0) = red_numer.coeff(x, i);
+ }
+//clog << "coeffs: " << sys << endl;
+//clog << "rhs : " << rhs << endl;
+
+ // Solve resulting linear system
+ matrix vars(num_factors, 1);
+ for (unsigned i=0; i<num_factors; i++)
+ vars(i, 0) = symbol();
+ matrix sol = sys.solve(vars, rhs);
+
+ // Sum up decomposed fractions
+ ex sum = 0;
+ for (unsigned i=0; i<num_factors; i++)
+ sum += sol(i, 0) / factor[i];
+
+ return red_poly + sum;
+}
+
/*
* Normal form of rational functions
* the information that (a+b) is the numerator and 3 is the denominator.
*/
+
/** Create a symbol for replacing the expression "e" (or return a previously
* assigned symbol). The symbol is appended to sym_lst and returned, the
* expression is appended to repl_lst.
/** Create a symbol for replacing the expression "e" (or return a previously
* assigned symbol). An expression of the form "symbol == expression" is added
* to repl_lst and the symbol is returned.
- * @see ex::to_rational */
+ * @see basic::to_rational */
static ex replace_with_symbol(const ex &e, lst &repl_lst)
{
// Expression already in repl_lst? Then return the assigned symbol
return es;
}
-/** Default implementation of ex::normal(). It replaces the object with a
- * temporary symbol.
+
+/** Function object to be applied by basic::normal(). */
+struct normal_map_function : public map_function {
+ int level;
+ normal_map_function(int l) : level(l) {}
+ ex operator()(const ex & e) { return normal(e, level); }
+};
+
+/** Default implementation of ex::normal(). It normalizes the children and
+ * replaces the object with a temporary symbol.
* @see ex::normal */
ex basic::normal(lst &sym_lst, lst &repl_lst, int level) const
{
- return (new lst(replace_with_symbol(*this, sym_lst, repl_lst), _ex1()))->setflag(status_flags::dynallocated);
+ if (nops() == 0)
+ return (new lst(replace_with_symbol(*this, sym_lst, repl_lst), _ex1))->setflag(status_flags::dynallocated);
+ else {
+ if (level == 1)
+ return (new lst(replace_with_symbol(*this, sym_lst, repl_lst), _ex1))->setflag(status_flags::dynallocated);
+ else if (level == -max_recursion_level)
+ throw(std::runtime_error("max recursion level reached"));
+ else {
+ normal_map_function map_normal(level - 1);
+ return (new lst(replace_with_symbol(map(map_normal), sym_lst, repl_lst), _ex1))->setflag(status_flags::dynallocated);
+ }
+ }
}
* @see ex::normal */
ex symbol::normal(lst &sym_lst, lst &repl_lst, int level) const
{
- return (new lst(*this, _ex1()))->setflag(status_flags::dynallocated);
+ return (new lst(*this, _ex1))->setflag(status_flags::dynallocated);
}
{
ex num = n;
ex den = d;
- numeric pre_factor = _num1();
+ numeric pre_factor = _num1;
//std::clog << "frac_cancel num = " << num << ", den = " << den << std::endl;
// Handle trivial case where denominator is 1
- if (den.is_equal(_ex1()))
+ 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(num, _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"));
// Cancel GCD from numerator and denominator
ex cnum, cden;
- if (gcd(num, den, &cnum, &cden, false) != _ex1()) {
+ 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)) {
- GINAC_ASSERT(is_ex_exactly_of_type(den.unit(*x),numeric));
- if (ex_to_numeric(den.unit(*x)).is_negative()) {
- num *= _ex_1();
- den *= _ex_1();
+ GINAC_ASSERT(is_exactly_a<numeric>(den.unit(*x)));
+ if (ex_to<numeric>(den.unit(*x)).is_negative()) {
+ num *= _ex_1;
+ den *= _ex_1;
}
}
ex add::normal(lst &sym_lst, lst &repl_lst, int level) const
{
if (level == 1)
- return (new lst(replace_with_symbol(*this, sym_lst, repl_lst), _ex1()))->setflag(status_flags::dynallocated);
+ return (new lst(replace_with_symbol(*this, sym_lst, repl_lst), _ex1))->setflag(status_flags::dynallocated);
else if (level == -max_recursion_level)
throw(std::runtime_error("max recursion level reached"));
dens.reserve(seq.size()+1);
epvector::const_iterator it = seq.begin(), itend = seq.end();
while (it != itend) {
- ex n = recombine_pair_to_ex(*it).bp->normal(sym_lst, repl_lst, level-1);
+ ex n = ex_to<basic>(recombine_pair_to_ex(*it)).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);
+ ex n = ex_to<numeric>(overall_coeff).normal(sym_lst, repl_lst, level-1);
nums.push_back(n.op(0));
dens.push_back(n.op(1));
GINAC_ASSERT(nums.size() == dens.size());
ex mul::normal(lst &sym_lst, lst &repl_lst, int level) const
{
if (level == 1)
- return (new lst(replace_with_symbol(*this, sym_lst, repl_lst), _ex1()))->setflag(status_flags::dynallocated);
+ return (new lst(replace_with_symbol(*this, sym_lst, repl_lst), _ex1))->setflag(status_flags::dynallocated);
else if (level == -max_recursion_level)
throw(std::runtime_error("max recursion level reached"));
// Normalize children, separate into numerator and denominator
- ex num = _ex1();
- ex den = _ex1();
+ exvector num; num.reserve(seq.size());
+ exvector den; den.reserve(seq.size());
ex n;
epvector::const_iterator it = seq.begin(), itend = seq.end();
while (it != itend) {
- n = recombine_pair_to_ex(*it).bp->normal(sym_lst, repl_lst, level-1);
- num *= n.op(0);
- den *= n.op(1);
+ n = ex_to<basic>(recombine_pair_to_ex(*it)).normal(sym_lst, repl_lst, level-1);
+ num.push_back(n.op(0));
+ den.push_back(n.op(1));
it++;
}
- n = overall_coeff.bp->normal(sym_lst, repl_lst, level-1);
- num *= n.op(0);
- den *= n.op(1);
+ n = ex_to<numeric>(overall_coeff).normal(sym_lst, repl_lst, level-1);
+ num.push_back(n.op(0));
+ den.push_back(n.op(1));
// Perform fraction cancellation
- return frac_cancel(num, den);
+ return frac_cancel((new mul(num))->setflag(status_flags::dynallocated),
+ (new mul(den))->setflag(status_flags::dynallocated));
}
ex power::normal(lst &sym_lst, lst &repl_lst, int level) const
{
if (level == 1)
- return (new lst(replace_with_symbol(*this, sym_lst, repl_lst), _ex1()))->setflag(status_flags::dynallocated);
+ return (new lst(replace_with_symbol(*this, sym_lst, repl_lst), _ex1))->setflag(status_flags::dynallocated);
else if (level == -max_recursion_level)
throw(std::runtime_error("max recursion level reached"));
// 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);
+ ex n_basis = ex_to<basic>(basis).normal(sym_lst, repl_lst, level-1);
+ ex n_exponent = ex_to<basic>(exponent).normal(sym_lst, repl_lst, level-1);
n_exponent = n_exponent.op(0) / n_exponent.op(1);
if (n_exponent.info(info_flags::integer)) {
if (n_exponent.info(info_flags::positive)) {
// (a/b)^x -> {sym((a/b)^x), 1}
- 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);
+ 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 (n_exponent.info(info_flags::negative)) {
- if (n_basis.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_basis.op(0), -n_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_basis.op(1) / n_basis.op(0), -n_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 { // n_exponent not numeric
// (a/b)^x -> {sym((a/b)^x, 1}
- 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);
+ 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);
}
}
}
ex pseries::normal(lst &sym_lst, lst &repl_lst, int level) const
{
epvector newseq;
- for (epvector::const_iterator i=seq.begin(); i!=seq.end(); ++i) {
+ epvector::const_iterator i = seq.begin(), end = seq.end();
+ while (i != end) {
ex restexp = i->rest.normal();
if (!restexp.is_zero())
newseq.push_back(expair(restexp, i->coeff));
+ ++i;
}
ex n = pseries(relational(var,point), newseq);
- return (new lst(replace_with_symbol(n, sym_lst, repl_lst), _ex1()))->setflag(status_flags::dynallocated);
-}
-
-
-/** Implementation of ex::normal() for relationals. It normalizes both sides.
- * @see ex::normal */
-ex relational::normal(lst &sym_lst, lst &repl_lst, int level) const
-{
- return (new lst(relational(lh.normal(), rh.normal(), o), _ex1()))->setflag(status_flags::dynallocated);
+ return (new lst(replace_with_symbol(n, sym_lst, repl_lst), _ex1))->setflag(status_flags::dynallocated);
}
lst sym_lst, repl_lst;
ex e = bp->normal(sym_lst, repl_lst, level);
- GINAC_ASSERT(is_ex_of_type(e, lst));
+ GINAC_ASSERT(is_a<lst>(e));
// Re-insert replaced symbols
if (sym_lst.nops() > 0)
lst sym_lst, repl_lst;
ex e = bp->normal(sym_lst, repl_lst, 0);
- GINAC_ASSERT(is_ex_of_type(e, lst));
+ GINAC_ASSERT(is_a<lst>(e));
// Re-insert replaced symbols
if (sym_lst.nops() > 0)
lst sym_lst, repl_lst;
ex e = bp->normal(sym_lst, repl_lst, 0);
- GINAC_ASSERT(is_ex_of_type(e, lst));
+ GINAC_ASSERT(is_a<lst>(e));
// Re-insert replaced symbols
if (sym_lst.nops() > 0)
lst sym_lst, repl_lst;
ex e = bp->normal(sym_lst, repl_lst, 0);
- GINAC_ASSERT(is_ex_of_type(e, lst));
+ GINAC_ASSERT(is_a<lst>(e));
// Re-insert replaced symbols
if (sym_lst.nops() > 0)
}
-/** Default implementation of ex::to_rational(). It replaces the object with a
- * temporary symbol.
- * @see ex::to_rational */
+/** Rationalization of non-rational functions.
+ * This function converts a general expression to a rational polynomial
+ * by replacing all non-rational subexpressions (like non-rational numbers,
+ * non-integer powers or functions like sin(), cos() etc.) to temporary
+ * symbols. This makes it possible to use functions like gcd() and divide()
+ * on non-rational functions by applying to_rational() on the arguments,
+ * calling the desired function and re-substituting the temporary symbols
+ * in the result. To make the last step possible, all temporary symbols and
+ * their associated expressions are collected in the list specified by the
+ * repl_lst parameter in the form {symbol == expression}, ready to be passed
+ * as an argument to ex::subs().
+ *
+ * @param repl_lst collects a list of all temporary symbols and their replacements
+ * @return rationalized expression */
ex basic::to_rational(lst &repl_lst) const
{
return replace_with_symbol(*this, repl_lst);
/** Implementation of ex::to_rational() for symbols. This returns the
- * unmodified symbol.
- * @see ex::to_rational */
+ * unmodified symbol. */
ex symbol::to_rational(lst &repl_lst) const
{
return *this;
/** Implementation of ex::to_rational() for a numeric. It splits complex
* numbers into re+I*im and replaces I and non-rational real numbers with a
- * temporary symbol.
- * @see ex::to_rational */
+ * temporary symbol. */
ex numeric::to_rational(lst &repl_lst) const
{
if (is_real()) {
/** Implementation of ex::to_rational() for powers. It replaces non-integer
- * powers by temporary symbols.
- * @see ex::to_rational */
+ * powers by temporary symbols. */
ex power::to_rational(lst &repl_lst) const
{
if (exponent.info(info_flags::integer))
}
-/** Implementation of ex::to_rational() for expairseqs.
- * @see ex::to_rational */
+/** Implementation of ex::to_rational() for expairseqs. */
ex expairseq::to_rational(lst &repl_lst) const
{
epvector s;
s.reserve(seq.size());
- for (epvector::const_iterator it=seq.begin(); it!=seq.end(); ++it) {
- s.push_back(split_ex_to_pair(recombine_pair_to_ex(*it).to_rational(repl_lst)));
- // s.push_back(combine_ex_with_coeff_to_pair((*it).rest.to_rational(repl_lst),
+ epvector::const_iterator i = seq.begin(), end = seq.end();
+ while (i != end) {
+ s.push_back(split_ex_to_pair(recombine_pair_to_ex(*i).to_rational(repl_lst)));
+ ++i;
}
ex oc = overall_coeff.to_rational(repl_lst);
if (oc.info(info_flags::numeric))
return thisexpairseq(s, overall_coeff);
- else s.push_back(combine_ex_with_coeff_to_pair(oc,_ex1()));
+ else
+ s.push_back(combine_ex_with_coeff_to_pair(oc, _ex1));
return thisexpairseq(s, default_overall_coeff());
}
-/** Rationalization of non-rational functions.
- * This function converts a general expression to a rational polynomial
- * by replacing all non-rational subexpressions (like non-rational numbers,
- * non-integer powers or functions like sin(), cos() etc.) to temporary
- * symbols. This makes it possible to use functions like gcd() and divide()
- * on non-rational functions by applying to_rational() on the arguments,
- * calling the desired function and re-substituting the temporary symbols
- * in the result. To make the last step possible, all temporary symbols and
- * their associated expressions are collected in the list specified by the
- * repl_lst parameter in the form {symbol == expression}, ready to be passed
- * as an argument to ex::subs().
- *
- * @param repl_lst collects a list of all temporary symbols and their replacements
- * @return rationalized expression */
-ex ex::to_rational(lst &repl_lst) const
-{
- return bp->to_rational(repl_lst);
-}
-
-
} // namespace GiNaC
git://www.ginac.de / ginac.git / blobdiff