CompositeFunction.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidAPI/CompositeFunction.h"
#include "MantidAPI/FunctionFactory.h"
#include "MantidAPI/IConstraint.h"
#include "MantidAPI/ParameterTie.h"
#include "MantidKernel/Exception.h"
#include "MantidKernel/Logger.h"
#include "MantidKernel/Strings.h"
 
#include <algorithm>
#include <boost/lexical_cast.hpp>
#include <memory>
#include <numeric>
#include <sstream>
#include <utility>
 
namespace Mantid::API {
 
namespace {
Kernel::Logger g_log("CompositeFunction");
constexpr char *ATTNUMDERIV = "NumDeriv";
constexpr int NUMDEFAULTATTRIBUTES = 1;
template <typename T>
void replaceVariableIndexRange(std::vector<T> &variableFunctionIndexList, const size_t oldSize, const size_t newSize,
                               const T functionIndex) {
  auto itFun = std::find(variableFunctionIndexList.begin(), variableFunctionIndexList.end(), functionIndex);
  if (itFun != variableFunctionIndexList.end()) {
    if (oldSize > newSize) {
      variableFunctionIndexList.erase(itFun, itFun + oldSize - newSize);
    } else if (oldSize < newSize) {
      variableFunctionIndexList.insert(itFun, newSize - oldSize, functionIndex);
    }
  } else if (newSize > 0) {
    using std::placeholders::_1;
    itFun = std::find_if(variableFunctionIndexList.begin(), variableFunctionIndexList.end(),
                         std::bind(std::greater<size_t>(), _1, functionIndex));
    variableFunctionIndexList.insert(itFun, newSize, functionIndex);
  }
}
 
} // namespace
 
using std::size_t;
 
DECLARE_FUNCTION(CompositeFunction)
 
 
CompositeFunction::CompositeFunction() : IFunction(), m_nParams(0), m_nAttributes(0), m_iConstraintFunction(false) {
  createDefaultGlobalAttributes();
}
 
void CompositeFunction::createDefaultGlobalAttributes() {
  m_globalAttributeNames.clear();
  declareAttribute(ATTNUMDERIV, Attribute(false));
  m_nAttributes = NUMDEFAULTATTRIBUTES;
}
 
void CompositeFunction::init() {}
 
std::string CompositeFunction::writeToString(const std::string &parentLocalAttributesStr) const {
  std::ostringstream ostr;
 
  // if empty just return function name
  if (nFunctions() == 0) {
    return "name=" + name();
  }
 
  if (name() != "CompositeFunction" || nGlobalAttributes() > NUMDEFAULTATTRIBUTES ||
      getAttribute(ATTNUMDERIV).asBool() || !parentLocalAttributesStr.empty()) {
    ostr << "composite=" << name();
    std::vector<std::string> attr = m_globalAttributeNames;
    for (const auto &attName : attr) {
      std::string attValue = this->getAttribute(attName).value();
      if (!attValue.empty()) {
        ostr << ',' << attName << '=' << attValue;
      }
    }
    ostr << parentLocalAttributesStr << ';';
  }
  const auto localAttr = this->getLocalAttributeNames();
  for (size_t i = 0; i < nFunctions(); i++) {
    IFunction_sptr fun = getFunction(i);
    bool isComp = std::dynamic_pointer_cast<CompositeFunction>(fun) != nullptr;
    if (isComp)
      ostr << '(';
    std::ostringstream localAttributesStr;
    for (const auto &localAttName : localAttr) {
      const std::string localAttValue = this->getLocalAttribute(i, localAttName).value();
      if (!localAttValue.empty()) {
        // local attribute names are prefixed by dollar sign
        localAttributesStr << ',' << '$' << localAttName << '=' << localAttValue;
      }
    }
    ostr << fun->writeToString(localAttributesStr.str());
    if (isComp)
      ostr << ')';
    if (i < nFunctions() - 1) {
      ostr << ';';
    }
  }
 
  // collect non-default constraints
  std::string constraints = writeConstraints();
  // print constraints
  if (!constraints.empty()) {
    ostr << ";constraints=(" << constraints << ")";
  }
 
  // collect the non-default ties
  std::string ties = writeTies();
  // print the ties
  if (!ties.empty()) {
    ostr << ";ties=(" << ties << ")";
  }
 
  return ostr.str();
}
 
void CompositeFunction::setWorkspace(std::shared_ptr<const Workspace> ws) {
  // Pass it on to each member
  auto iend = m_functions.end();
  for (auto it = m_functions.begin(); it != iend; ++it) {
    (*it)->setWorkspace(ws);
  }
}
 
void CompositeFunction::setMatrixWorkspace(std::shared_ptr<const MatrixWorkspace> workspace, size_t wi, double startX,
                                           double endX) {
  for (size_t iFun = 0; iFun < nFunctions(); ++iFun) {
    m_functions[iFun]->setMatrixWorkspace(workspace, wi, startX, endX);
  }
}
 
void CompositeFunction::setStepSizeMethod(const StepSizeMethod stepSizeMethod) {
  std::for_each(m_functions.begin(), m_functions.end(),
                [&stepSizeMethod](const auto &function) { function->setStepSizeMethod(stepSizeMethod); });
}
 
void CompositeFunction::function(const FunctionDomain &domain, FunctionValues &values) const {
  FunctionValues tmp(domain);
  values.zeroCalculated();
  for (size_t iFun = 0; iFun < nFunctions(); ++iFun) {
    m_functions[iFun]->function(domain, tmp);
    values += tmp;
  }
}
 
void CompositeFunction::functionDeriv(const FunctionDomain &domain, Jacobian &jacobian) {
  if (getAttribute(ATTNUMDERIV).asBool()) {
    calNumericalDeriv(domain, jacobian);
  } else {
    for (size_t iFun = 0; iFun < nFunctions(); ++iFun) {
      PartialJacobian J(&jacobian, paramOffset(iFun));
      getFunction(iFun)->functionDeriv(domain, J);
    }
  }
}
 
void CompositeFunction::setParameter(size_t i, const double &value, bool explicitlySet) {
  size_t iFun = functionIndex(i);
  m_functions[iFun]->setParameter(i - m_paramOffsets[iFun], value, explicitlySet);
}
 
void CompositeFunction::setParameterDescription(size_t i, const std::string &description) {
  size_t iFun = functionIndex(i);
  m_functions[iFun]->setParameterDescription(i - m_paramOffsets[iFun], description);
}
 
double CompositeFunction::getParameter(size_t i) const {
  size_t iFun = functionIndex(i);
  return m_functions[iFun]->getParameter(i - m_paramOffsets[iFun]);
}
 
double CompositeFunction::getParameter(size_t i, size_t j) const { return m_functions[i]->getParameter(j); }
 
bool CompositeFunction::hasParameter(const std::string &name) const {
  try {
    const auto [parameterName, index] = parseName(name);
    return index < m_functions.size() ? m_functions[index]->hasParameter(parameterName) : false;
  } catch (std::invalid_argument &) {
    return false;
  }
}
 
bool CompositeFunction::hasAttribute(const std::string &name) const {
  try {
    if (std::find(m_globalAttributeNames.begin(), m_globalAttributeNames.end(), name) != m_globalAttributeNames.end()) {
      return true;
    }
    const auto [attributeName, index] = parseName(name);
    return index < m_functions.size() ? m_functions[index]->hasAttribute(attributeName) : false;
  } catch (std::invalid_argument &) {
    return false;
  }
}
 
void CompositeFunction::setParameter(const std::string &name, const double &value, bool explicitlySet) {
  const auto [parameterName, index] = parseName(name);
  getFunction(index)->setParameter(parameterName, value, explicitlySet);
}
 
void CompositeFunction::setParameterDescription(const std::string &name, const std::string &description) {
  const auto [parameterName, index] = parseName(name);
  getFunction(index)->setParameterDescription(parameterName, description);
}
 
double CompositeFunction::getParameter(const std::string &name) const {
  const auto [parameterName, index] = parseName(name);
  return getFunction(index)->getParameter(parameterName);
}
 
API::IFunction::Attribute CompositeFunction::getAttribute(const std::string &name) const {
  try {
    if (std::find(m_globalAttributeNames.begin(), m_globalAttributeNames.end(), name) != m_globalAttributeNames.end()) {
      return IFunction::getAttribute(name);
    }
    const auto [attributeName, index] = parseName(name);
    return m_functions[index]->getAttribute(attributeName);
  } catch (std::invalid_argument &) {
    throw std::invalid_argument("ParamFunctionAttributeHolder::getAttribute - Unknown attribute '" + name + "'");
  }
}
 
void CompositeFunction::setAttribute(const std::string &name, const API::IFunction::Attribute &value) {
  if (std::find(m_globalAttributeNames.begin(), m_globalAttributeNames.end(), name) != m_globalAttributeNames.end()) {
    return IFunction::setAttribute(name, value);
  }
  const auto [attributeName, index] = parseName(name);
  return m_functions[index]->setAttribute(attributeName, value);
}
 
size_t CompositeFunction::nParams() const { return m_nParams; }
 
// Total number of attributes
size_t CompositeFunction::nAttributes() const {
  return std::accumulate(
      m_functions.cbegin(), m_functions.cend(), nGlobalAttributes(),
      [](const size_t accumulator, const auto &function) -> size_t { return accumulator + function->nAttributes(); });
}
size_t CompositeFunction::parameterIndex(const std::string &name) const {
  const auto [parameterName, index] = parseName(name);
  return getFunction(index)->parameterIndex(parameterName) + m_paramOffsets[index];
}
 
std::string CompositeFunction::parameterName(size_t i) const {
  const size_t iFun = functionIndex(i);
  std::ostringstream ostr;
  ostr << 'f' << iFun << '.' << m_functions[iFun]->parameterName(i - m_paramOffsets[iFun]);
  return ostr.str();
}
 
std::string CompositeFunction::parameterName(size_t i, size_t j) const {
  std::ostringstream ostr;
  ostr << 'f' << i << '.' << m_functions[i]->parameterName(j);
  return ostr.str();
}
 
std::string CompositeFunction::attributeName(size_t index) const {
  if (index < nGlobalAttributes())
    return IFunction::attributeName(index);
 
  // Offset the index by the number of global attributes
  const size_t offsetIndex = index - nGlobalAttributes();
  size_t functionIndex = attributeFunctionIndex(offsetIndex);
  std::ostringstream ostr;
  ostr << 'f' << functionIndex << '.' << m_functions[functionIndex]->attributeName(getAttributeOffset(offsetIndex));
  return ostr.str();
}
 
std::string CompositeFunction::parameterDescription(size_t i) const {
  const size_t iFun = functionIndex(i);
  std::ostringstream ostr;
  ostr << m_functions[iFun]->parameterDescription(i - m_paramOffsets[iFun]);
  return ostr.str();
}
double CompositeFunction::getError(size_t i) const {
  size_t iFun = functionIndex(i);
  return m_functions[iFun]->getError(i - m_paramOffsets[iFun]);
}
double CompositeFunction::getError(size_t i, size_t j) const { return m_functions[i]->getError(j); }
 
double CompositeFunction::getError(const std::string &name) const {
  const auto [parameterName, index] = parseName(name);
  return getFunction(index)->getError(parameterName);
}
 
void CompositeFunction::setError(size_t i, double err) {
  size_t iFun = functionIndex(i);
  m_functions[iFun]->setError(i - m_paramOffsets[iFun], err);
}
 
void CompositeFunction::setError(const std::string &name, double err) {
  auto [parameterName, index] = parseName(name);
  getFunction(index)->setError(parameterName, err);
}
 
double CompositeFunction::activeParameter(size_t i) const {
  size_t iFun = functionIndex(i);
  return m_functions[iFun]->activeParameter(i - m_paramOffsets[iFun]);
}
 
void CompositeFunction::setActiveParameter(size_t i, double value) {
  size_t iFun = functionIndex(i);
  m_functions[iFun]->setActiveParameter(i - m_paramOffsets[iFun], value);
}
 
std::string CompositeFunction::nameOfActive(size_t i) const {
  size_t iFun = functionIndex(i);
  std::ostringstream ostr;
  ostr << 'f' << iFun << '.' << m_functions[iFun]->nameOfActive(i - m_paramOffsets[iFun]);
  return ostr.str();
}
 
std::string CompositeFunction::descriptionOfActive(size_t i) const {
  size_t iFun = functionIndex(i);
  std::ostringstream ostr;
  ostr << m_functions[iFun]->descriptionOfActive(i - m_paramOffsets[iFun]);
  return ostr.str();
}
 
void CompositeFunction::setParameterStatus(size_t i, IFunction::ParameterStatus status) {
  size_t iFun = functionIndex(i);
  m_functions[iFun]->setParameterStatus(i - m_paramOffsets[iFun], status);
}
 
IFunction::ParameterStatus CompositeFunction::getParameterStatus(size_t i) const {
  size_t iFun = functionIndex(i);
  return m_functions[iFun]->getParameterStatus(i - m_paramOffsets[iFun]);
}
 
void CompositeFunction::checkFunction() {
  m_nParams = 0;
  m_nAttributes = nGlobalAttributes();
  m_paramOffsets.clear();
  m_IFunction.clear();
  m_attributeIndex.clear();
 
  std::vector<IFunction_sptr> functions(m_functions.begin(), m_functions.end());
  m_functions.clear();
 
  for (auto &f : functions) {
    CompositeFunction_sptr cf = std::dynamic_pointer_cast<CompositeFunction>(f);
    if (cf)
      cf->checkFunction();
    addFunction(f);
  }
}
 
void CompositeFunction::clear() {
  m_nParams = 0;
  m_nAttributes = nGlobalAttributes();
  m_paramOffsets.clear();
  m_IFunction.clear();
  m_functions.clear();
  m_attributeIndex.clear();
}
 
size_t CompositeFunction::addFunction(IFunction_sptr f) {
  m_IFunction.insert(m_IFunction.end(), f->nParams(), m_functions.size());
  m_attributeIndex.insert(m_attributeIndex.end(), f->nAttributes(), m_functions.size());
  m_functions.emplace_back(f);
  if (m_paramOffsets.empty()) {
    m_paramOffsets.emplace_back(0);
    m_nParams = f->nParams();
    m_nAttributes = f->nAttributes() + nGlobalAttributes();
  } else {
    m_paramOffsets.emplace_back(m_nParams);
    m_nParams += f->nParams();
    m_nAttributes += f->nAttributes();
  }
  return m_functions.size() - 1;
}
 
void CompositeFunction::removeFunction(size_t i) {
  if (i >= nFunctions()) {
    throw std::out_of_range("Function index (" + std::to_string(i) + ") out of range (" + std::to_string(nFunctions()) +
                            ").");
  }
 
  const IFunction_sptr fun = getFunction(i);
  // Remove ties which are no longer valid
  for (size_t j = 0; j < nParams();) {
    ParameterTie *tie = getTie(j);
    if (tie && tie->findParametersOf(fun.get())) {
      removeTie(j);
    } else {
      j++;
    }
  }
 
  // Shift down the function indices for parameters and attributes
  auto shiftDown = [&](auto &functionIndex) {
    if (functionIndex == i) {
      return true;
    } else if (functionIndex > i) {
      functionIndex -= 1;
      return false;
    } else {
      return false;
    }
  };
 
  m_IFunction.erase(std::remove_if(m_IFunction.begin(), m_IFunction.end(), shiftDown), m_IFunction.end());
  m_attributeIndex.erase(std::remove_if(m_attributeIndex.begin(), m_attributeIndex.end(), shiftDown),
                         m_attributeIndex.end());
 
  // Reduction in parameters and attributes
  m_nParams -= fun->nParams();
  m_nAttributes -= fun->nAttributes();
 
  // Shift the parameter offsets down by the total number of i-th function's
  // params
  for (size_t j = i + 1; j < nFunctions(); j++) {
    m_paramOffsets[j] -= fun->nParams();
  }
  m_paramOffsets.erase(m_paramOffsets.begin() + i);
 
  m_functions.erase(m_functions.begin() + i);
}
 
void CompositeFunction::replaceFunctionPtr(const IFunction_sptr &f_old, const IFunction_sptr &f_new) {
  std::vector<IFunction_sptr>::const_iterator it = std::find(m_functions.begin(), m_functions.end(), f_old);
  if (it == m_functions.end())
    return;
  std::vector<IFunction_sptr>::difference_type iFun = it - m_functions.begin();
  replaceFunction(iFun, f_new);
}
 
void CompositeFunction::replaceFunction(size_t functionIndex, const IFunction_sptr &f) {
  if (functionIndex >= nFunctions()) {
    throw std::out_of_range("Function index (" + std::to_string(functionIndex) + ") out of range (" +
                            std::to_string(nFunctions()) + ").");
  }
 
  const IFunction_sptr fun = getFunction(functionIndex);
  const size_t np_old = fun->nParams();
  const size_t np_new = f->nParams();
  const size_t at_old = fun->nAttributes();
  const size_t at_new = f->nAttributes();
 
  // Modify function parameter and attribute indices:
  replaceVariableIndexRange(m_IFunction, np_old, np_new, functionIndex);
  replaceVariableIndexRange(m_attributeIndex, at_old, at_new, functionIndex);
 
  // Decrement attribute and parameter counts
  const size_t dnp = np_new - np_old;
  const size_t dna = at_new - at_old;
  m_nParams += dnp;
  m_nAttributes += dna;
 
  // Shift the parameter offsets down by the total number of i-th function's
  // params
  for (size_t j = functionIndex + 1; j < nFunctions(); j++) {
    m_paramOffsets[j] += dnp;
  }
  m_functions[functionIndex] = f;
}
 
bool CompositeFunction::hasFunction(const std::string &functionName) const {
  return std::any_of(m_functions.cbegin(), m_functions.cend(), [&functionName](const IFunction_const_sptr &function) {
    return function->name() == functionName;
  });
}
 
IFunction_sptr CompositeFunction::getFunction(std::size_t i) const {
  if (i >= nFunctions()) {
    throw std::out_of_range("Function index (" + std::to_string(i) + ") out of range (" + std::to_string(nFunctions()) +
                            ").");
  }
  return m_functions[i];
}
 
std::size_t CompositeFunction::functionIndex(const std::string &functionName) const {
  const auto iter =
      std::find_if(m_functions.cbegin(), m_functions.cend(),
                   [&functionName](const IFunction_const_sptr &function) { return function->name() == functionName; });
 
  if (iter != m_functions.cend())
    return std::distance(m_functions.cbegin(), iter);
 
  throw std::invalid_argument("A function with name '" + functionName + "' does not exist in this composite function.");
}
 
size_t CompositeFunction::functionIndex(std::size_t i) const {
  if (i >= nParams()) {
    throw std::out_of_range("Function parameter index (" + std::to_string(i) + ") out of range (" +
                            std::to_string(nParams()) + ").");
  }
  return m_IFunction[i];
}
size_t CompositeFunction::attributeFunctionIndex(std::size_t i) const {
  if (i >= nAttributes()) {
    throw std::out_of_range("Function attribute index (" + std::to_string(i) + ") out of range (" +
                            std::to_string(nAttributes()) + ").");
  }
  return m_attributeIndex[i];
}
 
std::pair<std::string, size_t> CompositeFunction::parseName(const std::string &varName) {
  const size_t i = varName.find('.');
  if (i == std::string::npos) {
    throw std::invalid_argument("Variable " + varName + " not found.");
  } else {
    if (varName[0] != 'f')
      throw std::invalid_argument("External function variable name must start with 'f'");
 
    const std::string sindex = varName.substr(1, i - 1);
    const size_t index = boost::lexical_cast<size_t>(sindex);
 
    if (i == varName.size() - 1)
      throw std::invalid_argument("Name cannot be empty");
 
    return std::make_pair(varName.substr(i + 1), index);
  }
}
 
size_t CompositeFunction::parameterLocalIndex(size_t i, bool recursive) const {
  size_t iFun = functionIndex(i);
  auto localIndex = i - m_paramOffsets[iFun];
  if (recursive) {
    auto cf = dynamic_cast<const CompositeFunction *>(m_functions[iFun].get());
    if (cf) {
      return cf->parameterLocalIndex(localIndex, recursive);
    }
  }
  return localIndex;
}
 
std::string CompositeFunction::parameterLocalName(size_t i, bool recursive) const {
  size_t iFun = functionIndex(i);
  auto localIndex = i - m_paramOffsets[iFun];
  auto localFunction = m_functions[iFun].get();
  if (recursive) {
    auto cf = dynamic_cast<const CompositeFunction *>(localFunction);
    if (cf) {
      return cf->parameterLocalName(localIndex, recursive);
    }
  }
  return localFunction->parameterName(localIndex);
}
 
void CompositeFunction::applyTies() {
  if (hasOrderedTies()) {
    applyOrderedTies();
  } else {
    for (size_t i = 0; i < nFunctions(); i++) {
      getFunction(i)->applyTies();
    }
    IFunction::applyTies();
  }
}
 
void CompositeFunction::clearTies() {
  IFunction::clearTies();
  for (size_t i = 0; i < nFunctions(); i++) {
    getFunction(i)->clearTies();
  }
}
 
bool CompositeFunction::removeTie(size_t i) {
  bool foundAndRemovedTie = IFunction::removeTie(i);
  if (!foundAndRemovedTie) {
    size_t iFun = functionIndex(i);
    bool res = m_functions[iFun]->removeTie(i - m_paramOffsets[iFun]);
    return res;
  }
  return foundAndRemovedTie;
}
 
ParameterTie *CompositeFunction::getTie(size_t i) const {
  auto tie = IFunction::getTie(i);
  if (tie == nullptr) {
    size_t iFun = functionIndex(i);
    tie = m_functions[iFun]->getTie(i - m_paramOffsets[iFun]);
  }
  return tie;
}
 
void CompositeFunction::declareParameter(const std::string &name, double initValue, const std::string &description) {
  (void)name;        // Avoid compiler warning
  (void)initValue;   // Avoid compiler warning
  (void)description; // Avoid compiler warning
  throw Kernel::Exception::NotImplementedError("CompositeFunction cannot not have its own parameters.");
}
void CompositeFunction::declareAttribute(const std::string &name, const API::IFunction::Attribute &defaultValue) {
  IFunction::declareAttribute(name, defaultValue);
  m_globalAttributeNames.emplace_back(name);
}
 
void CompositeFunction::declareAttribute(const std::string &name, const API::IFunction::Attribute &defaultValue,
                                         const Kernel::IValidator &validator) {
  IFunction::declareAttribute(name, defaultValue, validator);
  m_globalAttributeNames.emplace_back(name);
}
 
void CompositeFunction::registerFunctionUsage(bool internal) {
  for (size_t i = 0; i < nFunctions(); i++) {
    getFunction(i)->registerFunctionUsage(internal);
  }
}
 
void CompositeFunction::setUpForFit() {
  IFunction::setUpForFit();
  // set up the member functions
  for (size_t i = 0; i < nFunctions(); i++) {
    getFunction(i)->setUpForFit();
  }
 
  // Instead of automatically switching to numeric derivatives
  // log a warning about a danger of not using it
  if (!getAttribute("NumDeriv").asBool()) {
    for (size_t i = 0; i < nParams(); ++i) {
      ParameterTie *tie = getTie(i);
      if (tie && !tie->isConstant()) {
        g_log.warning() << "Numeric derivatives should be used when "
                           "non-constant ties defined.\n";
        break;
      }
    }
  }
}
 
IConstraint *CompositeFunction::getConstraint(size_t i) const {
  auto constraint = IFunction::getConstraint(i);
  if (constraint == nullptr) {
    size_t iFun = functionIndex(i);
    constraint = m_functions[iFun]->getConstraint(i - m_paramOffsets[iFun]);
  }
  return constraint;
}
 
void CompositeFunction::removeConstraint(const std::string &parName) {
  auto i = parameterIndex(parName);
  auto constraint = IFunction::getConstraint(i);
  if (constraint != nullptr) {
    IFunction::removeConstraint(parName);
  } else {
    size_t iPar = parameterIndex(parName);
    size_t iFun = functionIndex(iPar);
    getFunction(iFun)->removeConstraint(parameterLocalName(iPar));
  }
}
 
bool CompositeFunction::isExplicitlySet(size_t i) const {
  size_t iFun = functionIndex(i);
  return m_functions[iFun]->isExplicitlySet(i - m_paramOffsets[iFun]);
}
 
size_t CompositeFunction::getParameterIndex(const ParameterReference &ref) const {
  if (ref.getLocalFunction() == this && ref.getLocalIndex() < nParams()) {
    return ref.getLocalIndex();
  }
  for (size_t iFun = 0; iFun < nFunctions(); iFun++) {
    IFunction_sptr fun = getFunction(iFun);
    size_t iLocalIndex = fun->getParameterIndex(ref);
    if (iLocalIndex < fun->nParams()) {
      return m_paramOffsets[iFun] + iLocalIndex;
    }
  }
  return nParams();
}
 
IFunction_sptr CompositeFunction::getContainingFunction(const ParameterReference &ref) const {
  for (size_t iFun = 0; iFun < nFunctions(); iFun++) {
    IFunction_sptr fun = getFunction(iFun);
    if (fun->getParameterIndex(ref) < fun->nParams()) {
      return fun;
    }
  }
  return IFunction_sptr();
}
 
size_t CompositeFunction::getNumberDomains() const {
  auto n = nFunctions();
  if (n == 0) {
    return 1;
  }
  size_t nd = getFunction(0)->getNumberDomains();
  for (size_t iFun = 1; iFun < n; ++iFun) {
    if (getFunction(0)->getNumberDomains() != nd) {
      throw std::runtime_error("CompositeFunction has members with "
                               "inconsistent domain numbers.");
    }
  }
  return nd;
}
 
std::vector<IFunction_sptr> CompositeFunction::createEquivalentFunctions() const {
  auto nd = getNumberDomains();
  if (nd == 1) {
    return std::vector<IFunction_sptr>(1, FunctionFactory::Instance().createInitialized(asString()));
  }
 
  auto nf = nFunctions();
  std::vector<std::vector<IFunction_sptr>> equiv;
  equiv.reserve(nf);
  for (size_t i = 0; i < nf; ++i) {
    equiv.emplace_back(getFunction(i)->createEquivalentFunctions());
  }
 
  std::vector<IFunction_sptr> funs;
  funs.reserve(nd);
  for (size_t i = 0; i < nd; ++i) {
    auto comp = new CompositeFunction;
    funs.emplace_back(IFunction_sptr(comp));
    for (size_t j = 0; j < nf; ++j) {
      comp->addFunction(equiv[j][i]);
    }
  }
  return funs;
}
size_t CompositeFunction::getAttributeOffset(size_t attributeIndex) const {
  auto functionIndex = m_attributeIndex[attributeIndex];
  return std::distance(std::find(m_attributeIndex.begin(), m_attributeIndex.end(), functionIndex),
                       m_attributeIndex.begin() + attributeIndex);
}
 
} // namespace Mantid::API