code: def to_new(self, data, perplexities=None, return_distances=False):
          
          perplexities = perplexities if perplexities is not None else self.perplexities
          perplexities = self.check_perplexities(perplexities)
  
          max_perplexity = np.max(perplexities)
          k_neighbors = min(self.n_samples - 1, int(3 * max_perplexity))
  
          neighbors, distances = self.knn_index.query(data, k_neighbors)
  
          P = self._calculate_P(
              neighbors,
              distances,
              perplexities,
              symmetrize=False,
              normalization="point-wise",
              n_reference_samples=self.n_samples,
              n_jobs=self.n_jobs,
          )
  
          if return_distances:
              return P, neighbors, distances
  
          return P
docs: Compute the affinities of new samples to the initial samples.
  
          This is necessary for embedding new data points into an existing
          embedding.
  
          Please see the :ref:`parameter-guide` for more information.
  
          Parameters
          ----------
          data: np.ndarray
              The data points to be added to the existing embedding.
  
          perplexities: List[float]
              A list of perplexity values, which will be used in the multiscale
              Gaussian kernel. Perplexity can be thought of as the continuous
              :math:`k` number of nearest neighbors, for which t-SNE will attempt
              to preserve distances.
  
          return_distances: bool
              If needed, the function can return the indices of the nearest
              neighbors and their corresponding distances.
  
          Returns
          -------
          P: array_like
              An :math:`N \\times M` affinity matrix expressing interactions
              between :math:`N` new data points the initial :math:`M` data
              samples.
  
          indices: np.ndarray
              Returned if ``return_distances=True``. The indices of the :math:`k`
              nearest neighbors in the existing embedding for every new data
              point.
  
          distances: np.ndarray
              Returned if ``return_distances=True``. The distances to the
              :math:`k` nearest neighbors in the existing embedding for every new
              data point.