Merge Bandicoot tests with other tests

.appveyor.yml

@@ -33,6 +33,7 @@ build_script:
     -DLAPACK_LIBRARY:FILEPATH=%BLAS_LIBRARY%
     -DCMAKE_PREFIX:FILEPATH="%APPVEYOR_BUILD_FOLDER%/armadillo"
     -DBUILD_SHARED_LIBS=OFF
+    -DCMAKE_POLICY_VERSION_MINIMUM=3.5
     -DCMAKE_BUILD_TYPE=Release ..
   - >
     "%MSBUILD%" "armadillo.sln"
@@ -47,6 +48,7 @@ build_script:
     -DARMADILLO_LIBRARIES=%BLAS_LIBRARY%
     -DLAPACK_LIBRARY=%BLAS_LIBRARY%
     -DBLAS_LIBRARY=%BLAS_LIBRARY%
+    -DCMAKE_POLICY_VERSION_MINIMUM=3.5
     -DCMAKE_BUILD_TYPE=Release ..
   - >
     "%MSBUILD%" "ensmallen.sln"

include/ensmallen_bits/ens_version.hpp

@@ -12,16 +12,16 @@
 
 // This follows the Semantic Versioning pattern defined in https://semver.org/.
 
-#define ENS_VERSION_MAJOR 2
+#define ENS_VERSION_MAJOR 3
 // The minor version is two digits so regular numerical comparisons of versions
 // work right.  The first minor version of a release is always 10.
-#define ENS_VERSION_MINOR 22
-#define ENS_VERSION_PATCH 2
+#define ENS_VERSION_MINOR 10
+#define ENS_VERSION_PATCH 0
 // If this is a release candidate, it will be reflected in the version name
 // (i.e. the version name will be "RC1", "RC2", etc.).  Otherwise the version
 // name will typically be a seemingly arbitrary set of words that does not
 // contain the capitalized string "RC".
-#define ENS_VERSION_NAME "E-Bike Excitement"
+#define ENS_VERSION_NAME "RC1"
 // Incorporate the date the version was released.
 #define ENS_VERSION_YEAR "2025"
 #define ENS_VERSION_MONTH "04"

tests/ada_belief_test.cpp

@@ -20,19 +20,8 @@ using namespace ens;
 using namespace ens::test;
 
 TEMPLATE_TEST_CASE("AdaBelief_LogisticRegressionFunction", "[AdaBelief]",
-    ENS_ALL_TEST_TYPES)
+    ENS_ALL_CPU_TEST_TYPES)
 {
   AdaBelief adaBelief(0.032);
-  LogisticRegressionFunctionTest<TestType, arma::Row<size_t>>(adaBelief);
+  LogisticRegressionFunctionTest<TestType>(adaBelief);
 }
-
-#ifdef ENS_HAVE_COOT
-
-TEMPLATE_TEST_CASE("AdaBelief_LogisticRegressionFunction", "[AdaBelief]",
-    coot::mat, coot::fmat)
-{
-  AdaBelief adaBelief(0.032);
-  LogisticRegressionFunctionTest<TestType, coot::Row<size_t>>(adaBelief);
-}
-
-#endif

tests/ada_bound_test.cpp

@@ -75,23 +75,3 @@ TEMPLATE_TEST_CASE("AMSBound_SphereFunctionSpMatDenseGradient", "[AdaBound]",
   REQUIRE(coordinates(0) == Approx(0.0).margin(0.1));
   REQUIRE(coordinates(1) == Approx(0.0).margin(0.1));
 }
-
-#ifdef ENS_HAVE_COOT
-
-TEMPLATE_TEST_CASE("AdaBound_SphereFunction", "[AdaBound]",
-    coot::mat, coot::fmat)
-{
-  AdaBound optimizer(0.002, 2, 0.1, 1e-3, 0.9, 0.999, 1e-8, 500000,
-      1e-3, false);
-  FunctionTest<SphereFunction, TestType>(optimizer, 0.5, 0.1);
-}
-
-TEMPLATE_TEST_CASE("AMSBoundSphereFunctionTest", "[AdaBound]",
-    coot::mat, coot::fmat)
-{
-  AMSBound optimizer(0.002, 2, 0.1, 1e-3, 0.9, 0.999, 1e-8, 500000,
-      1e-3, false);
-  FunctionTest<SphereFunction, TestType>(optimizer, 0.5, 0.1);
-}
-
-#endif

tests/ada_delta_test.cpp

@@ -30,17 +30,5 @@ TEMPLATE_TEST_CASE("AdaDelta_LogisticRegressionFunction", "[AdaDelta]",
   // Use a large epsilon if we are using FP16, to avoid underflow in the first
   // iterations.
   AdaDelta adaDelta(32.0, 32, 0.95, sizeof(ElemType) == 2 ? 1e-4 : 1e-6);
-  LogisticRegressionFunctionTest<TestType, arma::Row<size_t>>(adaDelta);
+  LogisticRegressionFunctionTest<TestType>(adaDelta);
 }
-
-#ifdef ENS_HAVE_COOT
-
-TEMPLATE_TEST_CASE("AdaDelta_LogisticRegressionFunction", "[AdaDelta]",
-    coot::mat, coot::fmat)
-{
-  AdaDelta adaDelta(32.0);
-  LogisticRegressionFunctionTest<TestType, coot::Row<size_t>>(
-      adaDelta, 0.003, 0.006, 1);
-}
-
-#endif

tests/ada_grad_test.cpp

@@ -25,16 +25,5 @@ TEMPLATE_TEST_CASE("AdaGrad_LogisticRegressionFunction", "[AdaGrad]",
 {
   AdaGrad adagrad(31.5, 32, 10 * Tolerances<TestType>::Obj, 500000,
       Tolerances<TestType>::Obj, true);
-  LogisticRegressionFunctionTest<TestType, arma::Row<size_t>>(adagrad);
+  LogisticRegressionFunctionTest<TestType>(adagrad);
 }
-
-#ifdef ENS_HAVE_COOT
-
-TEMPLATE_TEST_CASE("AdaGrad_LogisticRegressionFunction", "[AdaGrad]",
-    coot::mat, coot::fmat)
-{
-  AdaGrad adagrad(31.5, 32, 1e-8, 500000, 1e-9, true);
-  LogisticRegressionFunctionTest<TestType, coot::Row<size_t>>(adagrad);
-}
-
-#endif

tests/ada_sqrt_test.cpp

@@ -26,21 +26,9 @@ TEMPLATE_TEST_CASE("AdaSqrt_LogisticRegressionFunction", "[AdaSqrt]",
       true);
   // We allow a few trials for lower precision types because AdaSqrt can have
   // trouble converging in that case.
-  LogisticRegressionFunctionTest<TestType, arma::Row<size_t>>(
+  LogisticRegressionFunctionTest<TestType>(
       optimizer,
       Tolerances<TestType>::LRTrainAcc,
       Tolerances<TestType>::LRTestAcc,
       sizeof(typename TestType::elem_type) < 4 ? 5 : 1);
 }
-
-#ifdef ENS_HAVE_COOT
-
-TEMPLATE_TEST_CASE("AdaSqrt_LogisticRegressionFunction", "[AdaSqrt]",
-    coot::mat, coot::fmat)
-{
-  AdaSqrt optimizer(8.0, 32, 1e-8, 150000, 1e-9, true);
-  LogisticRegressionFunctionTest<TestType, coot::Row<size_t>>(
-      optimizer);
-}
-
-#endif

tests/adam_test.cpp

@@ -215,96 +215,3 @@ TEMPLATE_TEST_CASE("Adam_ThreeHumpCamelFunction", "[Adam]", ENS_ALL_TEST_TYPES)
       Tolerances<TestType>::LargeObj,
       Tolerances<TestType>::LargeCoord);
 }
-
-#ifdef ENS_HAVE_COOT
-
-TEMPLATE_TEST_CASE("Adam_SphereFunction", "[Adam]", coot::mat, coot::fmat)
-{
-  Adam optimizer(1.0, 2, 0.7, 0.999, 1e-8, 50000, 1e-3, false);
-  FunctionTest<SphereFunction, TestType>(optimizer, 0.5, 0.2);
-}
-
-TEMPLATE_TEST_CASE("Adam_StyblinskiTangFunction", "[Adam]", coot::mat)
-{
-  Adam optimizer(1.0, 2, 0.7, 0.999, 1e-8, 50000, 1e-3, false);
-  FunctionTest<StyblinskiTangFunction, TestType>(optimizer, 0.5, 0.1);
-}
-
-TEMPLATE_TEST_CASE("Adam_McCormickFunction", "[Adam]", coot::mat)
-{
-  Adam optimizer(0.5, 1, 0.7, 0.999, 1e-8, 50000, 1e-5, false);
-  FunctionTest<McCormickFunction, TestType>(optimizer, 0.5, 0.1);
-}
-
-TEMPLATE_TEST_CASE("Adam_MatyasFunction", "[Adam]", coot::mat)
-{
-  Adam optimizer(0.5, 1, 0.7, 0.999, 1e-8, 50000, 1e-5, false);
-  FunctionTest<MatyasFunction, TestType>(optimizer, 0.1, 0.01);
-}
-
-TEMPLATE_TEST_CASE("Adam_EasomFunction", "[Adam]", coot::mat)
-{
-  Adam optimizer(0.2, 1, 0.7, 0.999, 1e-8, 50000, 1e-5, false);
-  FunctionTest<EasomFunction, TestType>(optimizer, 1.5, 0.01);
-}
-
-TEMPLATE_TEST_CASE("Adam_BoothFunction", "[Adam]", coot::mat)
-{
-  Adam optimizer(1e-1, 1, 0.7, 0.999, 1e-8, 50000, 1e-9, true);
-  FunctionTest<BoothFunction, TestType>(
-      optimizer,
-      50 * Tolerances<TestType>::Obj,
-      10 * Tolerances<TestType>::Coord);
-}
-
-TEMPLATE_TEST_CASE("Adam_LogisticRegressionFunction", "[Adam]", coot::mat)
-{
-  Adam adam(0.032);
-  LogisticRegressionFunctionTest<TestType, coot::Row<size_t>>(adam);
-}
-
-TEMPLATE_TEST_CASE("AdaMax_LogisticRegressionFunction", "[Adam]", coot::mat)
-{
-  AdaMax adamax(0.08, 8, 0.9, 0.999, 1e-8, 50000, 1e-9, true);
-  LogisticRegressionFunctionTest<TestType, coot::Row<size_t>>(adamax);
-}
-
-TEMPLATE_TEST_CASE("AMSGrad_LogisticRegressionFunction", "[Adam]", coot::mat)
-{
-  AMSGrad amsgrad(0.08, 8, 0.9, 0.999, 1e-8, 50000, 1e-11, true);
-  LogisticRegressionFunctionTest<TestType, coot::Row<size_t>>(amsgrad);
-}
-
-TEMPLATE_TEST_CASE("Nadam_LogisticRegressionFunction", "[Adam]", coot::mat)
-{
-  Nadam nadam(0.032);
-  LogisticRegressionFunctionTest<TestType, coot::Row<size_t>>(nadam);
-}
-
-TEMPLATE_TEST_CASE("NadaMax_LogisticRegressionFunction", "[Adam]", coot::mat)
-{
-  NadaMax nadamax(0.08, 8, 0.9, 0.999, 1e-8, 50000, 1e-9, true);
-  LogisticRegressionFunctionTest<TestType, coot::Row<size_t>>(nadamax);
-}
-
-TEMPLATE_TEST_CASE("OptimisticAdam_LogisticRegressionFunction", "[Adam]",
-    coot::mat)
-{
-  OptimisticAdam optimisticAdam(0.032);
-  LogisticRegressionFunctionTest<TestType, coot::Row<size_t>>(optimisticAdam);
-}
-
-TEMPLATE_TEST_CASE("Padam_LogisticRegressionFunction", "[Adam]", coot::mat)
-{
-  Padam optimizer(0.032);
-  LogisticRegressionFunctionTest<TestType, coot::Row<size_t>>(optimizer);
-}
-
-TEMPLATE_TEST_CASE("QHAdam_LogisticRegressionFunction", "[Adam]",
-    coot::mat, coot::fmat)
-{
-  QHAdam optimizer(0.032);
-  LogisticRegressionFunctionTest<TestType, coot::Row<size_t>>(optimizer);
-}
-
-#endif

tests/aug_lagrangian_test.cpp

@@ -28,7 +28,7 @@ using namespace ens::test;
  * AugmentedLagrangianTestFunction class.
  */
 TEMPLATE_TEST_CASE("AugLagrangian_AugLagrangianTestFunction", "[AugLagrangian]",
-    ENS_ALL_TEST_TYPES)
+    ENS_ALL_CPU_TEST_TYPES)
 {
   typedef typename TestType::elem_type ElemType;
 
@@ -92,30 +92,3 @@ TEMPLATE_TEST_CASE("AugLagrangian_GockenbachFunction", "[AugLagrangian]",
   REQUIRE(coords(1) == Approx(-1.10778185).epsilon(coordTol));
   REQUIRE(coords(2) == Approx(0.015099932).epsilon(coordTol));
 }
-
-#ifdef ENS_HAVE_COOT
-
-TEMPLATE_TEST_CASE("AugLagrangian_GockenbachFunction", "[AugLagrangian]",
-    coot::mat, coot::fmat)
-{
-  typedef typename ForwardType<TestType>::bvec BaseVecType;
-  typedef typename TestType::elem_type ElemType;
-
-  GockenbachFunction f;
-  AugLagrangianType<BaseVecType> aug;
-
-  TestType coords = f.template GetInitialPoint<TestType>();
-
-  if (!aug.Optimize(f, coords))
-    FAIL("Optimization reported failure.");
-
-  ElemType finalValue = f.Evaluate(coords);
-
-  // Higher tolerance for smaller values.
-  REQUIRE(finalValue == Approx(29.633926).epsilon(1e-3));
-  REQUIRE(coords(0) == Approx(0.12288178).epsilon(0.1));
-  REQUIRE(coords(1) == Approx(-1.10778185).epsilon(1e-3));
-  REQUIRE(coords(2) == Approx(0.015099932).epsilon(0.1));
-}
-
-#endif

tests/bigbatch_sgd_test.cpp

@@ -27,7 +27,7 @@ TEMPLATE_TEST_CASE("BBS_BB_LogisticRegressionFunction", "[BigBatchSGD]",
   for (size_t batchSize = 350; batchSize < 360; batchSize += 5)
   {
     BBS_BB bbsgd(batchSize, 0.001, 0.1, 10000, 1e-8, true, true);
-    LogisticRegressionFunctionTest<TestType, arma::Row<size_t>>(bbsgd);
+    LogisticRegressionFunctionTest<TestType>(bbsgd);
   }
 }
 
@@ -38,24 +38,6 @@ TEMPLATE_TEST_CASE("BBS_Armijo_LogisticRegressionFunction", "[BigBatchSGD]",
   for (size_t batchSize = 40; batchSize < 50; batchSize += 1)
   {
     BBS_Armijo bbsgd(batchSize, 0.005, 0.1, 10000, 1e-6, true, true);
-    LogisticRegressionFunctionTest<TestType, arma::Row<size_t>>(bbsgd);
+    LogisticRegressionFunctionTest<TestType>(bbsgd);
   }
 }
-
-#ifdef ENS_HAVE_COOT
-
-TEMPLATE_TEST_CASE("BBS_BB_LogisticRegressionFunction", "[BigBatchSGD]",
-    coot::mat, coot::fmat)
-{
-  BBS_BB bbsgd(350, 0.001, 0.1, 10000, 1e-8, true, true);
-  LogisticRegressionFunctionTest<TestType, coot::Row<size_t>>(bbsgd);
-}
-
-TEMPLATE_TEST_CASE("BBS_Armijo_LogisticRegressionFunction", "[BigBatchSGD]",
-    coot::mat, coot::fmat)
-{
-  BBS_Armijo bbsgd(40, 0.005, 0.1, 10000, 1e-6, true, true);
-  LogisticRegressionFunctionTest<TestType, coot::Row<size_t>>(bbsgd);
-}
-
-#endif

tests/cd_test.cpp

@@ -23,7 +23,8 @@ using namespace ens::test;
  * Test the correctness of the CD implementation by using a dataset with a
  * precalculated minima.
  */
-TEMPLATE_TEST_CASE("CD_LogisticRegressionFunction", "[CD]", ENS_ALL_TEST_TYPES)
+TEMPLATE_TEST_CASE("CD_LogisticRegressionFunction", "[CD]",
+    ENS_ALL_CPU_TEST_TYPES)
 {
   typedef typename TestType::elem_type ElemType;
 
@@ -44,7 +45,7 @@ TEMPLATE_TEST_CASE("CD_LogisticRegressionFunction", "[CD]", ENS_ALL_TEST_TYPES)
  * Test the correctness of the CD implemenation by using the sparse test
  * function, with disjoint features which optimize to a precalculated minima.
  */
-TEMPLATE_TEST_CASE("CD_SparseTestFunction", "[CD]", ENS_ALL_TEST_TYPES,
+TEMPLATE_TEST_CASE("CD_SparseTestFunction", "[CD]", ENS_ALL_CPU_TEST_TYPES,
     ENS_SPARSE_TEST_TYPES)
 {
   // The test function for parallel SGD should work with CD, as the gradients

tests/cmaes_test.cpp

@@ -26,7 +26,7 @@ using namespace ens::test;
  * make sure the results are acceptable.
  */
 TEMPLATE_TEST_CASE("CMAES_LogisticRegressionFunction", "[CMAES]",
-    ENS_TEST_TYPES)
+    ENS_FULLPREC_TEST_TYPES)
 {
   BoundaryBoxConstraint<TestType> b(-10, 10);
   CMAES<FullSelection, BoundaryBoxConstraint<TestType>> cmaes(
@@ -62,26 +62,3 @@ TEMPLATE_TEST_CASE("ApproxCMAES_EmptyTransformationLogisticRegressionFunction",
       cmaes(0, EmptyTransformation<TestType>(), 16, 500, 1e-3);
   LogisticRegressionFunctionTest<TestType>(cmaes, 0.01, 0.02, 5);
 }
-
-#ifdef ENS_HAVE_COOT
-
-TEMPLATE_TEST_CASE("CMAES_LogisticRegressionFunction", "[CMAES]", coot::mat)
-{
-  BoundaryBoxConstraint<TestType> b(-10, 10);
-  CMAES<FullSelection, BoundaryBoxConstraint<TestType>> cmaes(
-      0, b, 32, 500, 1e-3);
-  cmaes.StepSize() = 0.6;
-  LogisticRegressionFunctionTest<TestType, coot::Row<size_t>>(
-      cmaes, 0.003, 0.006, 5);
-}
-
-TEMPLATE_TEST_CASE("CMAES_LogisticRegressionFunction", "[CMAES]", coot::fmat)
-{
-  BoundaryBoxConstraint<TestType> b(-10, 10);
-  CMAES<FullSelection, BoundaryBoxConstraint<TestType>> cmaes(
-      120, b, 32, 500, 1e-3);
-  LogisticRegressionFunctionTest<TestType, coot::Row<size_t>>(
-      cmaes, 0.01, 0.02, 5);
-}
-
-#endif