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; }