/**
* Split this function into independent functions. The number of functions in
* the
* returned vector must be equal to the number
* of domains. The result of evaluation of the i-th function on the i-th domain
* must be
* the same as if this MultiDomainFunction was evaluated.
*/
std::vector<IFunction_sptr>
MultiDomainFunction::createEquivalentFunctions() const {
size_t nDomains = m_maxIndex + 1;
std::vector<CompositeFunction_sptr> compositeFunctions(nDomains);
for (size_t iFun = 0; iFun < nFunctions(); ++iFun) {
// find the domains member function must be applied to
std::vector<size_t> domains;
getDomainIndices(iFun, nDomains, domains);
for (auto i = domains.begin(); i != domains.end(); ++i) {
size_t j = *i;
CompositeFunction_sptr cf = compositeFunctions[j];
if (!cf) {
// create a composite function for each domain
cf = CompositeFunction_sptr(new CompositeFunction());
compositeFunctions[j] = cf;
}
// add copies of all functions applied to j-th domain to a single
// compositefunction
cf->addFunction(FunctionFactory::Instance().createInitialized(
getFunction(iFun)->asString()));
}
}
std::vector<IFunction_sptr> outFunctions(nDomains);
// fill in the output vector
// check functions containing a single member and take it out of the composite
for (size_t i = 0; i < compositeFunctions.size(); ++i) {
auto fun = compositeFunctions[i];
if (!fun || fun->nFunctions() == 0) {
throw std::runtime_error("There is no function for domain " +
boost::lexical_cast<std::string>(i));
}
if (fun->nFunctions() > 1) {
outFunctions[i] = fun;
} else {
outFunctions[i] = fun->getFunction(0);
}
}
return outFunctions;
}
/**
* Create a composite function from an expression.
* @param expr :: The input expression
* @param parentAttributes :: An output map filled with the attribute name &
* values of the parent function
* @return A pointer to the created function
*/
CompositeFunction_sptr FunctionFactoryImpl::createComposite(
const Expression &expr,
std::map<std::string, std::string> &parentAttributes) const {
if (expr.name() != ";")
inputError(expr.str());
if (expr.size() == 0) {
return CompositeFunction_sptr();
}
const std::vector<Expression> &terms = expr.terms();
auto it = terms.cbegin();
const Expression &term = it->bracketsRemoved();
CompositeFunction_sptr cfun;
if (term.name() == "=") {
if (term.terms()[0].name() == "composite") {
cfun = boost::dynamic_pointer_cast<CompositeFunction>(
createFunction(term.terms()[1].name()));
if (!cfun)
inputError(expr.str());
++it;
} else if (term.terms()[0].name() == "name") {
cfun = boost::dynamic_pointer_cast<CompositeFunction>(
createFunction("CompositeFunction"));
if (!cfun)
inputError(expr.str());
} else {
inputError(expr.str());
}
} else if (term.name() == ",") {
auto firstTerm = term.terms().cbegin();
if (firstTerm->name() == "=") {
if (firstTerm->terms()[0].name() == "composite") {
cfun = boost::dynamic_pointer_cast<CompositeFunction>(
createSimple(term, parentAttributes));
if (!cfun)
inputError(expr.str());
++it;
} else if (firstTerm->terms()[0].name() == "name") {
cfun = boost::dynamic_pointer_cast<CompositeFunction>(
createFunction("CompositeFunction"));
if (!cfun)
inputError(expr.str());
} else {
inputError(expr.str());
}
}
} else if (term.name() == ";") {
cfun = boost::dynamic_pointer_cast<CompositeFunction>(
createFunction("CompositeFunction"));
if (!cfun)
inputError(expr.str());
} else {
inputError(expr.str());
}
if (!cfun)
inputError(expr.str());
for (; it != terms.end(); ++it) {
const Expression &term = it->bracketsRemoved();
IFunction_sptr fun;
std::map<std::string, std::string> pAttributes;
if (term.name() == ";") {
fun = createComposite(term, pAttributes);
if (!fun)
continue;
} else {
std::string parName = term[0].name();
if (parName.size() >= 10 && parName.substr(0, 10) == "constraint") {
addConstraints(cfun, term[1]);
continue;
} else if (parName == "ties") {
addTies(cfun, term[1]);
continue;
} else {
fun = createSimple(term, pAttributes);
}
}
cfun->addFunction(fun);
size_t i = cfun->nFunctions() - 1;
for (auto &pAttribute : pAttributes) {
// Apply parent attributes of the child function to this function. If this
// function doesn't have those attributes, they get passed up the chain to
// this function's parent.
if (cfun->hasLocalAttribute(pAttribute.first)) {
cfun->setLocalAttributeValue(i, pAttribute.first, pAttribute.second);
} else {
parentAttributes[pAttribute.first] = pAttribute.second;
}
}
}
if (cfun) {
cfun->applyTies();
}
return cfun;
}
/**
* Create a composite function from an expression.
* @param expr :: The input expression
* @param parentAttributes :: An output map filled with the attribute name & values of the parent function
* @return A pointer to the created function
*/
CompositeFunction_sptr FunctionFactoryImpl::createComposite(const Expression& expr, std::map<std::string,std::string>& parentAttributes)const
{
if (expr.name() != ";") inputError(expr.str());
if (expr.size() == 0)
{
return CompositeFunction_sptr();
}
const std::vector<Expression>& terms = expr.terms();
std::vector<Expression>::const_iterator it = terms.begin();
const Expression& term = it->bracketsRemoved();
CompositeFunction_sptr cfun;
if (term.name() == "=")
{
if (term.terms()[0].name() == "composite")
{
cfun = boost::dynamic_pointer_cast<CompositeFunction>(createFunction(term.terms()[1].name()));
if (!cfun) inputError(expr.str());
++it;
}
else if (term.terms()[0].name() == "name")
{
cfun = boost::dynamic_pointer_cast<CompositeFunction>(createFunction("CompositeFunction"));
if (!cfun) inputError(expr.str());
}
else
{
inputError(expr.str());
}
}
else if (term.name() == ",")
{
std::vector<Expression>::const_iterator firstTerm = term.terms().begin();
if (firstTerm->name() == "=")
{
if (firstTerm->terms()[0].name() == "composite")
{
cfun = boost::dynamic_pointer_cast<CompositeFunction>(createSimple(term,parentAttributes));
if (!cfun) inputError(expr.str());
++it;
}
else if (firstTerm->terms()[0].name() == "name")
{
cfun = boost::dynamic_pointer_cast<CompositeFunction>(createFunction("CompositeFunction"));
if (!cfun) inputError(expr.str());
}
else
{
inputError(expr.str());
}
}
}
else if (term.name() == ";")
{
cfun = boost::dynamic_pointer_cast<CompositeFunction>(createFunction("CompositeFunction"));
if (!cfun) inputError(expr.str());
}
else
{
inputError(expr.str());
}
for(;it!=terms.end();++it)
{
const Expression& term = it->bracketsRemoved();
IFunction_sptr fun;
std::map<std::string,std::string> pAttributes;
if (term.name() == ";")
{
fun = createComposite(term,pAttributes);
if (!fun) continue;
}
else
{
std::string parName = term[0].name();
if (parName.size() >= 10 && parName.substr(0,10) == "constraint")
{
addConstraints(cfun,term[1]);
continue;
}
else if (parName == "ties")
{
addTies(cfun,term[1]);
continue;
}
else
{
fun = createSimple(term,pAttributes);
}
}
cfun->addFunction(fun);
size_t i = cfun->nFunctions() - 1;
for(auto att = pAttributes.begin(); att != pAttributes.end(); ++att)
{
cfun->setLocalAttributeValue(i,att->first,att->second);
}
}
cfun->applyTies();
return cfun;
}