OptimizationParameters.hpp

#pragma once

#include <limits>

#include "OptimizationResult.hpp"
#include "ScalarTraits.hpp"


namespace LSLOpt {

enum class Linesearch {
    Backtracking,
};

enum class Alpha0Policy {
  Constant, 
  ConstantScaling, 
  Interpolation, 
};


template<typename Scalar>
struct OptimizationParameters {
    Scalar machine_epsilon;

    unsigned max_iterations = 10000;
    Scalar gradient_tolerance;
    Scalar alpha_min;

    Scalar wolfe_c1 {1e-4};
    Scalar wolfe_c2 {0.9};

    Scalar sigma2 {0.6};
    Scalar sigma3 {3.0};
    Scalar sigma4 {0.0};

    Scalar check_epsilon;

    Scalar min_change;
    unsigned min_iterations_with_no_change = 2;

    Scalar min_grad_param;

    // BFGS is terminated if f_{i} <= min_value
    Scalar min_value;

    Linesearch linesearch = Linesearch::Backtracking;

    unsigned max_linesearch_iterations = std::numeric_limits<unsigned>::max();

    unsigned m = 10;

    bool allow_restarts = true;

    Alpha0Policy alpha0 = Alpha0Policy::Constant;

  private:
    // we prevent instantiation without meaningful default parameters
    OptimizationParameters() = default;
    template<typename U>
    friend OptimizationParameters<U> getOptimizationParameters();

};

template<typename Scalar>
OptimizationParameters<Scalar> getOptimizationParameters()
{
  return OptimizationParameters<Scalar>();
}

template<>
inline OptimizationParameters<double> getOptimizationParameters<double>()
{
  OptimizationParameters<double> params;

  params.machine_epsilon = scalar_traits<double>::epsilon();
  params.gradient_tolerance = 1e-6;
  params.alpha_min = params.machine_epsilon;
  params.check_epsilon = 1e-10;
  params.min_change = 0.0;
  params.min_value = -scalar_traits<double>::infinity();
  params.min_grad_param = params.machine_epsilon * params.machine_epsilon;

  return params;
};

}