ChebfunBase.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2007 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 +
#pragma once
 
#include "MantidCurveFitting/DllConfig.h"
#include "MantidCurveFitting/EigenMatrix.h"
 
#include <functional>
#include <memory>
#include <vector>
 
namespace Mantid {
 
namespace API {
class IFunction;
}
 
namespace CurveFitting {
namespace Functions {
 
using ChebfunFunctionType = std::function<double(double)>;
 
class MANTID_CURVEFITTING_DLL ChebfunBase {
public:
  ChebfunBase(size_t n, double start, double end, double tolerance = 0.0);
  ChebfunBase(const ChebfunBase &) = default;
  ChebfunBase(ChebfunBase &&) noexcept = default;
  size_t order() const { return m_n; }
  size_t size() const { return m_x.size(); }
  double startX() const { return m_x.front(); }
  double endX() const { return m_x.back(); }
  double width() const { return endX() - startX(); }
  const std::vector<double> &xPoints() const { return m_x; }
  const std::vector<double> &integrationWeights() const;
  double integrate(const std::vector<double> &p) const;
  std::vector<double> calcA(const std::vector<double> &p) const;
  std::vector<double> calcP(const std::vector<double> &a) const;
  std::vector<double> fit(ChebfunFunctionType f) const;
  std::vector<double> fit(const API::IFunction &f) const;
 
  double eval(double x, const std::vector<double> &p) const;
  void evalVector(const std::vector<double> &x, const std::vector<double> &p, std::vector<double> &res) const;
  std::vector<double> evalVector(const std::vector<double> &x, const std::vector<double> &p) const;
  void derivative(const std::vector<double> &a, std::vector<double> &aout) const;
  std::shared_ptr<ChebfunBase> integral(const std::vector<double> &a, std::vector<double> &aout) const;
  std::vector<double> roots(const std::vector<double> &a) const;
 
  static std::shared_ptr<ChebfunBase> bestFit(double start, double end, ChebfunFunctionType, std::vector<double> &p,
                                              std::vector<double> &a, double maxA = 0.0, double tolerance = 0.0,
                                              size_t maxSize = 0);
  static std::shared_ptr<ChebfunBase> bestFit(double start, double end, const API::IFunction &, std::vector<double> &p,
                                              std::vector<double> &a, double maxA = 0.0, double tolerance = 0.0,
                                              size_t maxSize = 0);
  double tolerance() { return m_tolerance; }
 
  template <class FunctionType>
  static std::shared_ptr<ChebfunBase>
  bestFitAnyTolerance(double start, double end, FunctionType f, std::vector<double> &p, std::vector<double> &a,
                      double maxA = 0.0, double tolerance = 0.0, size_t maxSize = 0);
 
  std::vector<double> linspace(size_t n) const;
  std::vector<double> smooth(const std::vector<double> &xvalues, const std::vector<double> &yvalues) const;
 
private:
  ChebfunBase &operator=(const ChebfunBase &other) = delete;
  ChebfunBase &operator=(ChebfunBase &&other) = delete;
  void calcX();
  void calcIntegrationWeights() const;
 
  std::vector<double> fitOdd(const ChebfunFunctionType &f, std::vector<double> &p) const;
  std::vector<double> fitOdd(const API::IFunction &f, std::vector<double> &pEven) const;
  static bool hasConverged(const std::vector<double> &a, double maxA, double tolerance, size_t shift = 0);
  template <class FunctionType>
  static std::shared_ptr<ChebfunBase> bestFitTempl(double start, double end, FunctionType f, std::vector<double> &p,
                                                   std::vector<double> &a, double maxA, double tolerance,
                                                   size_t maxSize);
 
  const double m_tolerance;
  size_t m_n;
  double m_start;
  double m_end;
  std::vector<double> m_x;
  std::vector<double> m_bw;
  mutable std::vector<double> m_integrationWeights;
  static const double g_tolerance;
  static const size_t g_maxNumberPoints;
};
 
using ChebfunBase_sptr = std::shared_ptr<ChebfunBase>;
 
template <class FunctionType>
std::shared_ptr<ChebfunBase> ChebfunBase::bestFitAnyTolerance(double start, double end, FunctionType f,
                                                              std::vector<double> &p, std::vector<double> &a,
                                                              double maxA, double tolerance, size_t maxSize) {
  if (tolerance == 0.0)
    tolerance = g_tolerance;
 
  double tol = tolerance;
  while (tol < 0.1) {
    auto base = bestFit(start, end, f, p, a, maxA, tol, maxSize);
    if (base) {
      return base;
    }
    tol *= 100.0;
  }
  return ChebfunBase_sptr();
}
 
} // namespace Functions
} // namespace CurveFitting
} // namespace Mantid