#include "expairseq.h"
#include "lst.h"
+#include "relational.h"
#include "print.h"
#include "archive.h"
#include "debugmsg.h"
throw(std::logic_error("let_op not defined for expairseq and derived classes (add,mul,...)"));
}
+ex expairseq::map(map_function & f) const
+{
+ epvector *v = new epvector;
+ v->reserve(seq.size());
+
+ epvector::const_iterator cit = seq.begin(), last = seq.end();
+ while (cit != last) {
+ v->push_back(split_ex_to_pair(f(recombine_pair_to_ex(*cit))));
+ cit++;
+ }
+
+ return thisexpairseq(v, f(overall_coeff));
+}
+
ex expairseq::eval(int level) const
{
if ((level==1) && (flags &status_flags::evaluated))
return n.bp->basic::normal(sym_lst,repl_lst,level);
}
-ex expairseq::subs(const lst &ls, const lst &lr) const
+bool expairseq::match(const ex & pattern, lst & repl_lst) const
{
- epvector *vp = subschildren(ls,lr);
- if (vp==0)
- return inherited::subs(ls, lr);
-
- return thisexpairseq(vp,overall_coeff);
+ // This differs from basic::match() because we want "a+b+c+d" to
+ // match "d+*+b" with "*" being "a+c", and we want to honor commutativity
+
+ if (tinfo() == pattern.bp->tinfo()) {
+
+ // Check whether global wildcard (one that matches the "rest of the
+ // expression", like "*" above) is present
+ bool has_global_wildcard = false;
+ ex global_wildcard;
+ for (unsigned int i=0; i<pattern.nops(); i++) {
+ if (is_ex_exactly_of_type(pattern.op(i), wildcard)) {
+ has_global_wildcard = true;
+ global_wildcard = pattern.op(i);
+ break;
+ }
+ }
+
+ // Unfortunately, this is an O(N^2) operation because we can't
+ // sort the pattern in a useful way...
+
+ // Chop into terms
+ exvector ops;
+ ops.reserve(nops());
+ for (unsigned i=0; i<nops(); i++)
+ ops.push_back(op(i));
+
+ // Now, for every term of the pattern, look for a matching term in
+ // the expression and remove the match
+ for (unsigned i=0; i<pattern.nops(); i++) {
+ ex p = pattern.op(i);
+ if (has_global_wildcard && p.is_equal(global_wildcard))
+ continue;
+ exvector::iterator it = ops.begin(), itend = ops.end();
+ while (it != itend) {
+ if (it->match(p, repl_lst)) {
+ ops.erase(it);
+ goto found;
+ }
+ it++;
+ }
+ return false; // no match found
+found: ;
+ }
+
+ if (has_global_wildcard) {
+
+ // Assign all the remaining terms to the global wildcard (unless
+ // it has already been matched before, in which case the matches
+ // must be equal)
+ epvector *vp = new epvector();
+ vp->reserve(ops.size());
+ for (unsigned i=0; i<ops.size(); i++)
+ vp->push_back(split_ex_to_pair(ops[i]));
+ ex rest = thisexpairseq(vp, default_overall_coeff());
+ for (unsigned i=0; i<repl_lst.nops(); i++) {
+ if (repl_lst.op(i).op(0).is_equal(global_wildcard))
+ return rest.is_equal(*repl_lst.op(i).op(1).bp);
+ }
+ repl_lst.append(global_wildcard == rest);
+ return true;
+
+ } else {
+
+ // No global wildcard, then the match fails if there are any
+ // unmatched terms left
+ return ops.empty();
+ }
+ }
+ return inherited::match(pattern, repl_lst);
+}
+
+ex expairseq::subs(const lst &ls, const lst &lr, bool no_pattern) const
+{
+ epvector *vp = subschildren(ls, lr, no_pattern);
+ if (vp)
+ return thisexpairseq(vp, overall_coeff).bp->basic::subs(ls, lr, no_pattern);
+ else
+ return basic::subs(ls, lr, no_pattern);
}
// protected
int expairseq::compare_same_type(const basic &other) const
{
GINAC_ASSERT(is_of_type(other, expairseq));
- const expairseq &o = static_cast<const expairseq &>(const_cast<basic &>(other));
+ const expairseq &o = static_cast<const expairseq &>(other);
int cmpval;
bool expairseq::is_equal_same_type(const basic &other) const
{
- const expairseq &o = dynamic_cast<const expairseq &>(const_cast<basic &>(other));
+ const expairseq &o = static_cast<const expairseq &>(other);
// compare number of elements
if (seq.size()!=o.seq.size())
GINAC_ASSERT(is_ex_exactly_of_type(p.coeff,numeric));
GINAC_ASSERT(is_ex_exactly_of_type(c,numeric));
- return expair(p.rest,ex_to_numeric(p.coeff).mul_dyn(ex_to_numeric(c)));
+ return expair(p.rest,ex_to<numeric>(p.coeff).mul_dyn(ex_to<numeric>(c)));
}
{
GINAC_ASSERT(is_ex_exactly_of_type(overall_coeff,numeric));
GINAC_ASSERT(is_ex_exactly_of_type(c,numeric));
- overall_coeff = ex_to_numeric(overall_coeff).add_dyn(ex_to_numeric(c));
+ overall_coeff = ex_to<numeric>(overall_coeff).add_dyn(ex_to<numeric>(c));
}
void expairseq::combine_overall_coeff(const ex &c1, const ex &c2)
GINAC_ASSERT(is_ex_exactly_of_type(overall_coeff,numeric));
GINAC_ASSERT(is_ex_exactly_of_type(c1,numeric));
GINAC_ASSERT(is_ex_exactly_of_type(c2,numeric));
- overall_coeff = ex_to_numeric(overall_coeff).
- add_dyn(ex_to_numeric(c1).mul(ex_to_numeric(c2)));
+ overall_coeff = ex_to<numeric>(overall_coeff).
+ add_dyn(ex_to<numeric>(c1).mul(ex_to<numeric>(c2)));
}
bool expairseq::can_make_flat(const expair &p) const
if (lh.bp->tinfo()==tinfo()) {
if (rh.bp->tinfo()==tinfo()) {
#if EXPAIRSEQ_USE_HASHTAB
- unsigned totalsize = ex_to_expairseq(lh).seq.size() +
- ex_to_expairseq(rh).seq.size();
+ unsigned totalsize = ex_to<expairseq>(lh).seq.size() +
+ ex_to<expairseq>(rh).seq.size();
if (calc_hashtabsize(totalsize)!=0) {
construct_from_2_ex_via_exvector(lh,rh);
} else {
#endif // EXPAIRSEQ_USE_HASHTAB
- construct_from_2_expairseq(ex_to_expairseq(lh),
- ex_to_expairseq(rh));
+ construct_from_2_expairseq(ex_to<expairseq>(lh),
+ ex_to<expairseq>(rh));
#if EXPAIRSEQ_USE_HASHTAB
}
#endif // EXPAIRSEQ_USE_HASHTAB
return;
} else {
#if EXPAIRSEQ_USE_HASHTAB
- unsigned totalsize = ex_to_expairseq(lh).seq.size()+1;
+ unsigned totalsize = ex_to<expairseq>(lh).seq.size()+1;
if (calc_hashtabsize(totalsize)!=0) {
construct_from_2_ex_via_exvector(lh, rh);
} else {
#endif // EXPAIRSEQ_USE_HASHTAB
- construct_from_expairseq_ex(ex_to_expairseq(lh), rh);
+ construct_from_expairseq_ex(ex_to<expairseq>(lh), rh);
#if EXPAIRSEQ_USE_HASHTAB
}
#endif // EXPAIRSEQ_USE_HASHTAB
}
} else if (rh.bp->tinfo()==tinfo()) {
#if EXPAIRSEQ_USE_HASHTAB
- unsigned totalsize=ex_to_expairseq(rh).seq.size()+1;
+ unsigned totalsize=ex_to<expairseq>(rh).seq.size()+1;
if (calc_hashtabsize(totalsize)!=0) {
construct_from_2_ex_via_exvector(lh,rh);
} else {
#endif // EXPAIRSEQ_USE_HASHTAB
- construct_from_expairseq_ex(ex_to_expairseq(rh),lh);
+ construct_from_expairseq_ex(ex_to<expairseq>(rh),lh);
#if EXPAIRSEQ_USE_HASHTAB
}
#endif // EXPAIRSEQ_USE_HASHTAB
int cmpval = p1.rest.compare(p2.rest);
if (cmpval==0) {
- p1.coeff=ex_to_numeric(p1.coeff).add_dyn(ex_to_numeric(p2.coeff));
- if (!ex_to_numeric(p1.coeff).is_zero()) {
+ p1.coeff=ex_to<numeric>(p1.coeff).add_dyn(ex_to<numeric>(p2.coeff));
+ if (!ex_to<numeric>(p1.coeff).is_zero()) {
// no further processing is necessary, since this
// one element will usually be recombined in eval()
seq.push_back(p1);
int cmpval = (*first1).rest.compare((*first2).rest);
if (cmpval==0) {
// combine terms
- const numeric &newcoeff = ex_to_numeric((*first1).coeff).
- add(ex_to_numeric((*first2).coeff));
+ const numeric &newcoeff = ex_to<numeric>((*first1).coeff).
+ add(ex_to<numeric>((*first2).coeff));
if (!newcoeff.is_zero()) {
seq.push_back(expair((*first1).rest,newcoeff));
if (expair_needs_further_processing(seq.end()-1)) {
int cmpval=(*first).rest.compare(p.rest);
if (cmpval==0) {
// combine terms
- const numeric &newcoeff = ex_to_numeric((*first).coeff).
- add(ex_to_numeric(p.coeff));
+ const numeric &newcoeff = ex_to<numeric>((*first).coeff).
+ add(ex_to<numeric>(p.coeff));
if (!newcoeff.is_zero()) {
seq.push_back(expair((*first).rest,newcoeff));
if (expair_needs_further_processing(seq.end()-1)) {
while (cit!=v.end()) {
if (cit->bp->tinfo()==this->tinfo()) {
++nexpairseqs;
- noperands += ex_to_expairseq(*cit).seq.size();
+ noperands += ex_to<expairseq>(*cit).seq.size();
}
++cit;
}
cit = v.begin();
while (cit!=v.end()) {
if (cit->bp->tinfo()==this->tinfo()) {
- const expairseq &subseqref = ex_to_expairseq(*cit);
+ const expairseq &subseqref = ex_to<expairseq>(*cit);
combine_overall_coeff(subseqref.overall_coeff);
epvector::const_iterator cit_s = subseqref.seq.begin();
while (cit_s!=subseqref.seq.end()) {
while (cit!=v.end()) {
if (cit->rest.bp->tinfo()==this->tinfo()) {
++nexpairseqs;
- noperands += ex_to_expairseq((*cit).rest).seq.size();
+ noperands += ex_to<expairseq>((*cit).rest).seq.size();
}
++cit;
}
while (cit!=v.end()) {
if (cit->rest.bp->tinfo()==this->tinfo() &&
this->can_make_flat(*cit)) {
- const expairseq &subseqref = ex_to_expairseq((*cit).rest);
- combine_overall_coeff(ex_to_numeric(subseqref.overall_coeff),
- ex_to_numeric((*cit).coeff));
+ const expairseq &subseqref = ex_to<expairseq>((*cit).rest);
+ combine_overall_coeff(ex_to<numeric>(subseqref.overall_coeff),
+ ex_to<numeric>((*cit).coeff));
epvector::const_iterator cit_s = subseqref.seq.begin();
while (cit_s!=subseqref.seq.end()) {
seq.push_back(expair((*cit_s).rest,
- ex_to_numeric((*cit_s).coeff).mul_dyn(ex_to_numeric((*cit).coeff))));
+ ex_to<numeric>((*cit_s).coeff).mul_dyn(ex_to<numeric>((*cit).coeff))));
//seq.push_back(combine_pair_with_coeff_to_pair(*cit_s,
// (*cit).coeff));
++cit_s;
bool must_copy = false;
while (itin2!=last) {
if ((*itin1).rest.compare((*itin2).rest)==0) {
- (*itin1).coeff = ex_to_numeric((*itin1).coeff).
- add_dyn(ex_to_numeric((*itin2).coeff));
+ (*itin1).coeff = ex_to<numeric>((*itin1).coeff).
+ add_dyn(ex_to<numeric>((*itin2).coeff));
if (expair_needs_further_processing(itin1))
needs_further_processing = true;
must_copy = true;
} else {
- if (!ex_to_numeric((*itin1).coeff).is_zero()) {
+ if (!ex_to<numeric>((*itin1).coeff).is_zero()) {
if (must_copy)
*itout = *itin1;
++itout;
}
++itin2;
}
- if (!ex_to_numeric((*itin1).coeff).is_zero()) {
+ if (!ex_to<numeric>((*itin1).coeff).is_zero()) {
if (must_copy)
*itout = *itin1;
++itout;
++current;
} else {
// epplit points to a matching expair, combine it with current
- (*(*epplit)).coeff = ex_to_numeric((*(*epplit)).coeff).
- add_dyn(ex_to_numeric((*current).coeff));
+ (*(*epplit)).coeff = ex_to<numeric>((*(*epplit)).coeff).
+ add_dyn(ex_to<numeric>((*current).coeff));
// move obsolete current expair to end by swapping with last_non_zero element
// if this was a numeric, it is swapped with the expair before first_numeric
if (!touched[i]) {
++current;
++i;
- } else if (!ex_to_numeric((*current).coeff).is_zero()) {
+ } else if (!ex_to<numeric>((*current).coeff).is_zero()) {
++current;
++i;
} else {
/** Member-wise substitute in this sequence.
*
* @see expairseq::subs()
- * @return pointer to epvector containing pairs after application of subs or zero
- * pointer, if no members were changed. */
-epvector * expairseq::subschildren(const lst &ls, const lst &lr) const
+ * @return pointer to epvector containing pairs after application of subs,
+ * or NULL pointer if no members were changed. */
+epvector * expairseq::subschildren(const lst &ls, const lst &lr, bool no_pattern) const
{
- // returns a NULL pointer if nothing had to be substituted
- // returns a pointer to a newly created epvector otherwise
- // (which has to be deleted somewhere else)
GINAC_ASSERT(ls.nops()==lr.nops());
-
- epvector::const_iterator last = seq.end();
- epvector::const_iterator cit = seq.begin();
- while (cit!=last) {
- const ex &subsed_ex=(*cit).rest.subs(ls,lr);
- if (!are_ex_trivially_equal((*cit).rest,subsed_ex)) {
+
+ // The substitution is "complex" when any of the objects to be substituted
+ // is a product or power. In this case we have to recombine the pairs
+ // because the numeric coefficients may be part of the search pattern.
+ bool complex_subs = false;
+ for (unsigned i=0; i<ls.nops(); i++)
+ if (is_ex_exactly_of_type(ls.op(i), mul) || is_ex_exactly_of_type(ls.op(i), power)) {
+ complex_subs = true;
+ break;
+ }
+
+ if (complex_subs) {
+
+ // Substitute in the recombined pairs
+ epvector::const_iterator cit = seq.begin(), last = seq.end();
+ while (cit != last) {
+
+ const ex &orig_ex = recombine_pair_to_ex(*cit);
+ const ex &subsed_ex = orig_ex.subs(ls, lr, no_pattern);
+ if (!are_ex_trivially_equal(orig_ex, subsed_ex)) {
+
+ // Something changed, copy seq, subs and return it
+ epvector *s = new epvector;
+ s->reserve(seq.size());
+
+ // Copy parts of seq which are known not to have changed
+ s->insert(s->begin(), seq.begin(), cit);
+
+ // Copy first changed element
+ s->push_back(split_ex_to_pair(subsed_ex));
+ ++cit;
+
+ // Copy rest
+ while (cit != last) {
+ s->push_back(split_ex_to_pair(recombine_pair_to_ex(*cit).subs(ls, lr, no_pattern)));
+ ++cit;
+ }
+ return s;
+ }
+
+ ++cit;
+ }
+
+ } else {
+
+ // Substitute only in the "rest" part of the pairs
+ epvector::const_iterator cit = seq.begin(), last = seq.end();
+ while (cit != last) {
+
+ const ex &subsed_ex = cit->rest.subs(ls, lr, no_pattern);
+ if (!are_ex_trivially_equal(cit->rest, subsed_ex)) {
- // something changed, copy seq, subs and return it
- epvector *s = new epvector;
- s->reserve(seq.size());
+ // Something changed, copy seq, subs and return it
+ epvector *s = new epvector;
+ s->reserve(seq.size());
+
+ // Copy parts of seq which are known not to have changed
+ s->insert(s->begin(), seq.begin(), cit);
- // copy parts of seq which are known not to have changed
- epvector::const_iterator cit2 = seq.begin();
- while (cit2!=cit) {
- s->push_back(*cit2);
- ++cit2;
- }
- // copy first changed element
- s->push_back(combine_ex_with_coeff_to_pair(subsed_ex,
- (*cit2).coeff));
- ++cit2;
- // copy rest
- while (cit2!=last) {
- s->push_back(combine_ex_with_coeff_to_pair((*cit2).rest.subs(ls,lr),
- (*cit2).coeff));
- ++cit2;
+ // Copy first changed element
+ s->push_back(combine_ex_with_coeff_to_pair(subsed_ex, cit->coeff));
+ ++cit;
+
+ // Copy rest
+ while (cit != last) {
+ s->push_back(combine_ex_with_coeff_to_pair(cit->rest.subs(ls, lr, no_pattern),
+ cit->coeff));
+ ++cit;
+ }
+ return s;
}
- return s;
+
+ ++cit;
}
- ++cit;
}
- return 0; // signalling nothing has changed
+ // Nothing has changed
+ return NULL;
}
//////////
git://www.ginac.de / ginac.git / blobdiff