traits.hpp

Go to the documentation of this file.

#ifndef MLPACK_CORE_OPTIMIZERS_FUNCTION_TRAITS_HPP
#define MLPACK_CORE_OPTIMIZERS_FUNCTION_TRAITS_HPP

#include <mlpack/prereqs.hpp>
#include <mlpack/core/util/sfinae_utility.hpp>

namespace mlpack {
namespace optimization {
namespace traits {

HAS_EXACT_METHOD_FORM(Evaluate, HasEvaluate);
HAS_EXACT_METHOD_FORM(Gradient, HasGradient);
HAS_EXACT_METHOD_FORM(EvaluateWithGradient, HasEvaluateWithGradient);
HAS_EXACT_METHOD_FORM(NumFunctions, HasNumFunctions);
HAS_EXACT_METHOD_FORM(Shuffle, HasShuffle);
HAS_EXACT_METHOD_FORM(NumConstraints, HasNumConstraints);
HAS_EXACT_METHOD_FORM(EvaluateConstraint, HasEvaluateConstraint);
HAS_EXACT_METHOD_FORM(GradientConstraint, HasGradientConstraint);
HAS_EXACT_METHOD_FORM(NumFeatures, HasNumFeatures);
HAS_EXACT_METHOD_FORM(PartialGradient, HasPartialGradient);

template<typename FunctionType>
using EvaluateForm = double(FunctionType::*)(const arma::mat&);

template<typename FunctionType>
using EvaluateConstForm =
    double(FunctionType::*)(const arma::mat&) const;

template<typename FunctionType>
using EvaluateStaticForm = double(*)(const arma::mat&);

template<typename FunctionType>
using GradientForm = void(FunctionType::*)(const arma::mat&, arma::mat&);

template<typename FunctionType>
using GradientConstForm =
    void(FunctionType::*)(const arma::mat&, arma::mat&) const;

template<typename FunctionType>
using GradientStaticForm = void(*)(const arma::mat&, arma::mat&);

template<typename FunctionType>
using EvaluateWithGradientForm =
    double(FunctionType::*)(const arma::mat&, arma::mat&);

template<typename FunctionType>
using EvaluateWithGradientConstForm =
    double(FunctionType::*)(const arma::mat&, arma::mat&) const;

template<typename FunctionType>
using EvaluateWithGradientStaticForm =
    double(*)(const arma::mat&, arma::mat&);

template <typename FunctionType>
using NumFunctionsForm = size_t(FunctionType::*)();

template <typename FunctionType>
using NumFunctionsConstForm = size_t(FunctionType::*)() const;

template<typename FunctionType>
using NumFunctionsStaticForm = size_t(*)();

template<typename FunctionType>
using ShuffleForm = void(FunctionType::*)();

template<typename FunctionType>
using ShuffleConstForm = void(FunctionType::*)() const;

template<typename FunctionType>
using ShuffleStaticForm = void(*)();

template<typename FunctionType>
using DecomposableEvaluateForm = double(FunctionType::*)(
    const arma::mat&, const size_t, const size_t);

template<typename FunctionType>
using DecomposableEvaluateConstForm = double(FunctionType::*)(
    const arma::mat&, const size_t, const size_t) const;

template<typename FunctionType>
using DecomposableEvaluateStaticForm = double(*)(
    const arma::mat&, const size_t, const size_t);

template<typename FunctionType>
using DecomposableGradientForm = void(FunctionType::*)(
    const arma::mat&, const size_t, arma::mat&, const size_t);

template<typename FunctionType>
using DecomposableGradientConstForm = void(FunctionType::*)(
    const arma::mat&, const size_t, arma::mat&, const size_t) const;

template<typename FunctionType>
using DecomposableGradientStaticForm = void(*)(
    const arma::mat&, const size_t, arma::mat&, const size_t);

template<typename FunctionType>
using DecomposableEvaluateWithGradientForm = double(FunctionType::*)(
    const arma::mat&, const size_t, arma::mat&, const size_t);

template<typename FunctionType>
using DecomposableEvaluateWithGradientConstForm = double(FunctionType::*)(
    const arma::mat&, const size_t, arma::mat&, const size_t) const;

template<typename FunctionType>
using DecomposableEvaluateWithGradientStaticForm = double(*)(
    const arma::mat&, const size_t, arma::mat&, const size_t);

template<typename FunctionType>
using NumConstraintsForm = size_t(FunctionType::*)();

template<typename FunctionType>
using NumConstraintsConstForm = size_t(FunctionType::*)() const;

template<typename FunctionType>
using NumConstraintsStaticForm = size_t(*)();

template <typename FunctionType>
using EvaluateConstraintForm = double(FunctionType::*)(
    const size_t, const arma::mat&);

template<typename FunctionType>
using EvaluateConstraintConstForm = double(FunctionType::*)(
    const size_t, const arma::mat&) const;

template<typename FunctionType>
using EvaluateConstraintStaticForm = double(*)(const size_t, const arma::mat&);

template <typename FunctionType>
using GradientConstraintForm = void(FunctionType::*)(
    const size_t, const arma::mat&, arma::mat&);

template<typename FunctionType>
using GradientConstraintConstForm = void(FunctionType::*)(
    const size_t, const arma::mat&, arma::mat&) const;

template<typename Class, typename... Ts>
using GradientConstraintStaticForm = void(*)(
    const size_t, const arma::mat&, arma::mat&);

template<typename FunctionType>
using SparseGradientForm = void(FunctionType::*)(
    const arma::mat&, const size_t, arma::sp_mat&, const size_t);

template<typename FunctionType>
using SparseGradientConstForm = void(FunctionType::*)(
    const arma::mat&, const size_t, arma::sp_mat&, const size_t) const;

template<typename FunctionType>
using SparseGradientStaticForm = void(*)(
    const arma::mat&, const size_t, arma::sp_mat&, const size_t);

template<typename FunctionType>
using NumFeaturesForm = size_t(FunctionType::*)();

template<typename FunctionType>
using NumFeaturesConstForm = size_t(FunctionType::*)() const;

template<typename FunctionType>
using NumFeaturesStaticForm = size_t(*)();

template<typename FunctionType>
using PartialGradientForm = void(FunctionType::*)(
    const arma::mat&, const size_t, arma::sp_mat&);

template<typename FunctionType>
using PartialGradientConstForm = void(FunctionType::*)(
    const arma::mat&, const size_t, arma::sp_mat&) const;

template<typename FunctionType>
using PartialGradientStaticForm = void(*)(
    const arma::mat&, const size_t, arma::sp_mat&);

template<typename FunctionType, typename... Ts>
using OtherForm = double(FunctionType::*)(Ts...);

template<typename FunctionType, typename... Ts>
using OtherConstForm = double(FunctionType::*)(Ts...) const;

template<typename FunctionType, typename... Ts>
using OtherStaticForm = double(*)(Ts...);

struct UnconstructableType
{
 private:
  UnconstructableType() { }
};

template<typename ClassType,
         template<typename, template<typename...> class, size_t> class CheckerA,
         template<typename...> class SignatureA,
         template<typename...> class ConstSignatureA,
         template<typename...> class StaticSignatureA,
         template<typename, template<typename...> class, size_t> class CheckerB,
         template<typename...> class SignatureB,
         template<typename...> class ConstSignatureB,
         template<typename...> class StaticSignatureB>
struct HasNonConstSignatures
{
  // Check if any const or static version of method A exists.
  const static bool HasAnyFormA =
      CheckerA<ClassType, SignatureA, 0>::value ||
      CheckerA<ClassType, ConstSignatureA, 0>::value ||
      CheckerA<ClassType, StaticSignatureA, 0>::value;
  // Check if any const or static versino of method B exists.
  const static bool HasAnyFormB =
      CheckerB<ClassType, SignatureB, 0>::value ||
      CheckerB<ClassType, ConstSignatureB, 0>::value ||
      CheckerB<ClassType, StaticSignatureB, 0>::value;

  // Make sure at least one const version exists.
  const static bool HasEitherNonConstForm =
      CheckerA<ClassType, SignatureA, 0>::value ||
      CheckerB<ClassType, SignatureB, 0>::value;

  const static bool value = HasEitherNonConstForm && HasAnyFormA && HasAnyFormB;
};

template<typename ClassType,
         template<typename, template<typename...> class, size_t> class CheckerA,
         template<typename...> class ConstSignatureA,
         template<typename...> class StaticSignatureA,
         template<typename, template<typename...> class, size_t> class CheckerB,
         template<typename...> class ConstSignatureB,
         template<typename...> class StaticSignatureB>
struct HasConstSignatures
{
  // Check if any const or static version of method A exists.
  const static bool HasAnyFormA =
      CheckerA<ClassType, ConstSignatureA, 0>::value ||
      CheckerA<ClassType, StaticSignatureA, 0>::value;
  // Check if any const or static version of method B exists.
  const static bool HasAnyFormB =
      CheckerB<ClassType, ConstSignatureB, 0>::value ||
      CheckerB<ClassType, StaticSignatureB, 0>::value;

  // Make sure at least one const version exists.
  const static bool HasEitherConstForm =
      CheckerA<ClassType, ConstSignatureA, 0>::value ||
      CheckerB<ClassType, ConstSignatureB, 0>::value;

  const static bool value = HasEitherConstForm && HasAnyFormA && HasAnyFormB;
};

} // namespace traits
} // namespace optimization
} // namespace mlpack

#endif