add_decomposable_evaluate_with_gradient_const.hpp

Go to the documentation of this file.

#ifndef MLPACK_CORE_OPTIMIZERS_ADD_DECOMPOSABLE_EVALUATE_WITH_GRADIENT_CONST_HPP
#define MLPACK_CORE_OPTIMIZERS_ADD_DECOMPOSABLE_EVALUATE_WITH_GRADIENT_CONST_HPP

#include <mlpack/prereqs.hpp>
#include "traits.hpp"

namespace mlpack {
namespace optimization {

namespace aux {

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&,
                                                 size_t,
                                                 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, typename... Ts>
using DecomposableGradientStaticForm = void(*)(const arma::mat&,
                                               const size_t,
                                               arma::mat&);

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

template<typename FunctionType>
using DecomposableEvaluateWithGradientConstForm =
    void(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);

} // namespace aux

template<typename FunctionType,
         bool HasDecomposableEvaluate =
             aux::HasEvaluate<FunctionType,
                 aux::DecomposableEvaluateForm>::value ||
             aux::HasEvaluate<FunctionType,
                 aux::DecomposableEvaluateConstForm>::value ||
             aux::HasEvaluate<FunctionType,
                 aux::DecomposableEvaluateStaticForm>::value,
         bool HasGradient =
             aux::HasGradient<FunctionType,
                 aux::DecomposableGradientForm>::value ||
             aux::HasGradient<FunctionType,
                 aux::DecomposableGradientConstForm>::value ||
             aux::HasGradient<FunctionType,
                 aux::DecomposableGradientStaticForm>::value,
         bool HasEvaluateWithGradient =
             aux::HasEvaluateWithGradient<FunctionType,
                 aux::DecomposableEvaluateWithGradientForm>::value ||
             aux::HasEvaluateWithGradient<FunctionType,
                 aux::DecomposableEvaluateWithGradientConstForm>::value ||
             aux::HasEvaluateWithGradient<FunctionType,
                 aux::DecomposableEvaluateWithGradientStaticForm>::value>
class AddDecomposableEvaluateWithGradient : public FunctionType { };

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

template<typename FunctionType>
class AddDecomposableEvaluateWithGradient<FunctionType, false, true, true> :
    public FunctionType
{
 public:
  double Evaluate(const arma::mat& coordinates,
                  const size_t begin,
                  const size_t batchSize)
  {
    arma::mat gradient; // This will be ignored.
    return FunctionType::EvaluateWithGradient(coordinates, begin, gradient,
        batchSize);
  }
};

template<typename FunctionType>
class AddDecomposableEvaluateWithGradient<FunctionType, true, false, true> :
      public FunctionType
{
 public:
  void Gradient(const arma::mat& coordinates,
                const size_t begin,
                arma::mat& gradient,
                const size_t batchSize)
  {
    // The returned objective value will be ignored.
    (void) FunctionType::EvaluateWithGradient(coordinates, begin, gradient,
        batchSize);
  }
};

} // namespace optimization
} // namespace mlpack

#endif