+ // Try to avoid expanding partially factored expressions.
+ if (is_exactly_a<mul>(b)) {
+ // Divide sequentially by each term
+ ex rem_new, rem_old = a;
+ for (size_t i=0; i < b.nops(); i++) {
+ if (! divide(rem_old, b.op(i), rem_new, false))
+ return false;
+ rem_old = rem_new;
+ }
+ q = rem_new;
+ return true;
+ } else if (is_exactly_a<power>(b)) {
+ const ex& bb(b.op(0));
+ int exp_b = ex_to<numeric>(b.op(1)).to_int();
+ ex rem_new, rem_old = a;
+ for (int i=exp_b; i>0; i--) {
+ if (! divide(rem_old, bb, rem_new, false))
+ return false;
+ rem_old = rem_new;
+ }
+ q = rem_new;
+ return true;
+ }
+
+ if (is_exactly_a<mul>(a)) {
+ // Divide sequentially each term. If some term in a is divisible
+ // by b we are done... and if not, we can't really say anything.
+ size_t i;
+ ex rem_i;
+ bool divisible_p = false;
+ for (i=0; i < a.nops(); ++i) {
+ if (divide(a.op(i), b, rem_i, false)) {
+ divisible_p = true;
+ break;
+ }
+ }
+ if (divisible_p) {
+ exvector resv;
+ resv.reserve(a.nops());
+ for (size_t j=0; j < a.nops(); j++) {
+ if (j==i)
+ resv.push_back(rem_i);
+ else
+ resv.push_back(a.op(j));
+ }
+ q = (new mul(resv))->setflag(status_flags::dynallocated);
+ return true;
+ }
+ } else if (is_exactly_a<power>(a)) {
+ // The base itself might be divisible by b, in that case we don't
+ // need to expand a
+ const ex& ab(a.op(0));
+ int a_exp = ex_to<numeric>(a.op(1)).to_int();
+ ex rem_i;
+ if (divide(ab, b, rem_i, false)) {
+ q = rem_i*power(ab, a_exp - 1);
+ return true;
+ }
+ for (int i=2; i < a_exp; i++) {
+ if (divide(power(ab, i), b, rem_i, false)) {
+ q = rem_i*power(ab, a_exp - i);
+ return true;
+ }
+ } // ... so we *really* need to expand expression.
+ }
+