scitbx/lbfgs/drop_convergence_test.h

#ifndef SCITBX_LBFGS_DROP_CONVERGENCE_TEST_H
#define SCITBX_LBFGS_DROP_CONVERGENCE_TEST_H

#include <scitbx/array_family/shared.h>
#include <scitbx/array_family/misc_functions.h>
#include <scitbx/math/linear_regression.h>

namespace scitbx { namespace lbfgs {


  template <typename FloatType, typename SizeType = std::size_t>
  class drop_convergence_test
  {
    public:

      explicit
      drop_convergence_test(
        SizeType n_test_points=5,
        FloatType max_drop_eps=FloatType(1.e-5),
        FloatType iteration_coefficient=FloatType(2))
      : n_test_points_(n_test_points),
        max_drop_eps_(max_drop_eps),
        iteration_coefficient_(iteration_coefficient),
        max_drop_(0),
        max_f_(0)
      {
        SCITBX_ASSERT(n_test_points >= 2);
        SCITBX_ASSERT(max_drop_eps_ >= FloatType(0));
        SCITBX_ASSERT(iteration_coefficient_ >= FloatType(1));
      }

      SizeType n_test_points() const { return n_test_points_; }

      FloatType max_drop_eps() const { return max_drop_eps_; }

      FloatType iteration_coefficient() const {
        return iteration_coefficient_;
      }


      bool
      operator()(FloatType f);

      af::shared<FloatType> objective_function_values() const {
        return y_;
      }

      FloatType max_drop() const { return max_drop_; }

    protected:
      const SizeType n_test_points_;
      const FloatType max_drop_eps_;
      const FloatType iteration_coefficient_;
      af::shared<FloatType> x_;
      af::shared<FloatType> y_;
      FloatType max_drop_;
      FloatType max_f_;
  };

  template <typename FloatType, typename SizeType>
  bool
  drop_convergence_test<FloatType, SizeType>::operator()(FloatType f)
  {
    if (x_.size()) {
      max_drop_ = std::max(max_drop_, y_.back() - f);
    }
    max_f_ = std::max(max_f_, fn::absolute(f));
    x_.push_back(x_.size() + 1);
    y_.push_back(f);
    if (x_.size() < n_test_points_) return false;
    if (!max_f_) return true; // y_ must be all 0
    af::shared<FloatType> y_scaled;
    y_scaled.reserve(n_test_points_);
    for(std::size_t i=y_.size()-n_test_points_;i<y_.size();i++) {
      y_scaled.push_back(y_[i] / max_f_);
    }
    // fit last n_test_points_ to straight line: y = m*x + b
    math::linear_regression<FloatType> linreg_y(
      af::const_ref<FloatType>(x_.end() - n_test_points_, n_test_points_),
      af::const_ref<FloatType>(y_scaled.begin(), n_test_points_));
    SCITBX_ASSERT(linreg_y.is_well_defined());
    // check absolute value of slope
    FloatType sliding_tolerance =
      max_drop_ * max_drop_eps_ * std::pow(
        FloatType(x_.size()), iteration_coefficient_);
    if (-linreg_y.slope() * max_f_ <= sliding_tolerance) {
      return true;
    }
    return false;
  }

}} // namespace scitbx::lbfgs

#endif // SCITBX_LBFGS_DROP_CONVERGENCE_TEST_H

---