Implmented svd() in Matrix

include/DataFrame/DataFrame.h

@@ -3759,6 +3759,34 @@ class   DataFrame : public ThreadGranularity {
         std::vector<const char *> &&col_names,
         normalization_type norm_type = normalization_type::none) const;
 
+
+
+
+
+
+
+
+
+
+
+    // Principal Component Analysis (PCA)
+    //
+    template<typename T>
+    EigenSpace<T>
+    prin_comp_analysis(std::vector<const char *> &&col_names,
+                       const PCAParams params = { }) const;
+
+
+
+
+
+
+
+
+
+
+
+
     // This function returns a DataFrame indexed by std::string that provides
     // a few statistics about the columns of the calling DataFrame.
     // The statistics are:

include/DataFrame/DataFrameTypes.h

@@ -717,6 +717,28 @@ struct  StationaryTestParams  {
 
 // ----------------------------------------------------------------------------
 
+enum class  pca_method : unsigned char  {
+
+    eigen = 1,  // Eigen decomposition of the covariance matrix
+    svd = 2,    // Singular Value Decomposition of the data matrix
+};
+
+struct  PCAParams  {
+
+    pca_method          method { pca_method::eigen };
+    normalization_type  norm_type { normalization_type::z_score };
+
+    // if populated, number of eigen components kept.
+    //
+    std::size_t         num_comp_kept { 0 };
+
+    // if populated, percentage of eigen components kept -- 0.9 means 90%.
+    //
+    double              pct_comp_kept { 0.9 };
+};
+
+// ----------------------------------------------------------------------------
+
 template<typename T>
 struct  RandGenParams  {
 

include/DataFrame/Utils/Matrix.h

@@ -137,7 +137,7 @@ class   Matrix  {
     //
     Matrix
     covariance(bool is_unbiased = true) const;
-	
+
     // Let A be an nXn matrix. The number l is an eigenvalue of A if there
     // exists a non-zero vector v such that
     //     Av = lv
@@ -209,6 +209,40 @@ class   Matrix  {
                      MA2 &eigenvectors,
                      bool sort_values) const;
 
+    // In linear algebra, the Singular Value Decomposition (SVD) is an
+    // important factorization of a rectangular real or complex matrix,
+    // with several applications in signal processing and statistics.
+    // Applications which employ the SVD include computing the
+    // pseudoinverse, matrix approximation, and determining the rank,
+    // range and null space of a matrix.
+    //
+    // Suppose M is an mXn matrix whose entries come from the field K,
+    // which is either the field of real numbers or the field of complex
+    // numbers. Then there exists a factorization of the form
+    //     M = U*Σ*~V
+    //
+    // where U is an mXm unitary matrix over K, the matrix Σ is mXn
+    // with nonnegative numbers on the diagonal (as defined for a
+    // rectangular matrix) and zeros off the diagonal, and ~V denotes the
+    // conjugate transpose of V (transpose of V in case of real matrices),
+    // an nXn unitary matrix over K. Such a factorization is called a
+    // Singular Value Decomposition of M.
+    //
+    //  -- The matrix V thus contains a set of orthonormal "input" or
+    //     "analysing" basis vector directions for M
+    //  -- The matrix U contains a set of orthonormal "output" basis vector
+    //     directions for M
+    //  -- The matrix Σ contains the singular values, which can be thought
+    //     of as scalar "gain controls" by which each corresponding input
+    //     is multiplied to give a corresponding output.
+    //
+    // A common convention is to order the values Σi,i in non-increasing
+    // fashion. In this case, the diagonal matrix Σ is uniquely determined
+    // by M (though the matrices U and V are not).
+    //
+    template<typename MA1, typename MA2, typename MA3>
+    inline void svd(MA1 &U, MA2 &S, MA3 &V, bool full_size = true) const;
+
 private:
 
     static constexpr size_type  NOPOS_ = static_cast<size_type>(-9);
@@ -1453,6 +1487,15 @@ operator * (const Matrix<T, MO1> &lhs, const Matrix<T, MO2> &rhs)  {
     return (result);
 }
 
+// ----------------------------------------------------------------------------
+
+template<typename T>
+struct  EigenSpace  {
+
+    Matrix<T, matrix_orient::row_major>     eigen_vals { };
+    Matrix<T, matrix_orient::column_major>  eigen_vecs { };
+};
+
 } // namespace hmdf
 
 // ----------------------------------------------------------------------------