code: def algebraic_distance(A, alpha=0.5, R=5, k=20, epsilon=2.0, p=2):
      
      if not sparse.isspmatrix_csr(A):
          A = sparse.csr_matrix(A)
  
      if alpha < 0:
          raise ValueError('expected alpha>0')
  
      if R <= 0 or not isinstance(R, int):
          raise ValueError('expected integer R>0')
  
      if k <= 0 or not isinstance(k, int):
          raise ValueError('expected integer k>0')
  
      if epsilon < 1:
          raise ValueError('expected epsilon>1.0')
  
      if p < 1:
          raise ValueError('expected p>1 or equal to numpy.inf')
  
      def distance(x):
          (rows, cols) = A.nonzero()
          if p != np.inf:
              avg = np.sum(np.abs(x[rows] - x[cols])**p, axis=1) / R
              return (avg)**(1.0 / p)
          else:
              return np.abs(x[rows] - x[cols]).max(axis=1)
  
      return distance_measure_common(A, distance, alpha, R, k, epsilon)
docs: Algebraic Distance Strength Measure.
  
      Parameters
      ----------
      A : csr_matrix
          Sparse NxN matrix
      alpha : scalar
          Weight for Jacobi
      R : integer
          Number of random vectors
      k : integer
          Number of relaxation passes
      epsilon : scalar
          Drop tolerance
      p : scalar or inf
          p-norm of the measure
  
      Returns
      -------
      C : csr_matrix
          Sparse matrix of strength values
  
      References
      ----------
      .. [SaSaSc] Ilya Safro, Peter Sanders, and Christian Schulz,
          "Advanced Coarsening Schemes for Graph Partitioning"
  
      Notes
      -----
      No unit testing yet.
  
      Does not handle BSR matrices yet.
  
      See [SaSaSc]_ for more details.