FunctionValues.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/FunctionValues.h"
#include <algorithm>
#include <functional>
 
namespace Mantid::API {
 
FunctionValues::FunctionValues(size_t n) {
  if (n > 0) {
    m_calculated.resize(n);
  }
}
 
FunctionValues::FunctionValues(const FunctionDomain &domain) { reset(domain); }
 
void FunctionValues::reset(const FunctionDomain &domain) {
  if (domain.size() == 0) {
    throw std::invalid_argument("FunctionValues cannot have zero size.");
  }
  m_calculated.resize(domain.size());
}
 
void FunctionValues::expand(size_t n) {
  if (n < size()) {
    throw std::invalid_argument("Cannot make FunctionValues smaller");
  }
  m_calculated.resize(n);
  if (!m_data.empty()) {
    m_data.resize(n);
  }
  if (!m_weights.empty()) {
    m_weights.resize(n);
  }
}
 
void FunctionValues::setCalculated(double value) { std::fill(m_calculated.begin(), m_calculated.end(), value); }
 
double *FunctionValues::getPointerToCalculated(size_t i) {
  if (i < size()) {
    return &m_calculated[i];
  }
  throw std::out_of_range("FunctionValue index out of range.");
}
 
void FunctionValues::zeroCalculated() { setCalculated(0.0); }
 
void FunctionValues::copyTo(double *to) const { std::copy(m_calculated.begin(), m_calculated.end(), to); }
 
void FunctionValues::add(double *to) const {
  std::transform(m_calculated.begin(), m_calculated.end(), to, to, std::plus<double>());
}
 
void FunctionValues::multiply(double *to) const {
  std::transform(m_calculated.begin(), m_calculated.end(), to, to, std::multiplies<double>());
}
 
FunctionValues &FunctionValues::operator+=(const FunctionValues &values) {
  if (size() != values.size()) {
    throw std::runtime_error("Cannot add values: sizes do not match");
  }
  values.add(getPointerToCalculated(0));
  return *this;
}
 
FunctionValues &FunctionValues::operator*=(const FunctionValues &values) {
  if (size() != values.size()) {
    throw std::runtime_error("Cannot multiply values: sizes do not match");
  }
  values.multiply(getPointerToCalculated(0));
  return *this;
}
 
void FunctionValues::addToCalculated(size_t start, const FunctionValues &values) {
  if (start + size() < values.size()) {
    throw std::runtime_error("Cannot add values: sizes do not match");
  }
  values.add(getPointerToCalculated(start));
}
 
void FunctionValues::setFitData(size_t i, double value) {
  if (m_data.size() != m_calculated.size()) {
    m_data.resize(m_calculated.size());
  }
  m_data[i] = value;
}
 
void FunctionValues::setFitData(const std::vector<double> &values) {
  if (values.size() != this->size()) {
    throw std::invalid_argument("Setting data of a wrong size");
  }
  m_data.assign(values.begin(), values.end());
}
 
double FunctionValues::getFitData(size_t i) const {
  if (m_data.size() != m_calculated.size()) {
    throw std::runtime_error("Fitting data was not set");
  }
  return m_data[i];
}
 
void FunctionValues::setFitWeight(size_t i, double value) {
  if (m_weights.size() != m_calculated.size()) {
    m_weights.resize(m_calculated.size());
  }
  m_weights[i] = value;
}
 
void FunctionValues::setFitWeights(const std::vector<double> &values) {
  if (values.size() != this->size()) {
    throw std::invalid_argument("Setting data of a wrong size");
  }
  m_weights.assign(values.begin(), values.end());
}
 
void FunctionValues::setFitWeights(const double &value) { m_weights.resize(m_calculated.size(), value); }
 
double FunctionValues::getFitWeight(size_t i) const {
  if (m_weights.size() != m_calculated.size()) {
    throw std::runtime_error("Fitting weights was not set");
  }
  return m_weights[i];
}
 
void FunctionValues::setFitDataFromCalculated(const FunctionValues &values) {
  m_data.assign(values.m_calculated.begin(), values.m_calculated.end());
}
 
} // namespace Mantid::API