class_docstr: Principal Component Analysis (PCA).
  
  Parameters
  ----------
  rescale_with_mean
      Whether or not to subtract each column's mean before performing SVD.
  rescale_with_std
      Whether or not to standardize each column before performing SVD.
  n_components
      The number of principal components to compute.
  n_iter
      The number of iterations used for computing the SVD.
  copy
      Whether nor to perform the computations inplace.
  check_input
      Whether to check the coherence of the inputs or not.
code: def fit(self, X, y=None, supplementary_columns=None):
      self._check_input(X)
  
      supplementary_columns = supplementary_columns or []
      active_variables = X.columns.difference(
          supplementary_columns, sort=False
      ).tolist()
  
      # https://scikit-learn.org/stable/developers/develop.html#universal-attributes
      self.feature_names_in_ = active_variables
      self.n_features_in_ = len(active_variables)
  
      X_active = X[active_variables].to_numpy(
          dtype=np.float64, copy=self.copy
      )
      if supplementary_columns:
          X_sup = X[supplementary_columns].to_numpy(
              dtype=np.float64, copy=self.copy
          )
  
      # Scale datarow_contributions
      if self.rescale_with_mean or self.rescale_with_std:
          self.scaler_ = preprocessing.StandardScaler(
              copy=self.copy,
              with_mean=self.rescale_with_mean,
              with_std=self.rescale_with_std,
          ).fit(X_active)
          X_active = self.scaler_.transform(
              X_active
          )  # TODO: maybe fit_transform is faster
          if supplementary_columns:
              X_sup = preprocessing.StandardScaler(
                  copy=self.copy,
                  with_mean=self.rescale_with_mean,
                  with_std=self.rescale_with_std,
              ).fit_transform(X_sup)
  
      self._column_dist = pd.Series(
          (X_active**2 / len(X_active)).sum(axis=0),
          index=active_variables,
      )
      if supplementary_columns:
          self._column_dist = pd.concat(
              (
                  self._column_dist,
                  pd.Series(
                      (X_sup**2 / len(X_sup)).sum(axis=0),
                      index=supplementary_columns,
                  ),
              )
          )
  
      self.svd_ = svd.compute_svd(
          X=X_active,
          n_components=self.n_components,
          n_iter=self.n_iter,
          random_state=self.random_state,
          engine=self.engine,
      )
  
      self.total_inertia_ = np.sum(np.square(X_active)) / len(X_active)
  
      self.column_coordinates_ = pd.DataFrame(
          data=self.svd_.V.T * self.eigenvalues_**0.5,
          index=active_variables,
      )
      if supplementary_columns:
          self.column_coordinates_ = pd.concat(
              [
                  self.column_coordinates_,
                  pd.DataFrame(
                      data=X_sup.T
                      @ (self.svd_.U / len(self.svd_.U) ** 0.5),
                      index=supplementary_columns,
                  ),
              ]
          )
      self.column_coordinates_.columns.name = "component"
      self.column_coordinates_.index.name = "variable"
      row_coords = pd.DataFrame(
          (self.svd_.U * len(self.svd_.U) ** 0.5)
          * self.eigenvalues_**0.5,
          # HACK: there's a circular dependency between row_contributions_
          # and active_row_coordinates in self.__init__
          index=self.row_contributions_.index
          if hasattr(self, "row_contributions_")
          else None,
      )
      row_coords.columns.name = "component"
      self.row_contributions_ = (row_coords**2 / len(X)).div(
          self.eigenvalues_, axis=1
      )
      self.row_contributions_.index = X.index
  
      return self
  
imports: from __future__ import annotations
  import functools
  import altair
  import numpy
  import pandas
  import sklearn.base
  import sklearn.utils
  from sklearn import preprocessing
  from prince import svd, utils
label_desc: Use image node_id 3 for calling the PCA obj's underlying member method code with example usage: obj.fit(X, y, supplementary_columns) and returns: self