tmapper-py 0.1.0__py3-none-any.whl

tmapper/cycle_path_decomp.py

@@ -0,0 +1,104 @@
+"""Port of tmapper_tools/CyclePathDecomp.m from the MATLAB toolbox.
+
+The MATLAB original's diagonal cluster-block overlay (``addDiagBlock.m``)
+is not ported literally -- it's tightly coupled to MATLAB axes internals
+(``ax.Children(end).CData``) with no Python equivalent. The same visual
+annotation is reproduced directly here with matplotlib patches, reusing
+:func:`tmapper.graph_utils.find_blocks`.
+"""
+
+import numpy as np
+import networkx as nx
+
+from .cycle_count2p import cycle_count2p
+from .cycle_cluster import cycle_cluster
+from .cycle_cluster_conn import cycle_cluster_conn
+from .cycles_to_paths import cycles_to_paths
+from .graph_utils import find_blocks
+
+
+def _add_diag_block(ax, cluster_labels, *, reordermat=True):
+    from matplotlib.patches import Rectangle
+
+    cluster_labels = np.asarray(cluster_labels)
+    order = np.argsort(cluster_labels, kind="stable") if reordermat else np.arange(len(cluster_labels))
+    sorted_labels = cluster_labels[order]
+
+    for label in np.unique(sorted_labels):
+        starts, _, sizes = find_blocks((sorted_labels == label).astype(int))
+        for s, size in zip(starts, sizes):
+            ax.add_patch(Rectangle((s - 0.5, s - 0.5), size, size,
+                                    fill=False, edgecolor="k", linewidth=2))
+
+
+def cycle_path_decomp(dg, *, clusterthres=0.5, plotmat=True, plotmds=False,
+                       plothist=False, reordermat=True):
+    """Cycle-path decomposition of a directed graph.
+
+    Port of MATLAB's ``CyclePathDecomp.m``. Cycles on the graph are
+    first computed, then clustered such that cycles with ``clusterthres``
+    amount of overlap belong to the same cluster. Boundaries between
+    clusters of cycles (nodes where one cycle enters into another) are
+    used to cut cycles into paths, which are then clustered themselves.
+
+    Parameters
+    ----------
+    dg : networkx.DiGraph
+        The graph to decompose.
+    clusterthres : float, default 0.5
+        Overlap threshold for cycle/path clustering.
+    plotmat : bool, default True
+        Whether to plot the overlap matrices (with cluster-block
+        outlines) for diagnostics.
+    plotmds : bool, default False
+        Whether to plot a 2D classical-MDS projection of cycles/paths.
+    plothist : bool, default False
+        Whether to plot linkage-distance histograms.
+    reordermat : bool, default True
+        Whether to reorder the overlap matrices by cluster assignment.
+
+    Returns
+    -------
+    allbd : list
+        All boundary points between cycle clusters (used to cut cycles
+        into paths).
+    pclusters_nodes : list of list
+        Nodes in each path cluster.
+    pclusters_interior : list of list
+        Interior (non-boundary) nodes of each path cluster.
+    pclusters_boundary : list of set
+        Boundary nodes of each path cluster.
+    pcluster_conn_dir : list of list of set
+        Directed boundary connectivity between path clusters.
+    pclusters_intcrtpts : list of list
+        Interior critical points of each path cluster.
+    allupath : list of list
+        All unique decomposed paths.
+    Tp : numpy.ndarray
+        Cluster assignment of each path in ``allupath``.
+    """
+    A = nx.to_numpy_array(dg, nodelist=list(dg.nodes()), weight=None)
+    _, _, _, allcycles = cycle_count2p(A)
+
+    T, ax1 = cycle_cluster(allcycles, clusterthres, plotmat=plotmat, plotmds=plotmds,
+                           plothist=plothist, reordermat=reordermat, return_ax=True)
+    _, _, _, clusters_boundary, _, _, _ = cycle_cluster_conn(dg, allcycles, T)
+
+    if plotmat and ax1 is not None:
+        _add_diag_block(ax1, T, reordermat=reordermat)
+    print(f"# cycle clusters = {int(T.max()) if len(T) else 0}")
+
+    allbd = sorted(set().union(*clusters_boundary)) if clusters_boundary else []
+    allupath = cycles_to_paths(allcycles, allbd)
+
+    Tp, ax2 = cycle_cluster(allupath, clusterthres, plotmat=plotmat, plotmds=plotmds,
+                            plothist=plothist, reordermat=reordermat, return_ax=True)
+    (_, pcluster_conn_dir, pclusters_nodes, pclusters_boundary,
+     pclusters_interior, _, pclusters_intcrtpts) = cycle_cluster_conn(dg, allupath, Tp)
+
+    if plotmat and ax2 is not None:
+        _add_diag_block(ax2, Tp, reordermat=reordermat)
+    print(f"# path clusters = {int(Tp.max()) if len(Tp) else 0}")
+
+    return (allbd, pclusters_nodes, pclusters_interior, pclusters_boundary,
+            pcluster_conn_dir, pclusters_intcrtpts, allupath, Tp)

tmapper/cycles_to_paths.py

@@ -0,0 +1,40 @@
+"""Port of tmapper_tools/Cycles2Paths.m from the MATLAB toolbox."""
+
+from .cycle_cutter import cycle_cutter
+
+
+def cycles_to_paths(allcycles, cutpts):
+    """Cut a set of cycles to obtain a set of unique paths connecting a
+    set of cutting points (nodes).
+
+    Port of MATLAB's ``Cycles2Paths.m``.
+
+    Parameters
+    ----------
+    allcycles : sequence of sequence of int
+        A list of cycle paths.
+    cutpts : sequence of int
+        Node indices at which each cycle should be cut (cutting points).
+
+    Returns
+    -------
+    list of list
+        Unique paths linking the cutting points, sorted by (length, then
+        lexicographically within each length).
+    """
+    if not allcycles:
+        return []
+
+    allpath = []
+    for x in allcycles:
+        allpath.extend(cycle_cutter(x, cutpts))
+
+    pathlen = [len(p) for p in allpath]
+    upathlen = sorted(set(pathlen))
+
+    allupath = []
+    for L in upathlen:
+        rows = sorted({tuple(p) for p, l in zip(allpath, pathlen) if l == L})
+        allupath.extend(list(r) for r in rows)
+
+    return allupath

tmapper/filtergraph.py

@@ -0,0 +1,107 @@
+"""Port of tmapper_tools/filtergraph.m from the MATLAB toolbox."""
+
+import numpy as np
+import networkx as nx
+
+from ._shortest_path import all_pairs_distance
+
+
+def filtergraph(g, d, *, reciprocal=True):
+    """Contract a graph ``g`` into a simplified graph (a Mapper-style shape
+    graph) by merging nodes that are within geodesic distance ``d`` of one
+    another.
+
+    Port of MATLAB's ``filtergraph.m``. This is the Mapper-style contraction
+    step: nodes of ``g`` within geodesic distance ``d`` of each other are
+    connected in an intermediate graph, and its connected components become
+    the nodes of the simplified graph.
+
+    Parameters
+    ----------
+    g : networkx.Graph or networkx.DiGraph
+        Graph to simplify.
+    d : float
+        Threshold under which original nodes are collapsed together. Must
+        be a positive real number.
+    reciprocal : bool, default True
+        Whether to require both the path length from x to y *and* from y
+        to x to be under ``d`` (True), or either direction (False).
+
+    Returns
+    -------
+    g_simp : networkx.DiGraph
+        The simplified graph -- the attractor transition network.
+    members : list of list
+        ``members[n]`` is the list of original node labels (from ``g``)
+        belonging to new node n. If ``g``'s nodes are the default 0..N-1
+        integers straight from :func:`tknndigraph`, these are *positions*
+        into your original data, not real time labels.
+    nodesize : numpy.ndarray, shape (n_new,)
+        Number of original-graph members in each new node.
+    D_simp : numpy.ndarray, shape (n_new, n_new)
+        Shortest "distance" (from the original graph) between each pair
+        of new nodes' member sets.
+    """
+    if not isinstance(g, (nx.Graph, nx.DiGraph)):
+        raise ValueError("g must be a networkx Graph or DiGraph.")
+    if not (np.isscalar(d) and np.isreal(d) and d > 0):
+        raise ValueError("d must be a positive real scalar.")
+
+    nodelist = list(g.nodes())
+    Nn = len(nodelist)
+    idx_of = {node: i for i, node in enumerate(nodelist)}
+
+    A = nx.to_numpy_array(g, nodelist=nodelist)  # weighted adjacency (weight 1 if unweighted)
+    D = all_pairs_distance(g, nodelist)  # geodesic distance, inf if unreachable
+
+    # -- connectivity within a distance threshold
+    if reciprocal:
+        A_ = (D < d) & (D.T < d)
+    else:
+        A_ = (D < d) | (D.T < d)
+    np.fill_diagonal(A_, False)  # remove self-loops
+
+    # -- create graph out of nodes within said threshold, find connected components
+    g_ = nx.from_numpy_array(A_)
+    components = list(nx.connected_components(g_))
+    # sort components by their smallest member index, for deterministic/stable ordering
+    components = sorted(components, key=min)
+
+    idx_newnodes = np.empty(Nn, dtype=int)
+    for new_idx, comp in enumerate(components):
+        for i in comp:
+            idx_newnodes[i] = new_idx
+    n_new = len(components)
+
+    # -- group original nodes by new-node label via a stable sort, so each
+    # group is a contiguous run. This lets the block min/mean below use
+    # ufunc.reduceat instead of an O(n_new^2) Python loop over Nn-sized
+    # boolean masks (the previous approach was O(n_new^2 * Nn) and became
+    # the dominant cost at realistic graph sizes).
+    order = np.argsort(idx_newnodes, kind="stable")
+    group_start = np.searchsorted(idx_newnodes[order], np.arange(n_new))
+    group_bounds = np.append(group_start, Nn)
+
+    members = [
+        [nodelist[i] for i in order[group_bounds[n]:group_bounds[n + 1]]]
+        for n in range(n_new)
+    ]
+    nodesize = np.array([len(m) for m in members])
+
+    D_sorted = D[np.ix_(order, order)]
+    A_sorted = A[np.ix_(order, order)]
+
+    # -- define distance between new nodes: shortest path between member sets
+    D_row = np.minimum.reduceat(D_sorted, group_start, axis=0)
+    D_simp = np.minimum.reduceat(D_row, group_start, axis=1)
+
+    # -- construct simplified graph: A_simp(n,m) = average connectivity between blocks
+    A_row_sum = np.add.reduceat(A_sorted, group_start, axis=0)
+    A_col_sum = np.add.reduceat(A_row_sum, group_start, axis=1)
+    group_sizes = np.diff(group_bounds)
+    A_simp = A_col_sum / np.outer(group_sizes, group_sizes)
+
+    g_simp = nx.from_numpy_array(A_simp, create_using=nx.DiGraph)
+    g_simp.remove_edges_from(nx.selfloop_edges(g_simp))  # OmitSelfLoops
+
+    return g_simp, members, nodesize, D_simp

tmapper/graph_utils.py

@@ -0,0 +1,283 @@
+"""Small graph/data utilities. Ports of tmapper_tools/nodesize.m,
+nodemeasure.m, normgeo.m, normtcm.m, members2tidx.m,
+subgraphFromMembers.m, symDyn2digraph.m, digraph2graph.m, and
+findtaskn.m from the MATLAB toolbox.
+
+weightedAdj.m, zerodiag.m, and toVec.m are not ported: they are pure
+MATLAB-object-compatibility shims with no standalone meaning in Python
+(nx.to_numpy_array, np.fill_diagonal, and flat numpy arrays already
+cover that ground natively).
+"""
+
+import numpy as np
+import networkx as nx
+
+
+def node_size(nodemembers):
+    """Number of members in each node. Port of ``nodesize.m``."""
+    return np.array([len(m) for m in nodemembers])
+
+
+def node_measure(nodemembers):
+    """Number of members in each node, normalized to sum to 1. Port of
+    ``nodemeasure.m``."""
+    n = node_size(nodemembers).astype(float)
+    return n / n.sum()
+
+
+def normalize_geodesic(geod, nsize=None, *, exclude_diag=False):
+    """Normalize a geodesic distance matrix by node measure.
+
+    Port of ``normgeo.m``. Note: unlike the MATLAB original, an omitted
+    ``nsize`` defaults to a uniform *vector* of ones (equal-size nodes),
+    which is clearly the intended behavior from the docstring -- the
+    MATLAB version's ``ones(N_nodes)`` (a matrix, not ``ones(N_nodes,1)``)
+    appears to be an unexercised bug in that rarely-hit default-value path.
+
+    Parameters
+    ----------
+    geod : array_like, shape (N, N)
+        Geodesic distance matrix.
+    nsize : array_like, shape (N,), optional
+        Size of each node. Defaults to a uniform vector of ones.
+    exclude_diag : bool, default False
+        Whether to exclude the diagonal when computing the normalizing
+        factor.
+
+    Returns
+    -------
+    geod_n : numpy.ndarray, shape (N, N)
+        Normalized geodesic distance matrix.
+    nm : numpy.ndarray, shape (N,)
+        Node measure (probability), sums to 1.
+    """
+    geod = np.array(geod, dtype=float, copy=True)
+    n_nodes = geod.shape[0]
+
+    if nsize is None:
+        nsize = np.ones(n_nodes)
+    nsize = np.asarray(nsize, dtype=float)
+
+    # -- handle inf
+    if np.any(np.isinf(geod)):
+        finite = geod[np.isfinite(geod)]
+        geod[np.isinf(geod)] = finite.max() if finite.size else 0.0
+
+    # -- weight nodes and geodesics
+    nm = nsize / nsize.sum()
+    geod_n = np.outer(nm, nm) * geod ** 2
+
+    # -- normalizing factor: the sum of weighted geodesics
+    if exclude_diag:
+        mask = ~np.eye(n_nodes, dtype=bool)
+        normfactor = np.sqrt(geod_n[mask].sum())
+    else:
+        normfactor = np.sqrt(geod_n.sum())
+
+    # -- normalize
+    if normfactor != 0:
+        geod_n = geod / normfactor
+
+    return geod_n, nm
+
+
+def normalize_tcm(tcm, *, normtype="max", infreplace="max"):
+    """Normalize a temporal connectivity matrix by its maximal finite
+    value (or its norm). Port of ``normtcm.m``.
+
+    Parameters
+    ----------
+    tcm : array_like
+        Temporal connectivity matrix.
+    normtype : {'max', 'norm'}, default 'max'
+        How to compute the normalizing factor: the matrix's maximum
+        finite value, or its (Frobenius/vector) norm.
+    infreplace : {'max', 'nan'}, default 'max'
+        How to handle inf entries before normalizing: replace with the
+        matrix's maximum finite value, or with NaN.
+
+    Returns
+    -------
+    numpy.ndarray
+    """
+    tcm = np.array(tcm, dtype=float, copy=True)
+
+    if infreplace == "max":
+        finite = tcm[np.isfinite(tcm)]
+        if finite.size:
+            tcm[np.isinf(tcm)] = finite.max()
+    elif infreplace == "nan":
+        tcm[np.isinf(tcm)] = np.nan
+    else:
+        raise ValueError(f"Unknown infreplace: {infreplace!r}")
+
+    if normtype == "max":
+        normfactor = np.nanmax(tcm)
+    elif normtype == "norm":
+        normfactor = np.linalg.norm(tcm.ravel())
+    else:
+        raise ValueError(f"Unknown normtype: {normtype!r}")
+
+    if normfactor != 0:
+        return tcm / normfactor
+    return tcm
+
+
+def members_to_tidx(members, tidx):
+    """Translate positional-index members to real ``tidx`` values.
+
+    Port of ``members2tidx.m``. Use this when ``tidx`` is non-contiguous
+    or offset (e.g. real timestamps with gaps): :func:`filtergraph`'s
+    ``members`` output gives positional indices into your original data,
+    not ``tidx`` values.
+
+    Parameters
+    ----------
+    members : sequence of sequence of int
+        Positional indices into the original data, e.g. from
+        :func:`filtergraph`.
+    tidx : array_like
+        The same ``tidx`` array originally passed to :func:`tknndigraph`.
+
+    Returns
+    -------
+    list of numpy.ndarray
+    """
+    tidx = np.asarray(tidx)
+    return [tidx[np.asarray(list(m), dtype=int)] for m in members]
+
+
+def subgraph_from_members(g_simp, members, include_members):
+    """Extract the subgraph of a transition network restricted to a
+    subset of original time points. Port of ``subgraphFromMembers.m``.
+
+    Parameters
+    ----------
+    g_simp : networkx.Graph or networkx.DiGraph
+        The simplified transition network.
+    members : sequence of sequence of int
+        ``members[n]`` gives the original time-point indices belonging
+        to node n (in the same node order as ``g_simp.nodes()``).
+    include_members : iterable of int
+        The subset of original time points to keep.
+
+    Returns
+    -------
+    g_sub : networkx.Graph or networkx.DiGraph
+        The induced subgraph containing only nodes with at least one
+        member in ``include_members``.
+    members_sub : list of list
+        Members of each node of ``g_sub``, restricted to
+        ``include_members``.
+    sub_orig_nodeidx : list of int
+        Positional indices (into the original ``g_simp.nodes()``) of the
+        nodes kept in ``g_sub``.
+    """
+    include_set = set(include_members)
+    members_sub_all = [sorted(set(m) & include_set) for m in members]
+    sub_orig_nodeidx = [i for i, m in enumerate(members_sub_all) if len(m) > 0]
+
+    nodelist = list(g_simp.nodes())
+    sub_nodes = [nodelist[i] for i in sub_orig_nodeidx]
+    g_sub = g_simp.subgraph(sub_nodes).copy()
+    members_sub = [members_sub_all[i] for i in sub_orig_nodeidx]
+
+    return g_sub, members_sub, sub_orig_nodeidx
+
+
+def sym_dyn_to_digraph(sym_dyn):
+    """Construct a directed graph from a single time series of symbolic
+    dynamics. Port of ``symDyn2digraph.m``.
+
+    Parameters
+    ----------
+    sym_dyn : array_like of int
+        A vector of N labels (purely nominal -- numeric differences
+        between labels are irrelevant), one per time point.
+
+    Returns
+    -------
+    dg : networkx.DiGraph
+        One node per unique state in ``sym_dyn``; an edge wherever a
+        transition between two states is observed.
+    dwelltime : numpy.ndarray
+        Number of time points belonging to each state (in the same
+        order as ``dg.nodes()``).
+    nodemembers : list of numpy.ndarray
+        ``nodemembers[n]`` gives the time-point indices where the
+        system was in ``dg``'s n-th state.
+    """
+    sym_dyn = np.asarray(sym_dyn)
+    tidx = np.arange(len(sym_dyn))
+
+    state_names, state_idx = np.unique(sym_dyn, return_inverse=True)
+    dwelltime = np.bincount(state_idx, minlength=len(state_names))
+
+    dg = nx.DiGraph()
+    dg.add_nodes_from(state_names.tolist())
+
+    if len(sym_dyn) > 1:
+        changed = np.diff(sym_dyn) != 0
+        tidx_trans = tidx[:-1][changed]
+        state_s = sym_dyn[tidx_trans]
+        state_t = sym_dyn[tidx_trans + 1]
+        trans = np.unique(np.stack([state_s, state_t], axis=1), axis=0) if tidx_trans.size else np.empty((0, 2))
+        dg.add_edges_from((s, t) for s, t in trans.tolist())
+
+    nodemembers = [tidx[state_idx == n] for n in range(len(state_names))]
+
+    return dg, dwelltime, nodemembers
+
+
+def digraph_to_graph(dg):
+    """Convert a directed graph to an undirected graph, averaging the
+    weights of the two edges between each pair of nodes. Port of
+    ``digraph2graph.m``.
+
+    Parameters
+    ----------
+    dg : networkx.DiGraph
+        The directed graph to symmetrize.
+
+    Returns
+    -------
+    networkx.Graph
+    """
+    nodelist = list(dg.nodes())
+    A = nx.to_numpy_array(dg, nodelist=nodelist, weight="weight")
+    A_sym = (A + A.T) / 2
+    g = nx.from_numpy_array(A_sym)
+    return nx.relabel_nodes(g, {i: nodelist[i] for i in range(len(nodelist))})
+
+
+def find_blocks(indicator):
+    """Find the start, end, and size of contiguous True/1 runs
+    ("blocks") in a 0/1 indicator array. Port of ``findtaskn.m``.
+
+    Parameters
+    ----------
+    indicator : array_like
+        A 1D array of 0s/1s (or booleans).
+
+    Returns
+    -------
+    block_start : numpy.ndarray
+        0-indexed position of the first sample of each block.
+    block_end : numpy.ndarray
+        0-indexed position of the last sample of each block.
+    block_size : numpy.ndarray
+        Number of samples in each block.
+    """
+    ind = np.asarray(indicator).astype(int).ravel()
+
+    padded_start = np.concatenate([[0], ind])
+    block_start = np.flatnonzero(np.diff(padded_start) == 1)
+
+    padded_end = np.concatenate([ind, [0]])
+    block_end = np.flatnonzero(np.diff(padded_end) == -1)
+
+    if len(block_start) != len(block_end):
+        raise ValueError("Block structure incomplete.")
+
+    block_size = block_end - block_start + 1
+    return block_start, block_end, block_size

tmapper/knngraph.py

@@ -0,0 +1,61 @@
+"""Port of tmapper_tools/knngraph.m from the MATLAB toolbox."""
+
+import numpy as np
+import networkx as nx
+from scipy.spatial.distance import cdist
+
+
+def knngraph(X_or_D, k, *, reciprocal=True):
+    """Construct an undirected graph based on k-nearest neighbors: each
+    point is a node, linked to its k nearest neighbors.
+
+    Port of MATLAB's ``knngraph.m``. A standalone graph builder with no
+    temporal component (unlike :func:`tknndigraph`).
+
+    Parameters
+    ----------
+    X_or_D : array_like, shape (N, d) or (N, N)
+        Either raw coordinates (N points in d-dim space) or a precomputed
+        (N, N) distance matrix. Auto-detected: treated as a distance
+        matrix only if square *and* symmetric.
+    k : int
+        Number of nearest neighbors. Must be a positive integer strictly
+        less than N.
+    reciprocal : bool, default True
+        Whether to require a k-NN link to be mutual (both directions) to
+        be kept.
+
+    Returns
+    -------
+    networkx.Graph
+        Unweighted undirected graph, one node per input point.
+    """
+    X_or_D = np.asarray(X_or_D, dtype=float)
+    if X_or_D.ndim != 2:
+        raise ValueError("X_or_D must be a 2D array.")
+    if not (np.isscalar(k) and float(k) == round(float(k)) and k >= 1):
+        raise ValueError("k must be a positive integer scalar.")
+    k = int(k)
+
+    nr, nc = X_or_D.shape
+    if nr != nc or not np.allclose(X_or_D, X_or_D.T):
+        D = cdist(X_or_D, X_or_D)
+    else:
+        D = X_or_D.copy()
+    Nn = D.shape[0]
+
+    if k >= Nn:
+        raise ValueError(f"k must be smaller than the number of points ({Nn}).")
+
+    order = np.argsort(D, axis=1, kind="stable")
+    A = np.zeros((Nn, Nn), dtype=bool)
+    rows = np.repeat(np.arange(Nn), k)
+    cols = order[:, 1:1 + k].ravel()  # skip column 0: self (distance 0)
+    A[rows, cols] = True
+
+    if reciprocal:
+        A = A & A.T
+    else:
+        A = A | A.T
+
+    return nx.from_numpy_array(A)

tmapper/labeling.py

@@ -0,0 +1,45 @@
+"""Port of tmapper_tools/findnodelabel.m from the MATLAB toolbox."""
+
+import numpy as np
+from scipy import stats
+
+
+def find_node_label(members, x_label, *, labelmethod="mode"):
+    """Aggregate a per-time-point label to a per-node label.
+
+    Port of MATLAB's ``findnodelabel.m``.
+
+    Parameters
+    ----------
+    members : sequence of sequence of int
+        ``members[n]`` gives the positional indices belonging to node n.
+    x_label : array_like
+        Label/value for each time point (indexed the same way as the
+        indices inside ``members``).
+    labelmethod : {'mode', 'mean', 'median', 'none'} or callable, default 'mode'
+        How to aggregate each node's members' x_label values. A callable
+        is applied as ``labelmethod(x_label[members[n]])`` per node and
+        must return a scalar. 'none' gives every node the same label (0).
+
+    Returns
+    -------
+    numpy.ndarray, shape (len(members),)
+        The aggregated label for each node.
+    """
+    x_label = np.asarray(x_label)
+
+    if callable(labelmethod):
+        return np.array([labelmethod(x_label[list(m)]) for m in members])
+
+    if labelmethod == "mode":
+        # scipy.stats.mode returns the smallest value among ties, matching
+        # MATLAB's mode().
+        return np.array([stats.mode(x_label[list(m)], keepdims=False).mode for m in members])
+    elif labelmethod == "mean":
+        return np.array([np.mean(x_label[list(m)]) for m in members])
+    elif labelmethod == "median":
+        return np.array([np.median(x_label[list(m)]) for m in members])
+    elif labelmethod == "none":
+        return np.zeros(len(members))
+    else:
+        raise ValueError(f"Unknown labelmethod: {labelmethod!r}")