illico 0.1.0__py3-none-any.whl

illico/__init__.py

@@ -0,0 +1,3 @@
+from illico.asymptotic_wilcoxon import asymptotic_wilcoxon
+
+__all__ = ["asymptotic_wilcoxon"]

illico/asymptotic_wilcoxon.py

@@ -0,0 +1,169 @@
+import gc
+import math
+
+import anndata as ad
+import numpy as np
+import pandas as pd
+from joblib import Parallel, delayed
+from loguru import logger
+from scipy import sparse
+from tqdm.auto import tqdm
+
+from illico.ovo import ovo_mwu_over_contiguous_col_chunk
+from illico.ovr import ovr_mwu_over_col_contiguous_chunk
+from illico.utils.compile import _precompile
+from illico.utils.groups import encode_and_count_groups
+from illico.utils.memory import _log_memory_usage
+from illico.utils.ranking import check_indices_sorted_per_parcel
+
+# from illico.utils.math import _warn_log1p
+
+__all__ = ["asymptotic_wilcoxon"]
+
+
+def asymptotic_wilcoxon(
+    adata: ad.AnnData,
+    is_log1p: bool,
+    group_keys: str,
+    reference_group: str | None = None,
+    n_threads: int = 1,
+    batch_size: int = 256,
+    alternative: str = "two-sided",
+    use_continuity: bool = True,
+    layer: str | None = None,
+    precompile: bool = True,
+):
+    """Perform asymptotic Mann-Whitney tests for differential gene expression.
+
+    Mann-Whitney test is the same as Wilcoxon rank-sum test.
+
+    This function takes as input an AnnData object of shape (n-cells, n-genes) with a group
+    (e.g., perturbation) variable stored in .obs. It performs either one-versus-rest (OVR) or
+    one-versus-one (OVO) Wilcoxon-Mann-Whitney tests for each gene, depending on whether a
+    reference group is provided.
+
+    Parameters
+    ----------
+    adata:
+        Annotated data matrix of shape (n-cells, n-genes).
+    is_log1p
+        Whether the data is log1p transformed.
+    group_keys
+        Key in `adata.obs` specifying the group variable.
+    reference_group
+        Name of the reference group for OVO tests. If `None`, OVR tests are performed.
+    n_threads
+        Number of threads to use for parallel computation.
+    batch_size
+        Number of genes to process in each batch.
+    alternative
+        Type of alternative hypothesis. One of 'two-sided', 'less', or 'greater'.
+    use_continuity
+        Whether to apply continuity correction.
+    layer
+        Layer in `adata.layers` to use for the data. If `None`, uses `adata.X`.
+    precompile
+        Whether to precompile necessary functions for performance.
+
+    Returns
+    -------
+    pd.DataFrame
+        A DataFrame with MultiIndex (group, gene) containing p-values, statistics, and fold changes.
+
+    Author: Rémy Dubois
+    """
+    # TODO: add a sparsity warning inviting user to convert to sparse if possible
+    # TODO: rename group_keys
+
+    if layer is not None:
+        logger.info(f"Using layer '{layer}' for differential expression.")
+        X = adata.layers[layer]
+    else:
+        X = adata.X
+
+    # Check that the input CSR is sorted.
+    if isinstance(X, sparse.csr_matrix):
+        if not check_indices_sorted_per_parcel(X.indices, X.indptr):
+            raise ValueError(
+                "Input data matrix indices are not sorted. This is very unusual and may lead to incorrect results. "
+                "This can be the result of operations like `adata[:, np.random.choice(…)]` that do not preserve sorting."
+                "Please make sure that indices used to chunk the adata or the expression matrix have been sorted "
+                "prior to computing DE genes."
+            )
+
+    if precompile:
+        _precompile(X, reference_group)
+
+    # Process the groups information
+    raw_groups = adata.obs[group_keys].tolist()
+    unique_raw_groups, group_container = encode_and_count_groups(groups=raw_groups, ref_group=reference_group)
+    logger.info(
+        f"Found {group_container.counts.size} unique groups (min size: {group_container.counts.min()} cells; max size: {group_container.counts.max()} cells), with reference group: {reference_group}"
+    )
+    _, n_genes = X.shape
+
+    # Allocate the results dataframes
+    cols = pd.Series(adata.var_names, name="feature", dtype=str)
+    rows = pd.Series(unique_raw_groups, name="pert", dtype=str)
+    results = np.empty((len(rows), len(cols), 3), dtype=np.float64)
+
+    # Adapt batch size to leverage multithreading regarding the number of genes, if requested
+    batch_size = min(batch_size, math.ceil(n_genes / n_threads))
+    logger.trace(f"Using batch size of {batch_size} for {n_threads} threads and {n_genes} genes.")
+
+    # Compute estimated mem footprint
+    _log_memory_usage(adata, group_container, batch_size, n_threads)
+
+    # Generate batches of columns
+    bounds = np.append(np.arange(0, n_genes, batch_size), n_genes)
+    iterator = list(zip(bounds[:-1], bounds[1:]))
+    n_tests = n_genes * group_container.counts.size
+    logger.trace(f"Performing a total of {n_tests:,d} tests.")
+    with Parallel(n_threads, prefer="threads", return_as="generator_unordered") as pool:
+        with tqdm(total=n_tests, smoothing=0.0, unit="it", unit_scale=True, unit_divisor=1000) as pbar:
+            if reference_group is None:  # ovr use case
+                pbar.set_description("Running one-versus-all MannWhitney-U tests")
+                op = delayed(lambda *args: (ovr_mwu_over_col_contiguous_chunk(*args), args))
+            else:  # ovo use case
+                pbar.set_description("Running one-versus-ref MannWhitney-U tests")
+                op = delayed(lambda *args: (ovo_mwu_over_contiguous_col_chunk(*args), args))
+            for (pv, ustat, fc), args in pool(
+                op(X, lb, ub, group_container, is_log1p, use_continuity, alternative) for lb, ub in iterator
+            ):
+                # progress.update(task, advance=group_container.counts.size * (args[2] - args[1]))  # refresh after processing is done
+                pbar.update(group_container.counts.size * (args[2] - args[1]))
+                col_chunk = slice(*args[1:3])
+                results[:, col_chunk, 0] = pv
+                results[:, col_chunk, 1] = ustat
+                results[:, col_chunk, 2] = fc
+
+                # Cleanup memory
+                del pv, ustat, fc
+                gc.collect()
+
+        # Return a pd.DataFrame to index results
+        results = pd.DataFrame(
+            data=results.reshape(-1, 3),
+            index=pd.MultiIndex.from_product([rows, cols], names=["pert", "feature"]),
+            columns=["p_value", "statistic", "fold_change"],
+        )
+
+        """
+            This case is harder than the OVR use case, because:
+            1. If input is dense, then it's easy we can slice easily over rows (or group of rows) or columns and parallelize the way we want
+            2. If input is CSR, we can easily slice the perturbations, and easily slice contiguous columns
+            3. If input is CSC, we can easily slice along the columns, BUT NOT ALONG THE PERTURBATIONS because perturbations are non-contiguous along axis 0
+
+            So the answer is simple: if we want a unified parallelism scheme, it has to be along the columns. Now:
+            - For the dense use case, there is no problem.
+            - For the sparse use case, the OVO kernel requires data to be CSC, so:
+                a) If input is CSC, it means we do overall: big CSC ->  vertical chunk of CSC -> horizontal chunk of vertical chunk of CSC -> test
+                b) If input is CSR, it means we do: big CSR  ->  vertical chunk of CSR -> horizontal chunk of vertical chunk of CSR -> CSC -> test
+            For a), the second chunking is suboptimal because we chunk along 0 a CSC matrix, but because it has little columns this is fast.
+            For b), this is a lot of conversion but I believe they all happen on small matrices so this should be fine.
+
+            Conclusion: runtime on H1 is ~25 seconds for CSC, 25 seconds for CSR so still very nice.
+            TO KEEP IN MIND: there is **no** way to optimize any other parallelism than column-based actually, the current idea (parallelizing over the
+            perturbations) will be very slow, or require a brand new CSR allocation (which we don't want), to function.
+            """
+    return results

illico/ovo/__init__.py

@@ -0,0 +1,84 @@
+from typing import Literal
+
+import numpy as np
+from scipy import sparse as py_sparse
+
+from illico.ovo.dense_ovo import dense_ovo_mwu_kernel_over_contiguous_col_chunk
+from illico.ovo.sparse_ovo import (
+    csc_ovo_mwu_kernel_over_contiguous_col_chunk,
+    csr_ovo_mwu_kernel_over_contiguous_col_chunk,
+)
+from illico.utils.groups import GroupContainer
+from illico.utils.sparse.csc import CSCMatrix
+from illico.utils.sparse.csr import CSRMatrix
+from illico.utils.type import scipy_to_nb
+
+
+def ovo_mwu_over_contiguous_col_chunk(
+    X: np.ndarray | py_sparse.csc_matrix | py_sparse.csr_matrix,
+    chunk_lb: int,
+    chunk_ub: int,
+    group_container: GroupContainer,
+    is_log1p: bool,
+    use_continuity: bool = True,
+    alternative: Literal["two-sided", "less", "greater"] = "two-sided",
+):
+    """Dispatcher for the OVO ranksum test. Routes toward the optimized
+    implementation depending on input data format.
+
+    Args:
+        X (np.ndarray | py_sparse.csc_matrix | py_sparse.csr_matrix): Input expression count matrix.
+        chunk_lb (int): Vertical slicing (column) lower bound
+        chunk_ub (int): Vertical slicing (column) upper bound
+        group_container (GroupContainer): GroupContainer
+        is_log1p (bool): User-indicated flag telling if expression counts underwent log1p transfo.
+        use_continuity (bool, optional): Whether to use continuity correction when computing p-values.
+        alternative (Literal["two-sided", "less", "greater"]): Type of alternative hypothesis.
+
+    Raises:
+        ValueError: If input is neither dense, csc or csr.
+
+    Returns:
+        tuple[np.ndarray]: Two-sided p-values, U-statistics and fold change.
+        Each np.ndarray of shape (n_groups, n_genes)
+
+    Author: Rémy Dubois
+    """
+    # Convert to numba friendly dtype
+    X_nb = scipy_to_nb(X)
+
+    # Check all possible input types
+    if isinstance(X, np.ndarray):
+        pvalues, statistics, fold_change = dense_ovo_mwu_kernel_over_contiguous_col_chunk(
+            X,
+            chunk_lb,
+            chunk_ub,
+            group_container,
+            is_log1p=is_log1p,
+            use_continuity=use_continuity,
+            alternative=alternative,
+        )
+    elif isinstance(X_nb, CSCMatrix):
+        pvalues, statistics, fold_change = csc_ovo_mwu_kernel_over_contiguous_col_chunk(
+            X_nb,
+            chunk_lb,
+            chunk_ub,
+            group_container,
+            is_log1p=is_log1p,
+            use_continuity=use_continuity,
+            alternative=alternative,
+        )
+    elif isinstance(X_nb, CSRMatrix):
+        pvalues, statistics, fold_change = csr_ovo_mwu_kernel_over_contiguous_col_chunk(
+            X_nb,
+            chunk_lb,
+            chunk_ub,
+            group_container,
+            is_log1p=is_log1p,
+            use_continuity=use_continuity,
+            alternative=alternative,
+        )
+    else:
+        raise ValueError(X_nb)
+
+    return pvalues, statistics, fold_change

illico/ovo/dense_ovo.py

@@ -0,0 +1,129 @@
+from typing import Literal
+
+import numpy as np
+from numba import njit
+
+from illico.utils.groups import GroupContainer
+from illico.utils.math import chunk_and_fortranize, compute_pval, dense_fold_change
+from illico.utils.ranking import (
+    _sort_along_axis_inplace,
+    rank_sum_and_ties_from_sorted,
+)
+
+
+@njit(nogil=True, fastmath=True, parallel=False, cache=False)
+def dense_ovo_mwu_kernel(
+    sorted_ref_data: np.ndarray,
+    sorted_tgt_data: np.ndarray,
+    use_continuity: bool = True,
+    alternative: Literal["two-sided", "less", "greater"] = "two-sided",
+) -> tuple[np.ndarray]:
+    """Sequentially perform OVO tests on columns between sorted ref and sorted perturbed data.
+
+    Args:
+        sorted_ref_data (np.ndarray): Vertically sorted reference data.
+        sorted_tgt_data (_type_): Vertically sorted perturbed data.
+        use_continuity (bool, optional): Apply continuity factor or not . Defaults to True.
+        alternative (Literal["two-sided", "less", "greater"]): Type of alternative hypothesis
+
+    Returns:
+        tuple[np.ndarray]: two-sided p-values, U-statistics. Each of shape (n_genes,).
+
+    Author: Rémy Dubois
+    """
+    n_ref, ncols = sorted_ref_data.shape
+    n_tgt, _ = sorted_tgt_data.shape
+
+    U_statistics = np.empty(ncols, dtype=np.float64)
+    pvals = np.empty(ncols, dtype=np.float64)
+    n = n_ref + n_tgt
+    mu = n_ref * n_tgt / 2.0
+    for j in range(ncols):
+        R1, tie_sum = rank_sum_and_ties_from_sorted(sorted_ref_data[:, j], sorted_tgt_data[:, j])
+
+        # Compute U-stat
+        U1 = n_ref * n_tgt + n_tgt * (n_tgt + 1) / 2 - R1
+
+        pvals[j] = compute_pval(
+            n_ref=n_ref,
+            n_tgt=n_tgt,
+            n=n,
+            tie_sum=tie_sum,
+            U=U1,
+            mu=mu,
+            contin_corr=0.5 if use_continuity else 0.0,
+            alternative=alternative,
+        )
+        U_statistics[j] = U1
+
+    return pvals, U_statistics
+
+
+@njit(nogil=True, fastmath=True, cache=False, boundscheck=False)
+def dense_ovo_mwu_kernel_over_contiguous_col_chunk(
+    X: np.ndarray,
+    chunk_lb: int,
+    chunk_ub: int,
+    grpc: GroupContainer,
+    is_log1p: bool,
+    use_continuity: bool = True,
+    alternative: Literal["two-sided", "less", "greater"] = "two-sided",
+) -> tuple[np.ndarray]:
+    """Perform OVO tests group-wise and gene(col)-wise.
+
+    Update: There is no need to fortranize the whole chunk at once, it can be done group by group within the loop. The memo
+
+    Memory footprint investigations:
+    1. ad.read_h5ad allocates memory in such a weird way that zeros are not properly assigned. Most likely this differs on unix systems. All investigations done on my MBP were so weird because of that.
+    Tests were so weird because during the wilcoxon test, values were accessed and re-ordered and all those things. As a result, some memory allocation was happening within my functions although
+    I was not allocating anything.
+    2. np.asfortranarray(X[:, chunk_lb:chunk_ub][grpc.indices]) seems to allocate 2x the memory needed for the chunk. So if chunk is 2GB, this line allocates 4GB temporarily.
+    3.
+
+
+    Args:
+        X (np.ndarray): Input dense expression matrix of shape (n_cells, n_genes)
+        chunk_lb (int): Lower bound of the vertical slicing
+        chunk_ub (int): Upper bound of the vertical slicing
+        grpc (GroupContainer): GroupContainer, contains information about which group each row belongs to.
+        use_continuity (bool, optional): Apply continuity factor or not. Defaults to True.
+        is_log1p (bool, optional): User-indicated flag telling if data underwent log1p transform or not. Defaults to False.
+
+    Raises:
+        ValueError: If bounds are not intelligible.
+
+    Returns:
+        tuple[np.ndarray]: two-sided p-values, U-statistics, fold change. Each
+        of shape (n_groups, chunk_ub - chunk_lb).
+
+    Author: Rémy Dubois
+    """
+    chunk = X[:, chunk_lb:chunk_ub]
+    n_groups = grpc.counts.size
+
+    ref_indices = grpc.indices[grpc.indptr[grpc.encoded_ref_group] : grpc.indptr[grpc.encoded_ref_group + 1]]
+    # TODO: still have to benchmark speedup of F order
+    ref_chunk = chunk_and_fortranize(X, chunk_lb, chunk_ub, ref_indices)
+    _sort_along_axis_inplace(ref_chunk, axis=0)
+
+    pvalues = np.empty((n_groups, chunk_ub - chunk_lb), dtype=np.float64)
+    statistics = np.empty((n_groups, chunk_ub - chunk_lb), dtype=np.float64)
+    for group_id in range(n_groups):
+        if group_id == grpc.encoded_ref_group:
+            continue
+        tgt_indices = grpc.indices[grpc.indptr[group_id] : grpc.indptr[group_id + 1]]
+        # tgt_chunk = np.asfortranarray(chunk[tgt_indices, :])
+        tgt_chunk = chunk_and_fortranize(X, chunk_lb, chunk_ub, tgt_indices)
+        _sort_along_axis_inplace(tgt_chunk, axis=0)
+
+        pvalues[group_id], statistics[group_id] = dense_ovo_mwu_kernel(
+            sorted_ref_data=ref_chunk,
+            sorted_tgt_data=tgt_chunk,
+            use_continuity=use_continuity,
+            alternative=alternative,
+        )
+
+    # Compute fold change
+    fc = dense_fold_change(chunk, grpc, is_log1p=is_log1p)
+
+    return pvalues, statistics, fc

illico/ovo/sparse_ovo.py

@@ -0,0 +1,247 @@
+from typing import Literal
+
+import numpy as np
+from numba import njit
+
+from illico.utils.groups import GroupContainer
+from illico.utils.math import compute_pval, diff
+from illico.utils.ranking import (
+    _sort_csc_columns_inplace,
+    rank_sum_and_ties_from_sorted,
+)
+from illico.utils.sparse.csc import csc_get_contig_cols_into_csr
+from illico.utils.sparse.csr import (
+    csr_fold_change,
+    csr_get_contig_cols_into_csr,
+    csr_get_rows_into_csc,
+)
+from illico.utils.type import CSCMatrix, CSRMatrix
+
+
+@njit(nogil=True, fastmath=True, cache=False)
+def single_group_sparse_ovo_mwu_kernel(
+    sorted_ref_data: CSCMatrix,
+    sorted_tgt_data: CSCMatrix,
+    use_continuity: bool = True,
+    alternative: Literal["two-sided", "less", "greater"] = "two-sided",
+) -> tuple[np.ndarray]:
+    """Perform OVO tests gene wise using the two **sorted** CSC matrix given as input.
+
+    The test performed is the equivalent of:
+    `scipy.stats.mannwhitneyu(sorted_ref_data.toarray(), sorted_tgt_data.toarray(), use_continuity=True)`
+
+    Args:
+        sorted_ref_data (CSCMatrix): Reference data stored in CSC, sorted column-wise
+        sorted_tgt_data (CSCMatrix): Perturbed data stored in CSC, sorted column-wise
+        use_continuity (bool, optional): Apply continuity factor or not. Defaults to True.
+        alternative (Literal["two-sided", "less", "greater"]): Type of alternative hypothesis
+
+    Raises:
+        ValueError: If shape mismatche
+
+    Returns:
+        tuple[np.ndarray]: two-sided p-values, U-statistics. Each of shape (n_genes,).
+
+    Author: Rémy Dubois
+    """
+
+    n_ref, n_cols_ref = sorted_ref_data.shape
+    n_tgt, n_cols_tgt = sorted_tgt_data.shape
+    # TODO: make this check everywhere or nowhere
+    if n_cols_ref != n_cols_tgt:
+        raise ValueError("Uneven number of columns between ref and perturbed.")
+
+    # Allocate placeholders
+    n_zeros_tgt = (n_tgt - diff(sorted_tgt_data.indptr)).astype(np.int64)
+    n_zeros_ref = (n_ref - diff(sorted_ref_data.indptr)).astype(np.int64)
+    U_statistics = np.empty(n_cols_ref, dtype=np.float64)
+    pvals = np.empty(n_cols_ref, dtype=np.float64)
+    n = n_ref + n_tgt
+    mu = n_ref * n_tgt / 2.0
+    for j in range(n_cols_ref):
+        n_zeros_combined = n_zeros_ref[j] + n_zeros_tgt[j]
+        # Get the bounds
+        lbt, ubt = sorted_tgt_data.indptr[j], sorted_tgt_data.indptr[j + 1]
+        lbr, ubr = sorted_ref_data.indptr[j], sorted_ref_data.indptr[j + 1]
+
+        # Compute ranksum and tie sum for non zero values
+        ranksum, tie_sum = rank_sum_and_ties_from_sorted(sorted_ref_data.data[lbr:ubr], sorted_tgt_data.data[lbt:ubt])
+
+        # Offset the ranks of the number of zeros in ref and perturbed
+        ranksum += n_zeros_combined * (ubt - lbt)
+
+        # Compute ranksum
+        n0 = n_zeros_tgt[j]
+        R1_nz = ranksum  # Sum ranks
+        R1 = R1_nz + n0 * (n_zeros_ref[j] + n0 + 1) / 2.0  # Add sumranks of zeros
+
+        # Compute U-stat
+        U1 = n_ref * n_tgt + n_tgt * (n_tgt + 1) / 2 - R1
+
+        # Compute sigma
+        tie_sum += n_zeros_combined**3 - n_zeros_combined
+        pvals[j] = compute_pval(
+            n_ref=n_ref,
+            n_tgt=n_tgt,
+            n=n,
+            tie_sum=tie_sum,
+            U=U1,
+            mu=mu,
+            contin_corr=0.5 if use_continuity else 0.0,
+            alternative=alternative,
+        )
+
+        # Regardless of the alternative, always return U1 like scipy
+        U_statistics[j] = U1
+
+    return pvals, U_statistics
+
+
+@njit(nogil=True, fastmath=True, cache=False)
+def multi_group_sparse_ovo_mwu_kernel(
+    X: CSRMatrix,
+    grpc: GroupContainer,
+    ref_group_id: int,
+    use_continuity: bool = True,
+    alternative: Literal["two-sided", "less", "greater"] = "two-sided",
+) -> tuple[np.ndarray]:
+    """Sequentially perform group-wise OVO tests along the columns on a CSR matrix.
+
+    Args:
+        X (CSRMatrix): Input CSR matrix of shape (n_cells, n_genes)
+        grpc (GroupContainer): GroupContainer
+        ref_group_id (int): Encoded reference group ID.
+        use_continuity (bool, optional): Whether to use continuity correction when computing p-values. Defaults to True.
+        alternative (Literal["two-sided", "less", "greater"]): Type of alternative hypothesis
+
+    Returns:
+        tuple[np.ndarray]: two-sided p-values, U-statistics. Each of shape (n_groups, n_genes).
+
+    Author: Rémy Dubois
+    """
+    # Avoid accessing attributes in the for loop
+    group_indices = grpc.indices
+    group_indptr = grpc.indptr
+    # Now, get the ref group, and convert it back to CSC because the test requires CSC data
+    n_groups = group_indptr.size - 1
+    ref_indices = group_indices[group_indptr[ref_group_id] : group_indptr[ref_group_id + 1]]
+    csc_X_ref = csr_get_rows_into_csc(X, ref_indices)
+    _sort_csc_columns_inplace(csc_matrix=csc_X_ref)
+
+    # Now go through all the groups one by one
+    pvalues = np.empty((n_groups, X.shape[1]), dtype=np.float64)
+    statistics = np.empty((n_groups, X.shape[1]), dtype=np.float64)
+    for group_id in range(group_indptr.size - 1):
+        if group_id == ref_group_id:
+            pvalues[group_id, :] = 1.0
+            statistics[group_id, :] = -1.0
+            continue
+
+        tgt_idxs = group_indices[group_indptr[group_id] : group_indptr[group_id + 1]]
+        X_tgt = csr_get_rows_into_csc(X, tgt_idxs)
+        _sort_csc_columns_inplace(X_tgt)
+        pvalue, statistic = single_group_sparse_ovo_mwu_kernel(
+            sorted_ref_data=csc_X_ref, sorted_tgt_data=X_tgt, use_continuity=use_continuity, alternative=alternative
+        )
+        pvalues[group_id, :] = pvalue
+        statistics[group_id, :] = statistic
+
+    return pvalues, statistics
+
+
+# Not jitting this and sorting all the cells at once is 1.5x slower. Ideally, it would be faster to sort only groups one by one but
+# doubt this would be enough faster (think of mergesort) => It is twice faster, so i dont think it will bridge the gap
+@njit(nogil=True, fastmath=True, cache=False)  # This requires too many caching, too dangerous
+def csc_ovo_mwu_kernel_over_contiguous_col_chunk(
+    X: CSCMatrix,
+    chunk_lb: int,
+    chunk_ub: int,
+    grpc: GroupContainer,
+    is_log1p: bool,
+    use_continuity: bool = True,
+    alternative: Literal["two-sided", "less", "greater"] = "two-sided",
+):
+    """Perform OVO test over contiguous chunk of column of a CSC matrix.
+
+    Args:
+        X (CSCMatrix): Input matrix of shape (n_cells, n_genes)
+        chunk_lb (int): Lower bound of the vertical slicing
+        chunk_ub (int): Upper bound of the vertical slicing
+        grpc (GroupContainer): GroupContainer
+        is_log1p (bool): User-indicated flag telling if data underwent log1p transform.
+
+    Raises:
+        ValueError: If chunk bounds are inintelligible.
+
+    Returns:
+        tuple[np.ndarray]: two-sided p-values, U-statistics, fold change. Each
+        of shape (n_groups, chunk_ub - chunk_lb).
+
+    Author: Rémy Dubois
+    """
+    if chunk_lb < 0 or chunk_ub > X.shape[1] or chunk_lb > chunk_ub:
+        raise ValueError((chunk_lb, chunk_ub))
+
+    # This copies the data, so all that follow can happen in-place
+    csr_chunk = csc_get_contig_cols_into_csr(X, chunk_lb, chunk_ub)
+    pvalues, statistics = multi_group_sparse_ovo_mwu_kernel(
+        X=csr_chunk,
+        grpc=grpc,
+        ref_group_id=grpc.encoded_ref_group,
+        use_continuity=use_continuity,
+        alternative=alternative,
+    )
+
+    # Compute fold change
+    fold_change = csr_fold_change(csr_chunk, grpc, is_log1p=is_log1p)
+
+    return pvalues, statistics, fold_change
+
+
+# Real scale tests on whole H1 showed 24secs on 8 threads and 2min45s on 1, so a speedup of 165 / 24 = 6.875x
+@njit(nogil=True, fastmath=True, cache=False)
+def csr_ovo_mwu_kernel_over_contiguous_col_chunk(
+    X: CSRMatrix,
+    chunk_lb: int,
+    chunk_ub: int,
+    grpc: GroupContainer,
+    is_log1p: bool,
+    use_continuity: bool = True,
+    alternative: Literal["two-sided", "less", "greater"] = "two-sided",
+):
+    """Perform OVO test over contiguous chunk of column of a CSR matrix.
+
+    Args:
+        X (CSRMatrix): Input matrix of shape (n_cells, n_genes)
+        chunk_lb (int): Lower bound of the vertical slicing
+        chunk_ub (int): Upper bound of the vertical slicing
+        grpc (GroupContainer): GroupContainer
+        is_log1p (bool): User-indicated flag telling if data underwent log1p transform.
+        use_continuity (bool): Whether to use continuity correction when computing p-values.
+        alternative (Literal["two-sided", "less", "greater"]): Type of alternative hypothesis
+
+    Raises:
+        ValueError: If chunk bounds are inintelligible.
+
+    Returns:
+        tuple[np.ndarray]: two-sided p-values, U-statistics, fold change. Each
+        of shape (n_groups, chunk_ub - chunk_lb).
+
+    Author: Rémy Dubois
+    """
+    if chunk_lb < 0 or chunk_ub > X.shape[1] or chunk_lb > chunk_ub:
+        raise ValueError((chunk_lb, chunk_ub))
+
+    # This copies the data, so all that follow can happen in-place
+    csr_chunk = csr_get_contig_cols_into_csr(X, chunk_lb, chunk_ub)
+    pvalues, statistics = multi_group_sparse_ovo_mwu_kernel(
+        X=csr_chunk,
+        grpc=grpc,
+        ref_group_id=grpc.encoded_ref_group,
+        use_continuity=use_continuity,
+        alternative=alternative,
+    )
+    # Compute fold change
+    fold_change = csr_fold_change(csr_chunk, grpc, is_log1p=is_log1p)
+
+    return pvalues, statistics, fold_change