code: def _fit_full_daal4py(self, X, n_components):
      n_samples, n_features = X.shape
      n_sf_min = min(n_samples, n_features)
  
      if n_components == "mle":
          daal_n_components = n_features
      elif n_components < 1:
          daal_n_components = n_sf_min
      else:
          daal_n_components = n_components
  
      fpType = getFPType(X)
  
      covariance_algo = daal4py.covariance(
          fptype=fpType, outputMatrixType="covarianceMatrix"
      )
      covariance_res = covariance_algo.compute(X)
  
      self.mean_ = covariance_res.mean.ravel()
      covariance = covariance_res.covariance
      variances_ = np.array(
          [covariance[i, i] for i in range(n_features)]
      )
  
      pca_alg = daal4py.pca(
          fptype=fpType,
          method="correlationDense",
          resultsToCompute="eigenvalue",
          isDeterministic=True,
          nComponents=daal_n_components,
      )
      pca_res = pca_alg.compute(X, covariance)
  
      components_ = pca_res.eigenvectors
      explained_variance_ = np.maximum(pca_res.eigenvalues.ravel(), 0)
      tot_var = explained_variance_.sum()
      explained_variance_ratio_ = explained_variance_ / tot_var
  
      if n_components == "mle":
          if sklearn_check_version("0.23"):
              n_components = _infer_dimension(
                  explained_variance_, n_samples
              )
          else:
              n_components = _infer_dimension_(
                  explained_variance_, n_samples, n_features
              )
      elif 0 < n_components < 1.0:
          ratio_cumsum = stable_cumsum(explained_variance_ratio_)
          n_components = (
              np.searchsorted(ratio_cumsum, n_components, side="right")
              + 1
          )
  
      if n_components < n_sf_min:
          if explained_variance_.shape[0] == n_sf_min:
              self.noise_variance_ = explained_variance_[
                  n_components:
              ].mean()
          else:
              resid_var_ = variances_.sum()
              resid_var_ -= explained_variance_[:n_components].sum()
              self.noise_variance_ = resid_var_ / (
                  n_sf_min - n_components
              )
      else:
          self.noise_variance_ = 0.0
  
      if sklearn_check_version("1.2"):
          self.n_samples_, self.n_features_in_ = n_samples, n_features
      else:
          self.n_samples_, self.n_features_ = n_samples, n_features
      self.components_ = components_[:n_components]
      self.n_components_ = n_components
      self.explained_variance_ = explained_variance_[:n_components]
      self.explained_variance_ratio_ = explained_variance_ratio_[
          :n_components
      ]
      self.singular_values_ = np.sqrt(
          (n_samples - 1) * self.explained_variance_
      )
  
file_path: scikit-learn-intelex/daal4py/sklearn/decomposition/_pca.py
imports: import numbers
  from math import sqrt
  import numpy
  from scipy.sparse import issparse
  from sklearn.utils import check_array
  from sklearn.utils.extmath import stable_cumsum
  from sklearn.utils.validation import check_is_fitted
  import daal4py
  from .._device_offload import support_usm_ndarray
  from .._utils import PatchingConditionsChain, control_n_jobs, getFPType, run_with_n_jobs, sklearn_check_version
label_desc: Use image node_id 3 for calling the PCA obj's underlying member method code with example usage: obj._fit_full_daal4py(X, n_components) without return types