add_decomposable_evaluate_with_gradient.hpp

Go to the documentation of this file.

#ifndef MLPACK_CORE_OPTIMIZERS_FUNCTION_ADD_DECOMPOSABLE_EVALUATE_W_GRADIENT_HPP
#define MLPACK_CORE_OPTIMIZERS_FUNCTION_ADD_DECOMPOSABLE_EVALUATE_W_GRADIENT_HPP

#include "traits.hpp"

namespace mlpack {
namespace optimization {

template<typename FunctionType,
         // Check if there is at least one non-const Evaluate() or Gradient().
         bool HasDecomposableEvaluateGradient = traits::HasNonConstSignatures<
             FunctionType,
             traits::HasEvaluate,
             traits::DecomposableEvaluateForm,
             traits::DecomposableEvaluateConstForm,
             traits::DecomposableEvaluateStaticForm,
             traits::HasGradient,
             traits::DecomposableGradientForm,
             traits::DecomposableGradientConstForm,
             traits::DecomposableGradientStaticForm>::value,
         bool HasDecomposableEvaluateWithGradient =
             traits::HasEvaluateWithGradient<FunctionType,
                 traits::DecomposableEvaluateWithGradientForm>::value>
class AddDecomposableEvaluateWithGradient
{
 public:
  // Provide a dummy overload so the name 'EvaluateWithGradient' exists for this
  // object.
  double EvaluateWithGradient(traits::UnconstructableType&, const size_t,
      const size_t);
};

template<typename FunctionType, bool HasDecomposableEvaluateGradient>
class AddDecomposableEvaluateWithGradient<FunctionType,
    HasDecomposableEvaluateGradient, true>
{
 public:
  // Reflect the existing Evaluate().
  double EvaluateWithGradient(const arma::mat& coordinates,
                              const size_t begin,
                              arma::mat& gradient,
                              const size_t batchSize)
  {
    return static_cast<FunctionType*>(
        static_cast<Function<FunctionType>*>(this))->EvaluateWithGradient(
        coordinates, begin, gradient, batchSize);
  }
};

template<typename FunctionType>
class AddDecomposableEvaluateWithGradient<FunctionType, true, false>
{
 public:
  double EvaluateWithGradient(const arma::mat& coordinates,
                              const size_t begin,
                              arma::mat& gradient,
                              const size_t batchSize)
  {
    const double objective =
        static_cast<Function<FunctionType>*>(this)->Evaluate(coordinates, begin,
        batchSize);
    static_cast<Function<FunctionType>*>(this)->Gradient(coordinates, begin,
        gradient, batchSize);
    return objective;
  }
};

template<typename FunctionType,
         // Check if there is at least one const Evaluate() or Gradient().
         bool HasDecomposableEvaluateGradient = traits::HasConstSignatures<
             FunctionType,
             traits::HasEvaluate,
             traits::DecomposableEvaluateConstForm,
             traits::DecomposableEvaluateStaticForm,
             traits::HasGradient,
             traits::DecomposableGradientConstForm,
             traits::DecomposableGradientStaticForm>::value,
         bool HasDecomposableEvaluateWithGradient =
             traits::HasEvaluateWithGradient<FunctionType,
                 traits::DecomposableEvaluateWithGradientConstForm>::value>
class AddDecomposableEvaluateWithGradientConst
{
 public:
  // Provide a dummy overload so the name 'EvaluateWithGradient' exists for this
  // object.
  double EvaluateWithGradient(traits::UnconstructableType&, const size_t,
      const size_t) const;
};

template<typename FunctionType, bool HasDecomposableEvaluateGradient>
class AddDecomposableEvaluateWithGradientConst<FunctionType,
    HasDecomposableEvaluateGradient, true>
{
 public:
  // Reflect the existing Evaluate().
  double EvaluateWithGradient(const arma::mat& coordinates,
                              const size_t begin,
                              arma::mat& gradient,
                              const size_t batchSize) const
  {
    return static_cast<const FunctionType*>(
        static_cast<const Function<FunctionType>*>(this))->EvaluateWithGradient(
        coordinates, begin, gradient, batchSize);
  }
};

template<typename FunctionType>
class AddDecomposableEvaluateWithGradientConst<FunctionType, true, false>
{
 public:
  double EvaluateWithGradient(const arma::mat& coordinates,
                              const size_t begin,
                              arma::mat& gradient,
                              const size_t batchSize) const
  {
    const double objective =
        static_cast<const Function<FunctionType>*>(this)->Evaluate(coordinates,
        begin, batchSize);
    static_cast<const Function<FunctionType>*>(this)->Gradient(coordinates,
        begin, gradient, batchSize);
    return objective;
  }
};

template<typename FunctionType,
         bool HasDecomposableEvaluateGradient =
             traits::HasEvaluate<FunctionType,
                 traits::DecomposableEvaluateStaticForm>::value &&
             traits::HasGradient<FunctionType,
                 traits::DecomposableGradientStaticForm>::value,
         bool HasDecomposableEvaluateWithGradient =
             traits::HasEvaluateWithGradient<FunctionType,
                 traits::DecomposableEvaluateWithGradientStaticForm>::value>
class AddDecomposableEvaluateWithGradientStatic
{
 public:
  // Provide a dummy overload so the name 'EvaluateWithGradient' exists for this
  // object.
  static double EvaluateWithGradient(traits::UnconstructableType&, const size_t,
      const size_t);
};

template<typename FunctionType, bool HasDecomposableEvaluateGradient>
class AddDecomposableEvaluateWithGradientStatic<FunctionType,
    HasDecomposableEvaluateGradient, true>
{
 public:
  // Reflect the existing Evaluate().
  static double EvaluateWithGradient(const arma::mat& coordinates,
                                     const size_t begin,
                                     arma::mat& gradient,
                                     const size_t batchSize)
  {
    return FunctionType::EvaluateWithGradient(coordinates, begin, gradient,
        batchSize);
  }
};

template<typename FunctionType>
class AddDecomposableEvaluateWithGradientStatic<FunctionType, true, false>
{
 public:
  double EvaluateWithGradient(const arma::mat& coordinates,
                              const size_t begin,
                              arma::mat& gradient,
                              const size_t batchSize) const
  {
    const double objective = FunctionType::Evaluate(coordinates, begin,
        batchSize);
    FunctionType::Gradient(coordinates, begin, gradient, batchSize);
    return objective;
  }
};

} // namespace optimization
} // namespace mlpack

#endif