<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def distance_wei_floyd(adjacency, transform=None):
 """ Computes the topological length of the shortest possible path connecting every pair of nodes in the network. Parameters D : (N x N) array_like Weighted/unweighted, direct/undirected connection weight/length array transform : str, optional If `adjacency` is a connection weight array, specify a transform to map input connection weights to connection lengths. Options include ['log', 'inv'], where 'log' is `-np.log(adjacency)` and 'inv' is `1/adjacency`. Default: None Returns ------- SPL : (N x N) ndarray Weighted/unweighted shortest path-length array. If `D` is a directed graph, then `SPL` is not symmetric hops : (N x N) ndarray Number of edges in the shortest path array. If `D` is unweighted, `SPL` and `hops` are identical. Pmat : (N x N) ndarray Element `[i,j]` of this array indicates the next node in the shortest path between `i` and `j`. This array is used as an input argument for function `retrieve_shortest_path()`, which returns as output the sequence of nodes comprising the shortest path between a given pair of nodes. Notes ----- There may be more than one shortest path between any pair of nodes in the network. Non-unique shortest paths are termed shortest path degeneracies and are most likely to occur in unweighted networks. When the shortest-path is degenerate, the elements of `Pmat` correspond to the first shortest path discovered by the algorithm. The input array may be either a connection weight or length array. The connection length array is typically obtained with a mapping from weight to length, such that higher weights are mapped to shorter lengths (see argument `transform`, above). Originally written in Matlab by Andrea Avena-Koenigsberger (IU, 2012) References .. [1] Floyd, R. W. (1962). Algorithm 97: shortest path. Communications of the ACM, 5(6), 345. .. [2] Roy, B. (1959). Transitivite et connexite. Comptes Rendus Hebdomadaires Des Seances De L Academie Des Sciences, 249(2), 216-218. .. [3] Warshall, S. (1962). A theorem on boolean matrices. Journal of the ACM (JACM), 9(1), 11-12. .. [4] https://en.wikipedia.org/wiki/Floyd%E2%80%93Warshall_algorithm """


    if transform is not None:
        if transform == 'log':
            if np.logical_or(adjacency > 1, adjacency < 0).any():
                raise ValueError("Connection strengths must be in the " +
                                 "interval [0,1) to use the transform " +
                                 "-log(w_ij).")
            SPL = -np.log(adjacency)
        elif transform == 'inv':
            SPL = 1. / adjacency
        else:
            raise ValueError("Unexpected transform type. Only 'log' and " +
                             "'inv' are accepted")
    else:
        SPL = adjacency.copy().astype('float')
        SPL[SPL == 0] = np.inf

    n = adjacency.shape[1]

    flag_find_paths = True
    hops = np.array(adjacency != 0).astype('float')
    Pmat = np.repeat(np.atleast_2d(np.arange(0, n)), n, 0)

    for k in range(n):
        i2k_k2j = np.repeat(SPL[:, [k]], n, 1) + np.repeat(SPL[[k], :], n, 0)

        if flag_find_paths:
            path = SPL > i2k_k2j
            i, j = np.where(path)
            hops[path] = hops[i, k] + hops[k, j]
            Pmat[path] = Pmat[i, k]

        SPL = np.min(np.stack([SPL, i2k_k2j], 2), 2)

    I = np.eye(n) > 0
    SPL[I] = 0

    if flag_find_paths:
        hops[I], Pmat[I] = 0, 0

    return SPL, hops, Pmat