Rename PCA to PrincipalComponentAnalysis

include/tapkee/defines/methods.hpp

@@ -123,10 +123,10 @@ static const DimensionReductionMethod StochasticProximityEmbedding("Stochastic P
 
 /** Kernel PCA as described in
  * @cite Scholkopf1997 */
-static const DimensionReductionMethod KernelPCA("Kernel Principal Component Analysis (KPCA)", RequiresKernel);
+static const DimensionReductionMethod KernelPrincipalComponentAnalysis("Kernel Principal Component Analysis (KPCA)", RequiresKernel);
 
 /** Principal Component Analysis */
-static const DimensionReductionMethod PCA("Principal Component Analysis (PCA)", RequiresFeatures);
+static const DimensionReductionMethod PrincipalComponentAnalysis("Principal Component Analysis (PCA)", RequiresFeatures);
 
 /** Random Projection as described in
  * @cite Kaski1998*/

include/tapkee/methods.hpp

@@ -62,8 +62,8 @@ class DynamicImplementation : public ImplementationBase<RandomAccessIterator, Ke
         tapkee_method_handle(HessianLocallyLinearEmbedding);
         tapkee_method_handle(LaplacianEigenmaps);
         tapkee_method_handle(LocalityPreservingProjections);
-        tapkee_method_handle(PCA);
-        tapkee_method_handle(KernelPCA);
+        tapkee_method_handle(PrincipalComponentAnalysis);
+        tapkee_method_handle(KernelPrincipalComponentAnalysis);
         tapkee_method_handle(RandomProjection);
         tapkee_method_handle(StochasticProximityEmbedding);
         tapkee_method_handle(PassThru);

include/tapkee/methods/kernel_pca.hpp

@@ -15,7 +15,7 @@ namespace tapkee
 namespace tapkee_internal
 {
 
-__TAPKEE_IMPLEMENTATION(KernelPCA)
+__TAPKEE_IMPLEMENTATION(KernelPrincipalComponentAnalysis)
     TapkeeOutput embed()
     {
         DenseSymmetricMatrix centered_kernel_matrix = compute_centered_kernel_matrix(this->begin, this->end, this->kernel);

include/tapkee/methods/pca.hpp

@@ -15,7 +15,7 @@ namespace tapkee
 namespace tapkee_internal
 {
 
-__TAPKEE_IMPLEMENTATION(PCA)
+__TAPKEE_IMPLEMENTATION(PrincipalComponentAnalysis)
     TapkeeOutput embed()
     {
         DenseVector mean_vector = compute_mean(this->begin, this->end, this->features, this->current_dimension);

src/cli/util.hpp

@@ -114,9 +114,9 @@ tapkee::DimensionReductionMethod parse_reduction_method(const char* str)
     if (!strcmp(str, "diffusion_map") || !strcmp(str, "dm"))
         return tapkee::DiffusionMap;
     if (!strcmp(str, "kernel_pca") || !strcmp(str, "kpca"))
-        return tapkee::KernelPCA;
+        return tapkee::KernelPrincipalComponentAnalysis;
     if (!strcmp(str, "pca"))
-        return tapkee::PCA;
+        return tapkee::PrincipalComponentAnalysis;
     if (!strcmp(str, "random_projection") || !strcmp(str, "ra"))
         return tapkee::RandomProjection;
     if (!strcmp(str, "laplacian_eigenmaps") || !strcmp(str, "la"))

test/unit/interface.cpp

@@ -35,7 +35,7 @@ TEST(Interface, ChainInterfaceOrder)
                                  .embedRange(indices.begin(), indices.end()));
 
     ASSERT_NO_THROW(output = tapkee::initialize()
-                                 .withParameters((method = KernelPCA))
+                                 .withParameters((method = KernelPrincipalComponentAnalysis))
                                  .withDistance(dcb)
                                  .withKernel(kcb)
                                  .withFeatures(fcb)
@@ -75,13 +75,13 @@ TEST(Interface, ChainInterfaceOrder)
                                  .embedRange(indices.begin(), indices.end()));
 
     ASSERT_NO_THROW(output = tapkee::initialize()
-                                 .withParameters((method = KernelPCA))
+                                 .withParameters((method = KernelPrincipalComponentAnalysis))
                                  .withKernel(kcb)
                                  .withDistance(dcb)
                                  .embedRange(indices.begin(), indices.end()));
 
     ASSERT_NO_THROW(output = tapkee::initialize()
-                                 .withParameters((method = KernelPCA))
+                                 .withParameters((method = KernelPrincipalComponentAnalysis))
                                  .withKernel(kcb)
                                  .withFeatures(fcb)
                                  .embedRange(indices.begin(), indices.end()));
@@ -99,7 +99,7 @@ TEST(Interface, ChainInterfaceOrder)
                                  .embedRange(indices.begin(), indices.end()));
 
     ASSERT_NO_THROW(output = tapkee::initialize()
-                                 .withParameters((method = KernelPCA))
+                                 .withParameters((method = KernelPrincipalComponentAnalysis))
                                  .withKernel(kcb)
                                  .embedRange(indices.begin(), indices.end()));
 

test/unit/methods.cpp

@@ -96,14 +96,14 @@ TEST(Methods, StochasticProximityEmbeddingSmokeTest)
     smoketest(StochasticProximityEmbedding);
 }
 
-TEST(Methods, KernelPCASmokeTest)
+TEST(Methods, KernelPrincipalComponentAnalysisSmokeTest)
 {
-    smoketest(KernelPCA);
+    smoketest(KernelPrincipalComponentAnalysis);
 }
 
-TEST(Methods, PCASmokeTest)
+TEST(Methods, PrincipalComponentAnalysisSmokeTest)
 {
-    smoketest(PCA);
+    smoketest(PrincipalComponentAnalysis);
 }
 
 TEST(Methods, RandomProjectionSmokeTest)

test/unit/projecting.cpp

@@ -6,14 +6,14 @@
 
 using namespace tapkee;
 
-TEST(Projecting, PCA)
+TEST(Projecting, PrincipalComponentAnalysis)
 {
     const int N = 50;
     DenseMatrix X = swissroll(N);
 
     TapkeeOutput output;
 
-    ASSERT_NO_THROW(output = tapkee::initialize().withParameters((method = PCA, target_dimension = 2)).embedUsing(X));
+    ASSERT_NO_THROW(output = tapkee::initialize().withParameters((method = PrincipalComponentAnalysis, target_dimension = 2)).embedUsing(X));
 
     auto projected = output.projection(X.col(0));
     ASSERT_EQ(2, projected.size());