SimpleChebfun.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 +
#include "MantidCurveFitting/Functions/SimpleChebfun.h"
#include "MantidAPI/IFunction.h"
 
#include <memory>
#include <utility>
 
namespace Mantid::CurveFitting::Functions {
 
using namespace CurveFitting;
 
//----------------------------------------------------------------------------------------------
SimpleChebfun::SimpleChebfun(size_t n, ChebfunFunctionType fun, double start, double end)
    : m_base(std::make_shared<ChebfunBase>(n, start, end)), m_badFit(false) {
  m_P = m_base->fit(std::move(fun));
}
 
SimpleChebfun::SimpleChebfun(size_t n, const API::IFunction &fun, double start, double end)
    : m_base(std::make_shared<ChebfunBase>(n, start, end)), m_badFit(false) {
  m_P = m_base->fit(fun);
}
 
SimpleChebfun::SimpleChebfun(const ChebfunFunctionType &fun, double start, double end, double accuracy, size_t badSize)
    : m_badFit(false) {
  m_base = ChebfunBase::bestFitAnyTolerance<ChebfunFunctionType>(start, end, fun, m_P, m_A, accuracy);
  if (!m_base) {
    m_base = std::make_shared<ChebfunBase>(badSize - 1, start, end, accuracy);
    m_P = m_base->fit(fun);
    m_badFit = true;
  }
}
 
SimpleChebfun::SimpleChebfun(const API::IFunction &fun, double start, double end, double accuracy, size_t badSize)
    : m_badFit(false) {
  m_base = ChebfunBase::bestFitAnyTolerance<const API::IFunction &>(start, end, fun, m_P, m_A, accuracy);
  if (!m_base) {
    m_base = std::make_shared<ChebfunBase>(badSize - 1, start, end, accuracy);
    m_P = m_base->fit(fun);
    m_badFit = true;
  }
}
 
SimpleChebfun::SimpleChebfun(const std::vector<double> &x, const std::vector<double> &y)
    : m_base(std::make_shared<ChebfunBase>(x.size() - 1, x.front(), x.back())), m_badFit(false) {
  m_P = m_base->smooth(x, y);
}
 
SimpleChebfun::SimpleChebfun(const ChebfunBase_sptr &base) : m_badFit(false) {
  assert(base);
  m_base = base;
  m_P.resize(base->size());
}
 
const std::vector<double> &SimpleChebfun::coeffs() const {
  if (m_A.empty()) {
    m_A = m_base->calcA(m_P);
  }
  return m_A;
}
 
double SimpleChebfun::operator()(double x) const { return m_base->eval(x, m_P); }
 
std::vector<double> SimpleChebfun::operator()(const std::vector<double> &x) const { return m_base->evalVector(x, m_P); }
 
std::vector<double> SimpleChebfun::linspace(size_t n) const { return m_base->linspace(n); }
 
double SimpleChebfun::accuracy() const { return m_base->tolerance(); }
 
SimpleChebfun SimpleChebfun::derivative() const {
  SimpleChebfun cheb(m_base);
  if (m_A.empty()) {
    m_A = m_base->calcA(m_P);
  }
  m_base->derivative(m_A, cheb.m_A);
  cheb.m_P = m_base->calcP(cheb.m_A);
  return cheb;
}
 
SimpleChebfun SimpleChebfun::integral() const {
  if (m_A.empty()) {
    m_A = m_base->calcA(m_P);
  }
  std::vector<double> A;
  auto base = m_base->integral(m_A, A);
  SimpleChebfun cheb(base);
  cheb.m_P = base->calcP(A);
  cheb.m_A = A;
  return cheb;
}
 
std::vector<double> SimpleChebfun::roughRoots(double level) const {
  std::vector<double> rs;
  if (m_P.empty())
    return rs;
  auto &x = m_base->xPoints();
  auto y1 = m_P.front() - level;
  for (size_t i = 1; i < m_P.size(); ++i) {
    auto y = m_P[i] - level;
    if (y == 0.0) {
      rs.emplace_back(x[i]);
    } else if (y1 * y < 0.0) {
      rs.emplace_back((-x[i - 1] * y + x[i] * y1) / (y1 - y));
    }
    y1 = y;
  }
  return rs;
}
 
double SimpleChebfun::integrate() const { return m_base->integrate(m_P); }
 
SimpleChebfun &SimpleChebfun::operator+=(const ChebfunFunctionType &fun) {
  auto &x = xPoints();
  for (size_t i = 0; i < x.size(); ++i) {
    m_P[i] += fun(x[i]);
  }
  m_A.clear();
  return *this;
}
 
} // namespace Mantid::CurveFitting::Functions