+bool mul::has(const ex & pattern, unsigned options) const
+{
+ if(!(options&has_options::algebraic))
+ return basic::has(pattern,options);
+ if(is_a<mul>(pattern)) {
+ exmap repls;
+ int nummatches = std::numeric_limits<int>::max();
+ std::vector<bool> subsed(nops(), false);
+ std::vector<bool> matched(nops(), false);
+ if(algebraic_match_mul_with_mul(*this, pattern, repls, 0, nummatches,
+ subsed, matched))
+ return true;
+ }
+ return basic::has(pattern, options);
+}
+
+ex mul::algebraic_subs_mul(const exmap & m, unsigned options) const
+{
+ std::vector<bool> subsed(nops(), false);
+ ex divide_by = 1;
+ ex multiply_by = 1;
+
+ for (exmap::const_iterator it = m.begin(); it != m.end(); ++it) {
+
+ if (is_exactly_a<mul>(it->first)) {
+retry1:
+ int nummatches = std::numeric_limits<int>::max();
+ std::vector<bool> currsubsed(nops(), false);
+ exmap repls;
+
+ if(!algebraic_match_mul_with_mul(*this, it->first, repls, 0, nummatches, subsed, currsubsed))
+ continue;
+
+ for (size_t j=0; j<subsed.size(); j++)
+ if (currsubsed[j])
+ subsed[j] = true;
+ ex subsed_pattern
+ = it->first.subs(repls, subs_options::no_pattern);
+ divide_by *= power(subsed_pattern, nummatches);
+ ex subsed_result
+ = it->second.subs(repls, subs_options::no_pattern);
+ multiply_by *= power(subsed_result, nummatches);
+ goto retry1;
+
+ } else {
+
+ for (size_t j=0; j<this->nops(); j++) {
+ int nummatches = std::numeric_limits<int>::max();
+ exmap repls;
+ if (!subsed[j] && tryfactsubs(op(j), it->first, nummatches, repls)){
+ subsed[j] = true;
+ ex subsed_pattern
+ = it->first.subs(repls, subs_options::no_pattern);
+ divide_by *= power(subsed_pattern, nummatches);
+ ex subsed_result
+ = it->second.subs(repls, subs_options::no_pattern);
+ multiply_by *= power(subsed_result, nummatches);
+ }
+ }
+ }
+ }
+
+ bool subsfound = false;
+ for (size_t i=0; i<subsed.size(); i++) {
+ if (subsed[i]) {
+ subsfound = true;
+ break;
+ }
+ }
+ if (!subsfound)
+ return subs_one_level(m, options | subs_options::algebraic);
+
+ return ((*this)/divide_by)*multiply_by;
+}
+
+ex mul::conjugate() const
+{
+ // The base class' method is wrong here because we have to be careful at
+ // branch cuts. power::conjugate takes care of that already, so use it.
+ epvector *newepv = 0;
+ for (epvector::const_iterator i=seq.begin(); i!=seq.end(); ++i) {
+ if (newepv) {
+ newepv->push_back(split_ex_to_pair(recombine_pair_to_ex(*i).conjugate()));
+ continue;
+ }
+ ex x = recombine_pair_to_ex(*i);
+ ex c = x.conjugate();
+ if (c.is_equal(x)) {
+ continue;
+ }
+ newepv = new epvector;
+ newepv->reserve(seq.size());
+ for (epvector::const_iterator j=seq.begin(); j!=i; ++j) {
+ newepv->push_back(*j);
+ }
+ newepv->push_back(split_ex_to_pair(c));
+ }
+ ex x = overall_coeff.conjugate();
+ if (!newepv && are_ex_trivially_equal(x, overall_coeff)) {
+ return *this;
+ }
+ ex result = thisexpairseq(newepv ? *newepv : seq, x);
+ delete newepv;
+ return result;
+}
+
+