Set<Deriv> FunctionalPolynomial
::findFuncsForSummation(const Set<MultipleDeriv>& prevSet,
const MultipleDeriv& currentDeriv) const
{
Set<Deriv> rtn;
for (Set<MultipleDeriv>::const_iterator
i = prevSet.begin(); i != prevSet.end(); i++)
{
const MultipleDeriv& mdPrev = *i;
TEUCHOS_TEST_FOR_EXCEPTION(currentDeriv.size()+1 != mdPrev.size(),
std::logic_error,
"deriv orders must differ by 1. Found "
"currentDeriv.size()=" << currentDeriv.size()
<< " while mdPrev.size()=" << mdPrev.size());
/* We are looking for cases where the previous multiple derivative
* is equal to the current plus one *greater* element. In such cases, the
* set difference will contain exactly one element, and that element
* will be greater than or equal to the the upper bound of the current
* set */
Set<Deriv> tmp;
set_difference(mdPrev.begin(), mdPrev.end(),
currentDeriv.begin(), currentDeriv.end(),
inserter(tmp, tmp.begin()));
if (tmp.size()==1)
{
const Deriv& d = *(tmp.begin());
if (currentDeriv.upper_bound(d) == currentDeriv.end()) rtn.put(d);
}
}
return rtn;
}
void DiffOp::requestMultiIndexAtEvalPoint(const MultiIndex& mi,
const MultipleDeriv& u,
const EvalContext& context) const
{
int verb = context.setupVerbosity();
Tabs tab0(0);
SUNDANCE_MSG3(verb, tab0 << "DiffOp::requestMultiIndexAtEvalPoint() for=" << toString());
TEUCHOS_TEST_FOR_EXCEPT(u.size() != 1);
const Deriv& d = *(u.begin());
if (d.isFunctionalDeriv())
{
const SpatialDerivSpecifier& sds = d.opOnFunc();
TEUCHOS_TEST_FOR_EXCEPTION(sds.isDivergence(), std::logic_error,
"divergence operators not possible within DiffOp");
TEUCHOS_TEST_FOR_EXCEPTION(sds.isNormal(), std::logic_error,
"normal deriv operators not possible within DiffOp");
const MultiIndex& newMi = sds.mi();
const SymbolicFuncElement* sfe = d.symbFuncElem();
TEUCHOS_TEST_FOR_EXCEPT(sfe == 0);
const EvaluatableExpr* evalPt = sfe->evalPt();
const ZeroExpr* z = dynamic_cast<const ZeroExpr*>(evalPt);
if (z != 0) return;
const DiscreteFuncElement* df
= dynamic_cast<const DiscreteFuncElement*>(evalPt);
df->addMultiIndex(newMi);
df->findW(1, context);
df->findV(1, context);
df->findC(1, context);
}
}
bool hasParameter(const MultipleDeriv& d)
{
for (MultipleDeriv::const_iterator i=d.begin(); i!=d.end(); i++)
{
if (i->isParameter()) return true;
}
return false;
}
bool MultipleDeriv::containsDeriv(const MultipleDeriv& x) const
{
for (MultipleDeriv::const_iterator i=x.begin(); i!=x.end(); i++)
{
if ( count(*i) <= x.count(*i) ) return false;
}
return true;
}
MultipleDeriv FunctionalPolynomial::successorTerm(const MultipleDeriv& md) const
{
MultipleDeriv rtn;
unsigned int k = 0;
for (MultipleDeriv::const_iterator i=md.begin(); i!=md.end(); i++, k++)
{
if (k < md.size()-1) rtn.put(*i);
}
return rtn;
}
MultipleDeriv MultipleDeriv::product(const MultipleDeriv& other) const
{
MultipleDeriv rtn;
for (MultipleDeriv::const_iterator i=this->begin(); i!=this->end(); i++)
{
rtn.put(*i);
}
for (MultipleDeriv::const_iterator i=other.begin(); i!=other.end(); i++)
{
rtn.put(*i);
}
return rtn;
}
MultipleDeriv MultipleDeriv::factorOutDeriv(const MultipleDeriv& x) const
{
MultipleDeriv rtn = *this;
for (MultipleDeriv::const_iterator i=x.begin(); i!=x.end(); i++)
{
MultipleDeriv::iterator j = rtn.find(*i);
/* remove a single copy of the given derivative */
if (j != rtn.end()) rtn.erase(j);
}
if (rtn.size() == this->size()) return MultipleDeriv();
return rtn;
}
Deriv DiffOpEvaluator::remainder(const MultipleDeriv& big,
const MultipleDeriv& little, int verb) const
{
Tabs tab;
SUNDANCE_MSG5(verb, tab << "computing remainder: big=" << big << ", little="
<< little);
TEUCHOS_TEST_FOR_EXCEPT(big.order()-little.order() != 1);
MultipleDeriv r;
if (little.order()==0) r = big;
else r = big.factorOutDeriv(little);
SUNDANCE_MSG5(verb, tab << "remainder = " << r);
TEUCHOS_TEST_FOR_EXCEPT(r.order() != 1);
return *(r.begin());
}
Set<MultipleDeriv> DiffOpEvaluator
::increasedDerivs(const MultipleDeriv& mu,
const Set<MultipleDeriv>& W1, int verb) const
{
Tabs tabs;
SUNDANCE_MSG3(verb, tabs << "computing increased derivs");
Set<MultipleDeriv> rtn;
for (Set<MultipleDeriv>::const_iterator i=W1.begin(); i!=W1.end(); i++)
{
MultipleDeriv md = *i;
TEUCHOS_TEST_FOR_EXCEPT(md.order() != 1);
Deriv lambda = *(md.begin());
MultipleDeriv lambdaMu = mu;
lambdaMu.put(lambda);
rtn.put(lambdaMu);
}
SUNDANCE_MSG3(verb, tabs << "increased derivs = " << rtn);
return rtn;
}
int factorial(const MultipleDeriv& ms)
{
Sundance::Map<Deriv, int> counts;
for (MultipleDeriv::const_iterator i=ms.begin(); i!=ms.end(); i++)
{
if (counts.containsKey(*i)) counts[*i]++;
else counts.put(*i, 1);
}
int rtn = 1;
for (Sundance::Map<Deriv, int>::const_iterator
i=counts.begin(); i!=counts.end(); i++)
{
int f = 1;
for (int j=1; j<=i->second; j++) f *= j;
rtn *= f;
}
return rtn;
}
void SparsitySuperset::addDeriv(const MultipleDeriv& d,
const DerivState& state)
{
maxOrder_ = std::max(d.order(), maxOrder_);
if (containsDeriv(d))
{
const DerivState& oldState = states_[getIndex(d)];
if (state > oldState)
{
states_[getIndex(d)] = state;
numConstantDerivs_--;
numVectorDerivs_++;
}
}
else
{
int index = derivs_.size();
derivs_.append(d);
states_.append(state);
derivToIndexMap_.put(d, index);
MultiIndex mi;
for (MultipleDeriv::const_iterator i=d.begin();
i != d.end(); i++)
{
if (i->isCoordDeriv())
{
MultiIndex m;
int dir = i->coordDerivDir();
m[dir] = 1;
mi = mi + m;
}
}
multiIndex_.append(mi);
if (state==ConstantDeriv) numConstantDerivs_++;
else numVectorDerivs_++;
}
}
Set<MultipleDeriv> DiffOpEvaluator
::backedDerivs(const MultipleDeriv& mu,
const Set<MultipleDeriv>& W1, int verb) const
{
Tabs tabs;
SUNDANCE_MSG3(verb, tabs << "computing backed-out derivs for mu= " << mu
<< ", W1=" << W1);
Set<MultipleDeriv> rtn;
if (mu.order() != 0)
{
const MultiIndex& alpha = expr()->mi();
for (Set<MultipleDeriv>::const_iterator i=W1.begin(); i!=W1.end(); i++)
{
const MultipleDeriv& md = *i;
TEUCHOS_TEST_FOR_EXCEPT(md.order() != 1);
Deriv lambda = *(md.begin());
if (lambda.isCoordDeriv()) continue;
TEUCHOS_TEST_FOR_EXCEPT(!lambda.isFunctionalDeriv());
FunctionIdentifier lambda_fid = lambda.fid();
const MultiIndex& lambda_mi = lambda.opOnFunc().mi();
for (MultipleDeriv::const_iterator j=mu.begin(); j!=mu.end(); j++)
{
const Deriv& d = *j;
if (d.isCoordDeriv()) continue;
FunctionIdentifier d_fid = d.fid();
const MultiIndex& d_mi = d.opOnFunc().mi();
if (d_fid != lambda_fid) continue;
if (!(alpha + lambda_mi == d_mi)) continue;
MultipleDeriv z = mu.factorOutDeriv(d);
z.put(lambda);
rtn.put(z);
}
}
}
SUNDANCE_MSG3(verb, tabs << "backed-out derivs = " << rtn);
return rtn;
}
