ProblemTraits.hpp

#pragma once

#include <type_traits>

#include "../Types.hpp"
#include "../ScalarTraits.hpp"


namespace LSLOpt {

namespace Implementation {

template<typename T>
struct remove_cvref {
    using type = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
};

template<typename Problem, typename Scalar>
class problem_traits {
    static constexpr Vector<Scalar>* const dummy_vec = nullptr;
    static constexpr Problem* const dummy_problem = nullptr;

    template<typename U>
    static auto value_probe(U& u) -> decltype(u.value(*dummy_vec));
    static void value_probe(...);

    template<typename U>
    static auto gradient_probe(U& u) -> decltype(u.gradient(*dummy_vec));
    static void gradient_probe(...);

    template<typename U>
    static auto lower_bound_probe(U& u) -> decltype(u.lower_bounds());
    static void lower_bound_probe(...);

    template<typename U>
    static auto upper_bound_probe(U& u) -> decltype(u.upper_bounds());
    static void upper_bound_probe(...);

    template<typename U>
    static auto initial_step_length_probe(U& u)
        -> decltype(u.initial_step_length(*dummy_vec, *dummy_vec));
    static void initial_step_length_probe(...);

    template<typename U>
    static auto change_acceptable_probe(U& u)
        -> decltype(u.change_acceptable(*dummy_vec, *dummy_vec));
    static void change_acceptable_probe(...);

    template<typename U>
    static auto is_check_acceptable_first_probe(U& u) -> decltype(u.is_check_acceptable_first());
    static void is_check_acceptable_first_probe(...);

    template<typename U>
    static auto reparameterize_probe(U& u) -> decltype(u.reparameterize(*dummy_vec, *dummy_vec));
    static void reparameterize_probe(...);

public:
    using value_type = decltype(value_probe(*dummy_problem));
    static constexpr const bool has_value
        = std::is_same<Scalar, typename remove_cvref<value_type>::type>::value;

    using gradient_type = decltype(gradient_probe(*dummy_problem));
    static constexpr const bool has_gradient
        = std::is_same<Vector<Scalar>,
                       typename remove_cvref<gradient_type>::type>::value;

    using lower_bound_type = decltype(lower_bound_probe(*dummy_problem));
    static constexpr const bool has_lower_bound
        = std::is_same<Vector<Scalar>,
                       typename remove_cvref<lower_bound_type>::type>::value;

    using upper_bound_type = decltype(upper_bound_probe(*dummy_problem));
    static constexpr const bool has_upper_bound
        = std::is_same<Vector<Scalar>,
                       typename remove_cvref<upper_bound_type>::type>::value;

    using initial_step_length_type = decltype(initial_step_length_probe(*dummy_problem));
    static constexpr const bool has_initial_step_length
        = std::is_same<Scalar,
                       typename remove_cvref<initial_step_length_type>::type>::value;

    using change_acceptable_type = decltype(change_acceptable_probe(*dummy_problem));
    static constexpr const bool has_change_acceptable
        = std::is_same<Scalar,
                       typename remove_cvref<change_acceptable_type>::type>::value;

    using is_check_acceptable_first_type = decltype(is_check_acceptable_first_probe(*dummy_problem));
    static constexpr const bool has_is_check_acceptable_first
        = std::is_same<bool,
                       typename remove_cvref<is_check_acceptable_first_type>::type>::value;

    using reparameterize_type = decltype(reparameterize_probe(*dummy_problem));
    static constexpr const bool has_reparameterize
        = std::is_same<bool,
                       typename remove_cvref<reparameterize_type>::type>::value;
};

template<typename Problem, typename Scalar>
struct MaxStepLengthIdentifierTrait {
  static Scalar initial_step_length(
      Problem& problem,
      const Vector<Scalar>& x,
      const Vector<Scalar>& p)
  {
    static_assert(problem_traits<Problem, Scalar>::has_initial_step_length,
        "Problem must provide initial step length function: Scalar initial_step_length(...)");

    return problem.initial_step_length(x, p);
  }

  static Scalar change_acceptable(
      Problem& problem,
      const Vector<Scalar>& x0,
      const Vector<Scalar>& x)
  {
    static_assert(problem_traits<Problem, Scalar>::has_change_acceptable,
        "Problem must provide change acceptable function: Scalar change_acceptable(...)");

    return problem.change_acceptable(x0, x);
  }

  static bool is_check_acceptable_first(
      Problem& problem)
  {
    return _is_check_acceptable_first(problem);
  }

  private:

  template<typename U,
    typename std::enable_if<!problem_traits<U, Scalar>::has_is_check_acceptable_first,
      U>::type* = nullptr>
  static constexpr bool _is_check_acceptable_first(
    U&)
  {
    return false;
  }

  template<typename U,
    typename std::enable_if<problem_traits<U, Scalar>::has_is_check_acceptable_first,
      void>::type* = nullptr>
  static bool _is_check_acceptable_first(
      U& problem)
  {
    return problem.is_check_acceptable_first();
  }

};

template<typename Problem, typename Scalar>
struct NoMaxStepLengthIdentifierTrait {
  static constexpr Scalar initial_step_length(
      Problem&,
      const Vector<Scalar>&,
      const Vector<Scalar>&)
  {
    return scalar_traits<Scalar>::infinity();
  }

  static constexpr Scalar change_acceptable(
      Problem&,
      const Vector<Scalar>&,
      const Vector<Scalar>&)
  {
    return Scalar{0};
  }

  static constexpr bool is_check_acceptable_first(
      Problem&)
  {
    return false;
  }
};

template<typename Problem, typename Scalar>
struct ReparameterizeTrait {
  static bool reparameterize(
      Problem& problem,
      Vector<Scalar>& x,
      Vector<Scalar>& grad)
  {
    return _reparameterize(problem, x, grad);
  }

  private:

  template<typename U,
    typename std::enable_if<!problem_traits<U, Scalar>::has_reparameterize,
      U>::type* = nullptr>
  static constexpr bool _reparameterize(
    U&,
    Vector<Scalar>& x,
    Vector<Scalar>& grad)
  {
    return false;
  }

  template<typename U,
    typename std::enable_if<problem_traits<U, Scalar>::has_reparameterize,
    U>::type* = nullptr>
  static constexpr bool _reparameterize(
    U& problem,
    Vector<Scalar>& x,
    Vector<Scalar>& grad)
  {
    return problem.reparameterize(x, grad);
  }
};

}

}