add_decomposable_gradient.hpp

Go to the documentation of this file.

#ifndef MLPACK_CORE_OPTIMIZERS_FUNCTION_ADD_DECOMPOSABLE_GRADIENT_HPP
#define MLPACK_CORE_OPTIMIZERS_FUNCTION_ADD_DECOMPOSABLE_GRADIENT_HPP

#include "traits.hpp"

namespace mlpack {
namespace optimization {

template<typename FunctionType,
         bool HasDecomposableEvaluateWithGradient =
             traits::HasEvaluateWithGradient<FunctionType,
                 traits::DecomposableEvaluateWithGradientForm>::value,
         bool HasDecomposableGradient =
             traits::HasGradient<FunctionType,
                 traits::DecomposableGradientForm>::value>
class AddDecomposableGradient
{
 public:
  // Provide a dummy overload so the name 'Gradient' exists for this object.
  void Gradient(traits::UnconstructableType&, const size_t, const size_t);
};

template<typename FunctionType, bool HasDecomposableEvaluateWithGradient>
class AddDecomposableGradient<FunctionType, HasDecomposableEvaluateWithGradient,
    true>
{
 public:
  // Reflect the existing Gradient().
  void Gradient(const arma::mat& coordinates,
                const size_t begin,
                arma::mat& gradient,
                const size_t batchSize)
  {
    static_cast<FunctionType*>(
        static_cast<Function<FunctionType>*>(this))->Gradient(coordinates,
        begin, gradient, batchSize);
  }
};

template<typename FunctionType>
class AddDecomposableGradient<FunctionType, true, false>
{
 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) static_cast<Function<FunctionType>*>(this)->EvaluateWithGradient(
        coordinates, begin, gradient, batchSize);
  }
};

template<typename FunctionType,
         bool HasDecomposableEvaluateWithGradient =
             traits::HasEvaluateWithGradient<FunctionType,
                 traits::DecomposableEvaluateWithGradientConstForm>::value,
         bool HasDecomposableGradient =
             traits::HasGradient<FunctionType,
                 traits::DecomposableGradientConstForm>::value>
class AddDecomposableGradientConst
{
 public:
  // Provide a dummy overload so the name 'Gradient' exists for this object.
  void Gradient(traits::UnconstructableType&, const size_t, const size_t) const;
};

template<typename FunctionType, bool HasDecomposableEvaluateWithGradient>
class AddDecomposableGradientConst<FunctionType,
    HasDecomposableEvaluateWithGradient, true>
{
 public:
  // Reflect the existing Gradient().
  void Gradient(const arma::mat& coordinates,
                const size_t begin,
                arma::mat& gradient,
                const size_t batchSize) const
  {
    static_cast<const FunctionType*>(
        static_cast<const Function<FunctionType>*>(this))->Gradient(coordinates,
        begin, gradient, batchSize);
  }
};

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

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

template<typename FunctionType, bool HasDecomposableEvaluateWithGradient>
class AddDecomposableGradientStatic<FunctionType,
    HasDecomposableEvaluateWithGradient, true>
{
 public:
  // Reflect the existing Gradient().
  static void Gradient(const arma::mat& coordinates,
                       const size_t begin,
                       arma::mat& gradient,
                       const size_t batchSize)
  {
    FunctionType::Gradient(coordinates, begin, gradient, batchSize);
  }
};

template<typename FunctionType>
class AddDecomposableGradientStatic<FunctionType, true, false>
{
 public:
  static 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