code: def assortativity_indicators(user):
      
  
      matrix = matrix_undirected_unweighted(user)
  
      count_indicator = defaultdict(int)
      total_indicator = defaultdict(int)
  
      # Use all indicator except reporting variables and attributes
      ego_indics = all(user, flatten=True)
      ego_indics = {a: value for a, value in ego_indics.items()
                    if a != "name" and a[:11] != "reporting__" and
                    a[:10] != "attributes"}
  
      for i, u_name in enumerate(matrix_index(user)):
          correspondent = user.network.get(u_name, None)
  
          # Non reciprocated edge
          if correspondent is None or u_name == user.name or matrix[0][i] == 0:
              continue
  
          neighbor_indics = all(correspondent, flatten=True)
          for a in ego_indics:
              if ego_indics[a] is not None and neighbor_indics[a] is not None:
                  total_indicator[a] += 1
                  count_indicator[a] += (ego_indics[a] - neighbor_indics[a]) ** 2
  
      assortativity = {}
      for i in count_indicator:
          assortativity[i] = count_indicator[i] / total_indicator[i]
  
      return assortativity
docs: Computes the assortativity of indicators.
  
      This indicator measures the similarity of the current user with his
      correspondants, for all bandicoot indicators. For each one, it calculates
      the variance of the current user's value with the values for all his
      correspondants:
  
      .. math::
  
          \\text{assortativity}(J) = \\frac{1}{n} \\sum_i^n (J_{\\text{user}} - J_{\\text{i}})^2
  
      for the indicator :math:`J`, and all the :math:`n` correspondents.