* Implementation of sequences of expression pairs. */
/*
- * GiNaC Copyright (C) 1999-2007 Johannes Gutenberg University Mainz, Germany
+ * GiNaC Copyright (C) 1999-2008 Johannes Gutenberg University Mainz, Germany
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
#include <algorithm>
#include <string>
#include <stdexcept>
+#include <iterator>
#include "expairseq.h"
#include "lst.h"
bool expairseq::info(unsigned inf) const
{
- if (inf == info_flags::expanded)
- return (flags & status_flags::expanded);
+ switch(inf) {
+ case info_flags::expanded:
+ return (flags & status_flags::expanded);
+ case info_flags::has_indices: {
+ if (flags & status_flags::has_indices)
+ return true;
+ else if (flags & status_flags::has_no_indices)
+ return false;
+ for (epvector::const_iterator i = seq.begin(); i != seq.end(); ++i) {
+ if (i->rest.info(info_flags::has_indices)) {
+ this->setflag(status_flags::has_indices);
+ this->clearflag(status_flags::has_no_indices);
+ return true;
+ }
+ }
+ this->clearflag(status_flags::has_indices);
+ this->setflag(status_flags::has_no_indices);
+ return false;
+ }
+ }
return inherited::info(inf);
}
return true;
}
-bool expairseq::match(const ex & pattern, lst & repl_lst) const
+bool expairseq::match(const ex & pattern, exmap & repl_lst) const
{
// 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 (this->tinfo() == ex_to<basic>(pattern).tinfo()) {
+ if (typeid(*this) == typeid(ex_to<basic>(pattern))) {
// Check whether global wildcard (one that matches the "rest of the
// expression", like "*" above) is present
continue;
exvector::iterator it = ops.begin(), itend = ops.end();
while (it != itend) {
- lst::const_iterator last_el = repl_lst.end();
- --last_el;
if (it->match(p, repl_lst)) {
ops.erase(it);
goto found;
}
- while(true) {
- lst::const_iterator next_el = last_el;
- ++next_el;
- if(next_el == repl_lst.end())
- break;
- else
- repl_lst.remove_last();
- }
++it;
}
return false; // no match found
for (size_t i=0; i<num; i++)
vp->push_back(split_ex_to_pair(ops[i]));
ex rest = thisexpairseq(vp, default_overall_coeff());
- for (lst::const_iterator it = repl_lst.begin(); it != repl_lst.end(); ++it) {
- if (it->op(0).is_equal(global_wildcard))
- return rest.is_equal(it->op(1));
+ for (exmap::const_iterator it = repl_lst.begin(); it != repl_lst.end(); ++it) {
+ if (it->first.is_equal(global_wildcard))
+ return rest.is_equal(it->second);
}
- repl_lst.append(global_wildcard == rest);
+ repl_lst[global_wildcard] = rest;
return true;
} else {
void expairseq::construct_from_2_ex(const ex &lh, const ex &rh)
{
- if (ex_to<basic>(lh).tinfo()==this->tinfo()) {
- if (ex_to<basic>(rh).tinfo()==this->tinfo()) {
+ if (typeid(ex_to<basic>(lh)) == typeid(*this)) {
+ if (typeid(ex_to<basic>(rh)) == typeid(*this)) {
#if EXPAIRSEQ_USE_HASHTAB
unsigned totalsize = ex_to<expairseq>(lh).seq.size() +
ex_to<expairseq>(rh).seq.size();
construct_from_2_ex_via_exvector(lh,rh);
} else {
#endif // EXPAIRSEQ_USE_HASHTAB
- if(is_a<mul>(lh))
- {
+ if (is_a<mul>(lh) && lh.info(info_flags::has_indices) &&
+ rh.info(info_flags::has_indices)) {
ex newrh=rename_dummy_indices_uniquely(lh, rh);
construct_from_2_expairseq(ex_to<expairseq>(lh),
ex_to<expairseq>(newrh));
#endif // EXPAIRSEQ_USE_HASHTAB
return;
}
- } else if (ex_to<basic>(rh).tinfo()==this->tinfo()) {
+ } else if (typeid(ex_to<basic>(rh)) == typeid(*this)) {
#if EXPAIRSEQ_USE_HASHTAB
unsigned totalsize=ex_to<expairseq>(rh).seq.size()+1;
if (calc_hashtabsize(totalsize)!=0) {
// and their cumulative number of operands
int nexpairseqs = 0;
int noperands = 0;
+ bool do_idx_rename = false;
cit = v.begin();
while (cit!=v.end()) {
- if (ex_to<basic>(*cit).tinfo()==this->tinfo()) {
+ if (typeid(ex_to<basic>(*cit)) == typeid(*this)) {
++nexpairseqs;
noperands += ex_to<expairseq>(*cit).seq.size();
}
+ if (is_a<mul>(*this) && (!do_idx_rename) &&
+ cit->info(info_flags::has_indices))
+ do_idx_rename = true;
++cit;
}
seq.reserve(v.size()+noperands-nexpairseqs);
// copy elements and split off numerical part
- make_flat_inserter mf(v, this->tinfo() == &mul::tinfo_static);
+ make_flat_inserter mf(v, do_idx_rename);
cit = v.begin();
while (cit!=v.end()) {
- if (ex_to<basic>(*cit).tinfo()==this->tinfo()) {
+ if (typeid(ex_to<basic>(*cit)) == typeid(*this)) {
ex newfactor = mf.handle_factor(*cit, _ex1);
const expairseq &subseqref = ex_to<expairseq>(newfactor);
combine_overall_coeff(subseqref.overall_coeff);
// and their cumulative number of operands
int nexpairseqs = 0;
int noperands = 0;
+ bool really_need_rename_inds = false;
cit = v.begin();
while (cit!=v.end()) {
- if (ex_to<basic>(cit->rest).tinfo()==this->tinfo()) {
+ if (typeid(ex_to<basic>(cit->rest)) == typeid(*this)) {
++nexpairseqs;
noperands += ex_to<expairseq>(cit->rest).seq.size();
}
+ if ((!really_need_rename_inds) && is_a<mul>(*this) &&
+ cit->rest.info(info_flags::has_indices))
+ really_need_rename_inds = true;
++cit;
}
+ do_index_renaming = do_index_renaming && really_need_rename_inds;
// reserve seq and coeffseq which will hold all operands
seq.reserve(v.size()+noperands-nexpairseqs);
// copy elements and split off numerical part
cit = v.begin();
while (cit!=v.end()) {
- if (ex_to<basic>(cit->rest).tinfo()==this->tinfo() &&
+ if ((typeid(ex_to<basic>(cit->rest)) == typeid(*this)) &&
this->can_make_flat(*cit)) {
ex newrest = mf.handle_factor(cit->rest, cit->coeff);
const expairseq &subseqref = ex_to<expairseq>(newrest);
git://www.ginac.de / ginac.git / blobdiff