Revert "Change arma::mean to mean in tests"

This reverts commit 32d9a7f7f8.

src/mlpack/tests/ann/activation_functions_test.cpp

@@ -281,8 +281,8 @@ TEST_CASE("SELUFunctionNormalizedTest", "[ActivationFunctionsTest]")
   SELU selu;
   selu.Forward(input, output);
 
-  REQUIRE(arma::as_scalar(arma::abs(mean(input) -
-      mean(output))) <= 0.1);
+  REQUIRE(arma::as_scalar(arma::abs(arma::mean(input) -
+      arma::mean(output))) <= 0.1);
   REQUIRE(arma::as_scalar(arma::abs(arma::var(input) -
       arma::var(output))) <= 0.1);
 }
@@ -300,8 +300,8 @@ TEST_CASE("SELUFunctionUnnormalizedTest", "[ActivationFunctionsTest]")
   SELU selu;
   selu.Forward(input, output);
 
-  REQUIRE(arma::as_scalar(arma::abs(mean(input) -
-      mean(output))) >= 0.1);
+  REQUIRE(arma::as_scalar(arma::abs(arma::mean(input) -
+      arma::mean(output))) >= 0.1);
   REQUIRE(arma::as_scalar(arma::abs(arma::var(input) -
       arma::var(output))) >= 0.1);
 }
@@ -324,7 +324,7 @@ TEST_CASE("SELUFunctionDerivativeTest", "[ActivationFunctionsTest]")
   selu.Forward(input, activations);
   selu.Backward(input, activations, error, derivatives);
   
-  REQUIRE(arma::as_scalar(arma::abs(mean(derivatives) -
+  REQUIRE(arma::as_scalar(arma::abs(arma::mean(derivatives) -
       selu.Lambda())) <= 10e-4);
 
   input.fill(-1);
@@ -332,8 +332,8 @@ TEST_CASE("SELUFunctionDerivativeTest", "[ActivationFunctionsTest]")
   selu.Forward(input, activations);
   selu.Backward(input, activations, error, derivatives);
 
-  REQUIRE(arma::as_scalar(arma::abs(mean(derivatives) -
-      selu.Lambda() * selu.Alpha() - mean(activations))) <= 10e-4);
+  REQUIRE(arma::as_scalar(arma::abs(arma::mean(derivatives) -
+      selu.Lambda() * selu.Alpha() - arma::mean(activations))) <= 10e-4);
 }
 
 /**

src/mlpack/tests/ann/async_learning_test.cpp

@@ -71,7 +71,7 @@ TEST_CASE("OneStepQLearningTest", "[AsyncLearningTest]")
       rewards[pos++] = reward;
       pos %= rewards.n_elem;
       // Maybe underestimated.
-      double avgReward = mean(rewards);
+      double avgReward = arma::mean(rewards);
       Log::Debug << "Average return: " << avgReward
           << " Episode return: " << reward << std::endl;
       if (avgReward > 60)
@@ -82,7 +82,7 @@ TEST_CASE("OneStepQLearningTest", "[AsyncLearningTest]")
     agent.Train(measure);
     Log::Debug << "Total test episodes: " << testEpisodes << std::endl;
 
-    double avgReward = mean(rewards);
+    double avgReward = arma::mean(rewards);
     if (avgReward > 60)
     {
       success = true;
@@ -149,7 +149,7 @@ TEST_CASE("OneStepSarsaTest", "[AsyncLearningTest]")
       rewards[pos++] = reward;
       pos %= rewards.n_elem;
       // Maybe underestimated.
-      double avgReward = mean(rewards);
+      double avgReward = arma::mean(rewards);
       Log::Debug << "Average return: " << avgReward
                  << " Episode return: " << reward << std::endl;
       if (avgReward > 60)
@@ -160,7 +160,7 @@ TEST_CASE("OneStepSarsaTest", "[AsyncLearningTest]")
     agent.Train(measure);
     Log::Debug << "Total test episodes: " << testEpisodes << std::endl;
 
-    double avgReward = mean(rewards);
+    double avgReward = arma::mean(rewards);
     if (avgReward > 60)
     {
       success = true;
@@ -222,7 +222,7 @@ TEST_CASE("NStepQLearningTest", "[AsyncLearningTest]")
     rewards[pos++] = reward;
     pos %= rewards.n_elem;
     // Maybe underestimated.
-    double avgReward = mean(rewards);
+    double avgReward = arma::mean(rewards);
     Log::Debug << "Average return: " << avgReward
                << " Episode return: " << reward << std::endl;
     if (avgReward > 60)

src/mlpack/tests/ann/ksinit_test.cpp

@@ -85,11 +85,11 @@ void BuildVanillaNetwork(MatType& trainData,
 
   // Calculating the mean squared error on the training data.
   model.Predict(trainData, prediction);
-  trainError = mean(mean(square(prediction - trainLabels)));
+  trainError = arma::mean(arma::mean(square(prediction - trainLabels)));
 
   // Calculating the mean squared error on the test data
   model.Predict(testData, prediction);
-  testError = mean(mean(square(prediction - testLabels)));
+  testError = arma::mean(arma::mean(square(prediction - testLabels)));
 }
 
 /**

src/mlpack/tests/ann/layer/alpha_dropout.cpp

@@ -40,7 +40,7 @@ TEST_CASE("SimpleAlphaDropoutLayerTest", "[ANNLayerTest]")
   arma::mat output(arma::size(input));
   module.Forward(input, output);
   // Check whether mean remains nearly same.
-  REQUIRE(arma::as_scalar(arma::abs(mean(input) - mean(output))) <=
+  REQUIRE(arma::as_scalar(arma::abs(arma::mean(input) - arma::mean(output))) <=
       0.15);
 
   // Check whether variance remains nearly same.
@@ -50,7 +50,7 @@ TEST_CASE("SimpleAlphaDropoutLayerTest", "[ANNLayerTest]")
   // Test the Backward function when training phase.
   arma::mat delta;
   module.Backward(input, output, input, delta);
-  REQUIRE(arma::as_scalar(arma::abs(mean(delta) - 0)) <= 0.1);
+  REQUIRE(arma::as_scalar(arma::abs(arma::mean(delta) - 0)) <= 0.1);
 
   // Test the Forward function when testing phase.
   module.Training() = false;

src/mlpack/tests/ann/layer/dropout.cpp

@@ -37,12 +37,12 @@ TEST_CASE("SimpleDropoutLayerTest", "[ANNLayerTest]")
   // Test the Forward function.
   arma::mat output;
   module.Forward(input, output);
-  REQUIRE(arma::as_scalar(arma::abs(mean(output) - (1 - p))) <= 0.05);
+  REQUIRE(arma::as_scalar(arma::abs(arma::mean(output) - (1 - p))) <= 0.05);
 
   // Test the Backward function.
   arma::mat delta;
   module.Backward(input, output, input, delta);
-  REQUIRE(arma::as_scalar(arma::abs(mean(delta) - (1 - p))) <= 0.05);
+  REQUIRE(arma::as_scalar(arma::abs(arma::mean(delta) - (1 - p))) <= 0.05);
 
   // Test the Forward function.
   module.Training() = false;

src/mlpack/tests/ann/not_adapted/ann_layer_test.cpp

@@ -3952,7 +3952,7 @@ TEST_CASE("SimplePositionalEncodingTest", "[ANNLayerTest]")
   // Check Forward function.
   module.Forward(input, output);
   arma::mat pe = output - input;
-  CheckMatrices(mean(pe, 1), module.Encoding());
+  CheckMatrices(arma::mean(pe, 1), module.Encoding());
 
   // Check Backward function.
   module.Backward(input, gy, g);

src/mlpack/tests/ann/not_adapted/gan_test.cpp

@@ -111,9 +111,9 @@ TEST_CASE("GANTest", "[GANNetworkTest]")
         i * dim, 2 * dim - 1, i * dim + dim - 1) = samples;
   }
 
-  double generatedMean = arma::as_scalar(mean(
+  double generatedMean = arma::as_scalar(arma::mean(
       generatedData.rows(0, dim - 1), 1));
-  double originalMean = arma::as_scalar(mean(
+  double originalMean = arma::as_scalar(arma::mean(
       generatedData.rows(dim, 2 * dim - 1), 1));
   double generatedStd = arma::as_scalar(arma::stddev(
       generatedData.rows(0, dim - 1), 0, 1));

src/mlpack/tests/bayesian_linear_regression_test.cpp

@@ -88,9 +88,9 @@ TEST_CASE("TestCenterDataTrueScaleDataTrue", "[BayesianLinearRegressionTest]")
   BayesianLinearRegression<> estimator(true, true);
   estimator.Train(matX, y);
 
-  arma::colvec xMean = mean(matX, 1);
+  arma::colvec xMean = arma::mean(matX, 1);
   arma::colvec xStd = arma::stddev(matX, 0, 1);
-  double yMean = mean(y);
+  double yMean = arma::mean(y);
 
   REQUIRE((double) abs(sum(estimator.DataOffset() - xMean)) ==
       Approx(0.0).margin(1e-6));

src/mlpack/tests/distribution_test.cpp

@@ -464,7 +464,7 @@ TEST_CASE("GaussianDistributionRandomTest", "[DistributionTest]")
     obs.col(i) = d.Random();
 
   // Now make sure that reflects the actual distribution.
-  arma::vec obsMean = mean(obs, 1);
+  arma::vec obsMean = arma::mean(obs, 1);
   arma::mat obsCov = ColumnCovariance(obs);
 
   // 10% tolerance because this can be noisy.
@@ -499,7 +499,7 @@ TEST_CASE("GaussianDistributionTrainTest", "[DistributionTest]")
   GaussianDistribution d;
 
   // Find actual mean and covariance of data.
-  arma::vec actualMean = mean(observations, 1);
+  arma::vec actualMean = arma::mean(observations, 1);
   arma::mat actualCov = ColumnCovariance(observations);
 
   d.Train(observations);
@@ -917,8 +917,8 @@ TEST_CASE("GammaDistributionTrainStatisticsTest", "[DistributionTest]")
 
   // Train object d2 with the data's statistics.
   GammaDistribution d2;
-  const arma::vec meanLogx = mean(arma::log(data), 1);
-  const arma::vec meanx = mean(data, 1);
+  const arma::vec meanLogx = arma::mean(arma::log(data), 1);
+  const arma::vec meanx = arma::mean(data, 1);
   const arma::vec logMeanx = arma::log(meanx);
   d2.Train(logMeanx, meanLogx, meanx);
 
@@ -1434,7 +1434,7 @@ TEST_CASE("DiagonalGaussianDistributionRandomTest", "[DistributionTest]")
     obs.col(i) = d.Random();
 
   // Make sure that reflects the actual distribution.
-  arma::vec obsMean = mean(obs, 1);
+  arma::vec obsMean = arma::mean(obs, 1);
   arma::mat obsCov = ColumnCovariance(obs);
 
   // 10% tolerance because this can be noisy.
@@ -1462,7 +1462,7 @@ TEST_CASE("DiagonalGaussianDistributionTrainTest", "[DistributionTest]")
   DiagonalGaussianDistribution d;
 
   // Calculate the actual mean and covariance of data using armadillo.
-  arma::vec actualMean = mean(observations, 1);
+  arma::vec actualMean = arma::mean(observations, 1);
   arma::mat actualCov = ColumnCovariance(observations);
 
   // Estimate the parameters.

src/mlpack/tests/gmm_test.cpp

@@ -103,7 +103,7 @@ TEST_CASE("GMMTrainEMOneGaussian", "[GMMTest]")
     GMM gmm(1, 2);
     gmm.Train(data, 10);
 
-    arma::vec actualMean = mean(data, 1);
+    arma::vec actualMean = arma::mean(data, 1);
     arma::mat actualCovar = ColumnCovariance(data,
         1 /* biased estimator */);
 
@@ -192,7 +192,7 @@ TEST_CASE("GMMTrainEMMultipleGaussians", "[GMMTest]")
 
       // Calculate the actual means and covariances because they will probably
       // be different (this is easier to do before we shuffle the points).
-      means[i] = mean(data.cols(point, point + counts[i] - 1), 1);
+      means[i] = arma::mean(data.cols(point, point + counts[i] - 1), 1);
       covars[i] = ColumnCovariance(arma::mat(data.cols(point,
           point + counts[i] - 1)), 1 /* biased */);
 
@@ -727,7 +727,7 @@ TEST_CASE("UseExistingModelTest", "[GMMTest]")
 
     // Calculate the actual means and covariances because they will probably
     // be different (this is easier to do before we shuffle the points).
-    means[i] = mean(data.cols(point, point + counts[i] - 1), 1);
+    means[i] = arma::mean(data.cols(point, point + counts[i] - 1), 1);
     covars[i] = ColumnCovariance(arma::mat(data.cols(point,
         point + counts[i] - 1)), 1 /* biased */);
 
@@ -901,7 +901,7 @@ TEST_CASE("DiagonalGMMTrainEMOneGaussian", "[GMMTest]")
     DiagonalGMM gmm(1, 2);
     gmm.Train(data, 10);
 
-    arma::vec actualMean = mean(data, 1);
+    arma::vec actualMean = arma::mean(data, 1);
     arma::vec actualCovar = arma::diagvec(
         ColumnCovariance(data,
         1 /* biased estimator */));

src/mlpack/tests/hmm_test.cpp

@@ -1656,7 +1656,7 @@ TEST_CASE("DiagonalGMMHMMOneGaussianOneStateTrainingTest", "[HMMTest]")
   hmm.Train(observations);
 
   // Generate the ground truth values.
-  arma::vec actualMean = mean(observations[0], 1);
+  arma::vec actualMean = arma::mean(observations[0], 1);
   arma::vec actualCovar = arma::diagvec(
       ColumnCovariance(observations[0],
       1 /* biased estimator */));

src/mlpack/tests/lars_test.cpp

@@ -88,8 +88,8 @@ void LassoTest(size_t nPoints, size_t nDims, bool elasticNet, bool useCholesky,
 
     if (fitIntercept)
     {
-      y -= mean(y);
-      X.each_col() -= mean(X, 1);
+      y -= arma::mean(y);
+      X.each_col() -= arma::mean(X, 1);
     }
 
     if (normalizeData)
@@ -555,8 +555,8 @@ TEST_CASE("LARSFitInterceptTest", "[LARSTest]")
   arma::mat features = arma::randu<arma::mat>(10, 100);
   arma::rowvec responses = arma::randu<arma::rowvec>(100);
 
-  arma::mat centeredFeatures = features.each_col() - mean(features, 1);
-  arma::rowvec centeredResponses = responses - mean(responses);
+  arma::mat centeredFeatures = features.each_col() - arma::mean(features, 1);
+  arma::rowvec centeredResponses = responses - arma::mean(responses);
 
   LARS<> l1(features, responses, true, true, 0.001, 0.001, 1e-16, true, false);
   LARS<> l2(centeredFeatures, centeredResponses, true, true, 0.001, 0.001, 1e-16, false, false);
@@ -564,8 +564,8 @@ TEST_CASE("LARSFitInterceptTest", "[LARSTest]")
   // The weights learned should be the same.
   REQUIRE(l1.Beta().n_elem == l2.Beta().n_elem);
   CheckMatrices(l1.Beta(), l2.Beta());
-  REQUIRE(l1.Intercept() == Approx(mean(responses) -
-      arma::dot(mean(features, 1), l1.Beta())));
+  REQUIRE(l1.Intercept() == Approx(arma::mean(responses) -
+      arma::dot(arma::mean(features, 1), l1.Beta())));
 }
 
 // Make sure that Predict() provides reasonable enough solutions when we are
@@ -590,8 +590,8 @@ TEST_CASE("PredictFitInterceptTest", "[LARSTest]")
         lars.FitIntercept(true);
         lars.NormalizeData(false);
         lars.Train(X, y);
-        const double intercept = mean(y) -
-            arma::dot(mean(X, 1), lars.Beta());
+        const double intercept = arma::mean(y) -
+            arma::dot(arma::mean(X, 1), lars.Beta());
 
         // Calculate what the actual error should be with these regression
         // parameters.
@@ -678,8 +678,8 @@ TEST_CASE("PredictFitInterceptNormalizeDataTest", "[LARSTest]")
         lars.FitIntercept(true);
         lars.NormalizeData(true);
         lars.Train(X, y);
-        const double intercept = mean(y) -
-            arma::dot(mean(X, 1), lars.Beta());
+        const double intercept = arma::mean(y) -
+            arma::dot(arma::mean(X, 1), lars.Beta());
 
         // Calculate what the actual error should be with these regression
         // parameters.
@@ -756,10 +756,10 @@ TEST_CASE("LARSTestKKT", "[LARSTest]")
   {
     arma::mat X = std::move(F(0, i));
     arma::rowvec y = std::move(F(1, i));
-    const arma::rowvec xMean = mean(X, 0);
+    const arma::rowvec xMean = arma::mean(X, 0);
     arma::rowvec xStds = arma::stddev(X, 0, 0);
     xStds.replace(0.0, 1.0);
-    const double yMean = mean(y);
+    const double yMean = arma::mean(y);
 
     lars.FitIntercept(false);
     lars.NormalizeData(false);
@@ -823,10 +823,10 @@ TEMPLATE_TEST_CASE("LARSConstructorVariantTest", "[LARSTest]", arma::fmat,
   GenerateProblem(X, y, 1000, 100);
   MatType Xt = X.t();
 
-  const arma::Col<ElemType> xMean = mean(X, 1);
+  const arma::Col<ElemType> xMean = arma::mean(X, 1);
   arma::Col<ElemType> xStds = arma::stddev(X, 0, 1);
   xStds.replace(0.0, 1.0);
-  const ElemType yMean = mean(y);
+  const ElemType yMean = arma::mean(y);
 
   MatType centeredX = X.each_col() - xMean;
   arma::Row<ElemType> centeredY = y - yMean;
@@ -970,10 +970,10 @@ TEMPLATE_TEST_CASE("LARSTrainVariantTest", "[LARSTest]", arma::fmat, arma::mat)
   GenerateProblem(X, y, 1000, 5);
   MatType Xt = X.t();
 
-  const arma::Col<ElemType> xMean = mean(X, 1);
+  const arma::Col<ElemType> xMean = arma::mean(X, 1);
   arma::Col<ElemType> xStds = arma::stddev(X, 0, 1);
   xStds.replace(0.0, 1.0);
-  const ElemType yMean = mean(y);
+  const ElemType yMean = arma::mean(y);
 
   MatType centeredX = X.each_col() - xMean;
   arma::Row<ElemType> centeredY = y - yMean;

src/mlpack/tests/policy_gradient_test.cpp

@@ -217,7 +217,7 @@ TEST_CASE("GaussianNoiseTest", "[PolicyGradientTest]")
 
   // Verify that the noise vector has values drawn from a 
   // Gaussian distribution with the specified mean and standard deviation.
-  double mean = mean(noise);
+  double mean = arma::mean(noise);
   double stdDev = arma::stddev(noise);
 
   double meanErr = mean - mu;

src/mlpack/tests/tree_test.cpp

@@ -1438,7 +1438,7 @@ bool CheckHyperplaneSplit(const TreeType& tree)
   x.zeros();
   // Define an initial value.
   x[0] = 1.0;
-  x[1] = -mean(
+  x[1] = -arma::mean(
       dataset.cols(tree.Begin(), tree.Begin() + tree.Count() - 1).row(0));
 
   const size_t numIters = 1000000;