Refactor problems to avoid adding extra template parameters.

Author: rcurtin

include/ensmallen_bits/problems/aug_lagrangian_test_functions.hpp

@@ -56,43 +56,40 @@ class AugLagrangianTestFunction
  * The minimum that satisfies the two constraints is given as
  *   x = [0.12288, -1.1078, 0.015100], with an objective value of about 29.634.
  */
-template<typename MatType = arma::mat>
-class GockenbachFunctionType
+class GockenbachFunction
 {
  public:
-  GockenbachFunctionType();
-  GockenbachFunctionType(const MatType& initialPoint);
+  GockenbachFunction();
+  GockenbachFunction(const arma::mat& initialPoint);
 
-  template<typename InputMatType>
-  typename InputMatType::elem_type Evaluate(const InputMatType& coordinates);
+  template<typename MatType>
+  typename MatType::elem_type Evaluate(const MatType& coordinates);
 
-  template<typename InputMatType, typename InputGradType>
-  void Gradient(const InputMatType& coordinates, InputGradType& gradient);
+  template<typename MatType, typename GradType>
+  void Gradient(const MatType& coordinates, GradType& gradient);
 
   size_t NumConstraints() const { return 2; }
 
-  template<typename InputMatType>
-  typename InputMatType::elem_type EvaluateConstraint(
+  template<typename MatType>
+  typename MatType::elem_type EvaluateConstraint(
       const size_t index,
-      const InputMatType& coordinates);
+      const MatType& coordinates);
 
-  template<typename InputMatType, typename InputGradType>
+  template<typename MatType, typename GradType>
   void GradientConstraint(const size_t index,
-                          const InputMatType& coordinates,
-                          InputGradType& gradient);
+                          const MatType& coordinates,
+                          GradType& gradient);
 
-  template<typename InputMatType>
-  InputMatType GetInitialPoint() const
+  template<typename MatType>
+  MatType GetInitialPoint() const
   {
-    return conv_to<InputMatType>::from(initialPoint);
+    return arma::conv_to<MatType>::from(initialPoint);
   }
 
  private:
-  MatType initialPoint;
+  arma::mat initialPoint;
 };
 
-using GockenbachFunction = GockenbachFunctionType<arma::mat>;
-
 /**
  * This function is the Lovasz-Theta semidefinite program, as implemented in the
  * following paper:

include/ensmallen_bits/problems/aug_lagrangian_test_functions_impl.hpp

@@ -82,36 +82,32 @@ inline void AugLagrangianTestFunction::GradientConstraint(const size_t index,
 //
 // GockenbachFunction
 //
-template<typename MatType>
-GockenbachFunctionType<MatType>::GockenbachFunctionType()
+inline GockenbachFunction::GockenbachFunction()
 {
   // Set the initial point to (0, 0, 1).
   initialPoint.zeros(3, 1);
   initialPoint[2] = 1;
 }
 
-template<typename MatType>
-GockenbachFunctionType<MatType>::GockenbachFunctionType(const MatType& initialPoint) :
+inline GockenbachFunction::GockenbachFunction(const arma::mat& initialPoint) :
     initialPoint(initialPoint)
 {
   // Nothing to do.
 }
 
 template<typename MatType>
-template<typename InputMatType>
-typename InputMatType::elem_type GockenbachFunctionType<MatType>::Evaluate(
-    const InputMatType& coordinates)
+inline typename MatType::elem_type GockenbachFunction::Evaluate(
+    const MatType& coordinates)
 {
   // f(x) = (x_1 - 1)^2 + 2 (x_2 + 2)^2 + 3(x_3 + 3)^2
   return ((std::pow(coordinates[0] - 1, 2)) +
           (2 * std::pow(coordinates[1] + 2, 2)) +
           (3 * std::pow(coordinates[2] + 3, 2)));
 }
 
-template<typename MatType>
-template<typename InputMatType, typename InputGradType>
-void GockenbachFunctionType<MatType>::Gradient(
-    const InputMatType& coordinates, InputGradType& gradient)
+template<typename MatType, typename GradType>
+inline void GockenbachFunction::Gradient(const MatType& coordinates,
+                                         GradType& gradient)
 {
   // f'_x1(x) = 2 (x_1 - 1)
   // f'_x2(x) = 4 (x_2 + 2)
@@ -124,35 +120,35 @@ void GockenbachFunctionType<MatType>::Gradient(
 }
 
 template<typename MatType>
-template<typename InputMatType>
-typename InputMatType::elem_type GockenbachFunctionType<MatType>::EvaluateConstraint(
-    const size_t index, const InputMatType& coordinates)
+inline typename MatType::elem_type GockenbachFunction::EvaluateConstraint(
+    const size_t index,
+    const MatType& coordinates)
 {
-  typename InputMatType::elem_type constraint = 0;
+  typename MatType::elem_type constraint = 0;
 
   switch (index)
   {
     case 0: // g(x) = (x_3 - x_2 - x_1 - 1) = 0
       constraint = (coordinates[2] - coordinates[1] - coordinates[0] -
-          typename InputMatType::elem_type(1));
+          typename MatType::elem_type(1));
       break;
 
     case 1: // h(x) = (x_3 - x_1^2) >= 0
       // To deal with the inequality, the constraint will simply evaluate to 0
       // when h(x) >= 0.
-      constraint = std::min(typename InputMatType::elem_type(0), (coordinates[2] -
-          std::pow(coordinates[0], typename InputMatType::elem_type(2))));
+      constraint = std::min(typename MatType::elem_type(0), (coordinates[2] -
+          std::pow(coordinates[0], typename MatType::elem_type(2))));
       break;
   }
 
   // 0 will be returned for an invalid index (but this is okay).
   return constraint;
 }
 
-template<typename MatType>
-template<typename InputMatType, typename InputGradType>
-void GockenbachFunctionType<MatType>::GradientConstraint(
-    const size_t index, const InputMatType& coordinates, InputGradType& gradient)
+template<typename MatType, typename GradType>
+inline void GockenbachFunction::GradientConstraint(const size_t index,
+                                                   const MatType& coordinates,
+                                                   GradType& gradient)
 {
   gradient.zeros(3, 1);
 
@@ -339,7 +335,8 @@ inline const arma::mat& LovaszThetaSDP::GetInitialPoint()
     for (size_t j = 0; j < (size_t) vertices; j++)
     {
       if (i == j)
-        initialPoint(i, j) = std::sqrt(1.0 / r) + std::sqrt(1.0 / (vertices * m));
+        initialPoint(i, j) = std::sqrt(1.0 / r) +
+            std::sqrt(1.0 / (vertices * m));
       else
         initialPoint(i, j) = std::sqrt(1.0 / (vertices * m));
     }

include/ensmallen_bits/problems/generalized_rosenbrock_function.hpp

@@ -42,18 +42,15 @@ namespace test {
  * }
  * @endcode
  */
-template<
-    typename MatType = arma::mat,
-    typename LabelsType = typename ForwardType<MatType>::urowvec>
-class GeneralizedRosenbrockFunctionType
+class GeneralizedRosenbrockFunction
 {
  public:
   /*
    * Initialize the GeneralizedRosenbrockFunction.
    *
    * @param n Number of dimensions for the function.
    */
-  GeneralizedRosenbrockFunctionType(const size_t n);
+  GeneralizedRosenbrockFunction(const size_t n);
 
   /**
    * Shuffle the order of function visitation. This may be called by the
@@ -71,6 +68,7 @@ class GeneralizedRosenbrockFunctionType
    * @param begin The first function.
    * @param batchSize Number of points to process.
    */
+  template<typename MatType>
   typename MatType::elem_type Evaluate(const MatType& coordinates,
                                        const size_t begin,
                                        const size_t batchSize = 1) const;
@@ -80,6 +78,7 @@ class GeneralizedRosenbrockFunctionType
    *
    * @param coordinates The function coordinates.
    */
+  template<typename MatType>
   typename MatType::elem_type Evaluate(const MatType& coordinates) const;
 
   /**
@@ -90,7 +89,7 @@ class GeneralizedRosenbrockFunctionType
    * @param gradient The function gradient.
    * @param batchSize Number of points to process.
    */
-  template<typename GradType>
+  template<typename MatType, typename GradType>
   void Gradient(const MatType& coordinates,
                 const size_t begin,
                 GradType& gradient,
@@ -102,7 +101,7 @@ class GeneralizedRosenbrockFunctionType
    * @param coordinates The function coordinates.
    * @param gradient The function gradient.
    */
-  template<typename GradType>
+  template<typename MatType, typename GradType>
   void Gradient(const MatType& coordinates, GradType& gradient) const;
 
   // Note: GetInitialPoint(), GetFinalPoint(), and GetFinalObjective() are not
@@ -111,38 +110,33 @@ class GeneralizedRosenbrockFunctionType
   // infrastructure.
 
   //! Get the starting point.
-  template<typename InputMatType = MatType>
-  const InputMatType GetInitialPoint() const
+  template<typename MatType = arma::mat>
+  const MatType GetInitialPoint() const
   {
-    return conv_to<InputMatType>::from(initialPoint);
+    return arma::conv_to<MatType>::from(initialPoint);
   }
 
   //! Get the final point.
-  template<typename InputMatType = MatType>
-  const InputMatType GetFinalPoint() const
+  template<typename MatType = arma::mat>
+  const MatType GetFinalPoint() const
   {
-    InputMatType finalPoint(initialPoint.n_rows, initialPoint.n_cols);
-    finalPoint.ones();
-    return finalPoint;
+    return arma::ones<MatType>(initialPoint.n_rows, initialPoint.n_cols);
   }
 
   //! Get the final objective.
   double GetFinalObjective() const { return 0.0; }
 
  private:
   //! Locally-stored Initial point.
-  MatType initialPoint;
+  arma::mat initialPoint;
 
-  //! Number of dimensions for the function.
+  //! //! Number of dimensions for the function.
   size_t n;
 
   //! For shuffling.
-  LabelsType visitationOrder;
+  arma::Row<size_t> visitationOrder;
 };
 
-using GeneralizedRosenbrockFunction = GeneralizedRosenbrockFunctionType<
-    arma::mat>;
-
 } // namespace test
 } // namespace ens
 

include/ensmallen_bits/problems/generalized_rosenbrock_function_impl.hpp

@@ -19,12 +19,10 @@
 namespace ens {
 namespace test {
 
-template<typename MatType, typename LabelsType>
-GeneralizedRosenbrockFunctionType<
-    MatType, LabelsType>::GeneralizedRosenbrockFunctionType(
+inline GeneralizedRosenbrockFunction::GeneralizedRosenbrockFunction(
     const size_t n) :
     n(n),
-    visitationOrder(linspace<LabelsType>(0, n - 1, n))
+    visitationOrder(arma::linspace<arma::Row<size_t> >(0, n - 1, n))
 
 {
   initialPoint.set_size(n, 1);
@@ -41,15 +39,14 @@ GeneralizedRosenbrockFunctionType<
   }
 }
 
-template<typename MatType, typename LabelsType>
-void GeneralizedRosenbrockFunctionType<MatType, LabelsType>::Shuffle()
+inline void GeneralizedRosenbrockFunction::Shuffle()
 {
-  visitationOrder = shuffle(linspace<LabelsType>(0, n - 2, n - 1));
+  visitationOrder = arma::shuffle(arma::linspace<arma::Row<size_t>>(0, n - 2,
+      n - 1));
 }
 
-template<typename MatType, typename LabelsType>
-typename MatType::elem_type GeneralizedRosenbrockFunctionType<
-    MatType, LabelsType>::Evaluate(
+template<typename MatType>
+typename MatType::elem_type GeneralizedRosenbrockFunction::Evaluate(
     const MatType& coordinates,
     const size_t begin,
     const size_t batchSize) const
@@ -65,9 +62,8 @@ typename MatType::elem_type GeneralizedRosenbrockFunctionType<
   return objective;
 }
 
-template<typename MatType, typename LabelsType>
-typename MatType::elem_type GeneralizedRosenbrockFunctionType<
-    MatType, LabelsType>::Evaluate(
+template<typename MatType>
+typename MatType::elem_type GeneralizedRosenbrockFunction::Evaluate(
     const MatType& coordinates) const
 {
   typename MatType::elem_type fval = 0;
@@ -80,9 +76,8 @@ typename MatType::elem_type GeneralizedRosenbrockFunctionType<
   return fval;
 }
 
-template<typename MatType, typename LabelsType>
-template<typename GradType>
-void GeneralizedRosenbrockFunctionType<MatType, LabelsType>::Gradient(
+template<typename MatType, typename GradType>
+inline void GeneralizedRosenbrockFunction::Gradient(
     const MatType& coordinates,
     const size_t begin,
     GradType& gradient,
@@ -98,9 +93,8 @@ void GeneralizedRosenbrockFunctionType<MatType, LabelsType>::Gradient(
   }
 }
 
-template<typename MatType, typename LabelsType>
-template<typename GradType>
-void GeneralizedRosenbrockFunctionType<MatType, LabelsType>::Gradient(
+template<typename MatType, typename GradType>
+inline void GeneralizedRosenbrockFunction::Gradient(
     const MatType& coordinates,
     GradType& gradient) const
 {