code: def directed_modularity_matrix(G, nodelist=None, weight=None):
      """Returns the directed modularity matrix of G.
  
      The modularity matrix is the matrix B = A - <A>, where A is the adjacency
      matrix and <A> is the expected adjacency matrix, assuming that the graph
      is described by the configuration model.
  
      More specifically, the element B_ij of B is defined as
  
      .. math::
          B_{ij} = A_{ij} - k_i^{out} k_j^{in} / m
  
      where :math:`k_i^{in}` is the in degree of node i, and :math:`k_j^{out}` is the out degree
      of node j, with m the number of edges in the graph. When weight is set
      to a name of an attribute edge, Aij, k_i, k_j and m are computed using
      its value.
  
      Parameters
      ----------
      G : DiGraph
         A NetworkX DiGraph
  
      nodelist : list, optional
         The rows and columns are ordered according to the nodes in nodelist.
         If nodelist is None, then the ordering is produced by G.nodes().
  
      weight : string or None, optional (default=None)
         The edge attribute that holds the numerical value used for
         the edge weight.  If None then all edge weights are 1.
  
      Returns
      -------
      B : Numpy array
        The modularity matrix of G.
  
      Examples
      --------
      >>> G = nx.DiGraph()
      >>> G.add_edges_from(
      ...     (
      ...         (1, 2),
      ...         (1, 3),
      ...         (3, 1),
      ...         (3, 2),
      ...         (3, 5),
      ...         (4, 5),
      ...         (4, 6),
      ...         (5, 4),
      ...         (5, 6),
      ...         (6, 4),
      ...     )
      ... )
      >>> B = nx.directed_modularity_matrix(G)
  
  
      Notes
      -----
      NetworkX defines the element A_ij of the adjacency matrix as 1 if there
      is a link going from node i to node j. Leicht and Newman use the opposite
      definition. This explains the different expression for B_ij.
  
      See Also
      --------
      to_numpy_array
      modularity_spectrum
      adjacency_matrix
      modularity_matrix
  
      References
      ----------
      .. [1] E. A. Leicht, M. E. J. Newman,
          "Community structure in directed networks",
          Phys. Rev Lett., vol. 100, no. 11, p. 118703, 2008.
      """
      import numpy as np
  
      if nodelist is None:
          nodelist = list(G)
      A = nx.to_scipy_sparse_array(
          G, nodelist=nodelist, weight=weight, format="csr"
      )
      k_in = A.sum(axis=0)
      k_out = A.sum(axis=1)
      m = k_in.sum()
      # Expected adjacency matrix
      X = np.outer(k_out, k_in) / m
  
      return A - X
  
imports: import networkx
  from networkx.utils import not_implemented_for
label_desc: Use image node_id 2 for calling a global function with example usage: directed_modularity_matrix(G, nodelist, weight) and returns: unknown