Source code for xhistogram.core

Numpy API for xhistogram.

import dask
import numpy as np
from functools import reduce
from import Iterable
from numpy import (

# range is a keyword so save the builtin so they can use it.
_range = range

    import dask.array as dsa

    has_dask = True
except ImportError:
    has_dask = False

def _any_dask_array(*args):
    if not has_dask:
        return False
        return any(isinstance(a, dsa.core.Array) for a in args)

def _ensure_correctly_formatted_bins(bins, N_expected):
    # TODO: This could be done better / more robustly
    if bins is None:
        raise ValueError("bins must be provided")
    if isinstance(bins, (int, str, np.ndarray)):
        bins = N_expected * [bins]
    if len(bins) == N_expected:
        return bins
        raise ValueError(
            "The number of bin definitions doesn't match the number of args"

def _ensure_correctly_formatted_range(range_, N_expected):
    # TODO: This could be done better / more robustly
    def _iterable_nested(x):
        return all(isinstance(i, Iterable) for i in x)

    if range_ is not None:
        if (len(range_) == 2) & (not _iterable_nested(range_)):
            return N_expected * [range_]
        elif N_expected == len(range_):
            if all(len(x) == 2 for x in range_):
                return range_
                raise ValueError(
                    "range should be provided as (lower_range, upper_range). In the "
                    + "case of multiple args, range should be a list of such tuples"
            raise ValueError("The number of ranges doesn't match the number of args")
        return N_expected * [range_]

def _bincount_2d(bin_indices, weights, N, hist_shapes):
    # a trick to apply bincount on an axis-by-axis basis
    M = bin_indices.shape[0]
    if weights is not None:
        weights = weights.ravel()
    bin_indices_offset = (bin_indices + (N * np.arange(M)[:, None])).ravel()
    bc_offset = bincount(bin_indices_offset, weights=weights, minlength=N * M)
    final_shape = (M,) + tuple(hist_shapes)
    return bc_offset.reshape(final_shape)

def _bincount_loop(bin_indices, weights, N, hist_shapes, block_chunks):
    M = bin_indices.shape[0]
    assert sum(block_chunks) == M
    block_counts = []
    # iterate over chunks
    bounds = np.cumsum((0,) + block_chunks)
    for m_start, m_end in zip(bounds[:-1], bounds[1:]):
        bin_indices_block = bin_indices[m_start:m_end]
        weights_block = weights[m_start:m_end] if weights is not None else None
        bc_block = _bincount_2d(bin_indices_block, weights_block, N, hist_shapes)
    all_counts = concatenate(block_counts)
    final_shape = (bin_indices.shape[0],) + tuple(hist_shapes)
    return all_counts.reshape(final_shape)

def _determine_block_chunks(bin_indices, block_size):
    M, N = bin_indices.shape
    if block_size is None:
        return (M,)
    if block_size == "auto":
            # dask arrays - use the pre-existing chunks
            chunks = bin_indices.chunks
            return chunks[0]
        except AttributeError:
            # automatically pick a chunk size
            # this a a heueristic without much basis
            _MAX_CHUNK_SIZE = 10_000_000
            block_size = min(_MAX_CHUNK_SIZE // N, M)
    assert isinstance(block_size, int)
    num_chunks = M // block_size
    block_chunks = num_chunks * (block_size,)
    residual = M % block_size
    if residual:
        block_chunks += (residual,)
    assert sum(block_chunks) == M
    return block_chunks

def _dispatch_bincount(bin_indices, weights, N, hist_shapes, block_size=None):
    # block_chunks is like a dask chunk, a tuple that divides up the first
    # axis of bin_indices
    block_chunks = _determine_block_chunks(bin_indices, block_size)
    if len(block_chunks) == 1:
        # single global chunk, don't need a loop over chunks
        return _bincount_2d(bin_indices, weights, N, hist_shapes)
        return _bincount_loop(bin_indices, weights, N, hist_shapes, block_chunks)

def _bincount_2d_vectorized(
    *args, bins=None, weights=None, density=False, right=False, block_size=None
    """Calculate the histogram independently on each row of a 2D array"""

    N_inputs = len(args)
    a0 = args[0]

    # consistency checks for inputa
    for a, b in zip(args, bins):
        assert a.ndim == 2
        assert b.ndim == 1
        assert a.shape == a0.shape
    if weights is not None:
        assert weights.shape == a0.shape

    nrows, ncols = a0.shape
    nbins = [len(b) for b in bins]
    hist_shapes = [nb + 1 for nb in nbins]

    # The maximum possible value of searchsorted is nbins
    # For _searchsorted_inclusive:
    #   - 0 corresponds to a < b[0]
    #   - i corresponds to b[i-1] <= a < b[i]
    #   - nbins-1 corresponds to b[-2] <= a <= b[-1]
    #   - nbins corresponds to a >= b[-1]
    def _searchsorted_inclusive(a, b):
        Like `searchsorted`, but where the last bin is also right-edge inclusive.
        # Similar to implementation in np.histogramdd
        # see
        # This assumes the bins (b) are sorted
        bin_indices = searchsorted(b, a, side="right")
        on_edge = a == b[-1]
        # Shift these points one bin to the left.
        bin_indices[on_edge] -= 1
        return bin_indices

    each_bin_indices = [_searchsorted_inclusive(a, b) for a, b in zip(args, bins)]
    # product of the bins gives the joint distribution
    if N_inputs > 1:
        bin_indices = ravel_multi_index(each_bin_indices, hist_shapes)
        bin_indices = each_bin_indices[0]
    # total number of unique bin indices
    N = reduce(lambda x, y: x * y, hist_shapes)

    bin_counts = _dispatch_bincount(
        bin_indices, weights, N, hist_shapes, block_size=block_size

    # just throw out everything outside of the bins, as np.histogram does
    # TODO: make this optional?
    slices = (slice(None),) + (N_inputs * (slice(1, -1),))
    bin_counts = bin_counts[slices]

    return bin_counts

def _bincount(
    *all_arrays, weights=False, axis=None, bins=None, density=None, block_size=None
    a0 = all_arrays[0]

    do_full_array = (axis is None) or (set(axis) == set(_range(a0.ndim)))

    if do_full_array:
        kept_axes_shape = (1,) * a0.ndim
        kept_axes_shape = tuple(
            [a0.shape[i] if i not in axis else 1 for i in _range(a0.ndim)]

    def reshape_input(a):
        if do_full_array:
            d = a.ravel()[None, :]
            # reshape the array to 2D
            # axis 0: preserved axis after histogram
            # axis 1: calculate histogram along this axis
            new_pos = tuple(_range(-len(axis), 0))
            c = np.moveaxis(a, axis, new_pos)
            split_idx = c.ndim - len(axis)
            dims_0 = c.shape[:split_idx]
            # assert dims_0 == kept_axes_shape
            dims_1 = c.shape[split_idx:]
            new_dim_0 =
            new_dim_1 =
            d = reshape(c, (new_dim_0, new_dim_1))
        return d

    all_arrays_reshaped = [reshape_input(a) for a in all_arrays]

    if weights:
        weights_array = all_arrays_reshaped.pop()
        weights_array = None

    bin_counts = _bincount_2d_vectorized(

    final_shape = kept_axes_shape + bin_counts.shape[1:]
    bin_counts = reshape(bin_counts, final_shape)

    return bin_counts

[docs]def histogram( *args, bins=None, range=None, axis=None, weights=None, density=False, block_size="auto", ): """Histogram applied along specified axis / axes. Parameters ---------- args : array_like Input data. The number of input arguments determines the dimensionality of the histogram. For example, two arguments produce a 2D histogram. All args must have the same size. bins : int, str or numpy array or a list of ints, strs and/or arrays, optional If a list, there should be one entry for each item in ``args``. The bin specifications are as follows: * If int; the number of bins for all arguments in ``args``. * If str; the method used to automatically calculate the optimal bin width for all arguments in ``args``, as defined by numpy `histogram_bin_edges`. * If numpy array; the bin edges for all arguments in ``args``. * If a list of ints, strs and/or arrays; the bin specification as above for every argument in ``args``. When bin edges are specified, all but the last (righthand-most) bin include the left edge and exclude the right edge. The last bin includes both edges. A TypeError will be raised if args or weights contains dask arrays and bins are not specified explicitly as an array or list of arrays. This is because other bin specifications trigger computation. range : (float, float) or a list of (float, float), optional If a list, there should be one entry for each item in ``args``. The range specifications are as follows: * If (float, float); the lower and upper range(s) of the bins for all arguments in ``args``. Values outside the range are ignored. The first element of the range must be less than or equal to the second. `range` affects the automatic bin computation as well. In this case, while bin width is computed to be optimal based on the actual data within `range`, the bin count will fill the entire range including portions containing no data. * If a list of (float, float); the ranges as above for every argument in ``args``. * If not provided, range is simply ``(arg.min(), arg.max())`` for each arg. axis : None or int or tuple of ints, optional Axis or axes along which the histogram is computed. The default is to compute the histogram of the flattened array weights : array_like, optional An array of weights, of the same shape as `a`. Each value in `a` only contributes its associated weight towards the bin count (instead of 1). If `density` is True, the weights are normalized, so that the integral of the density over the range remains 1. density : bool, optional If ``False``, the result will contain the number of samples in each bin. If ``True``, the result is the value of the probability *density* function at the bin, normalized such that the *integral* over the range is 1. Note that the sum of the histogram values will not be equal to 1 unless bins of unity width are chosen; it is not a probability *mass* function. block_size : int or 'auto', optional A parameter which governs the algorithm used to compute the histogram. Using a nonzero value splits the histogram calculation over the non-histogram axes into blocks of size ``block_size``, iterating over them with a loop (numpy inputs) or in parallel (dask inputs). If ``'auto'``, blocks will be determined either by the underlying dask chunks (dask inputs) or an experimental built-in heuristic (numpy inputs). Returns ------- hist : array The values of the histogram. bin_edges : list of arrays Return the bin edges for each input array. See Also -------- numpy.histogram, numpy.bincount, numpy.searchsorted """ a0 = args[0] ndim = a0.ndim n_inputs = len(args) is_dask_array = any([dask.is_dask_collection(a) for a in list(args) + [weights]]) if axis is not None: axis = np.atleast_1d(axis) assert axis.ndim == 1 axis_normed = [] for ax in axis: if ax >= 0: ax_positive = ax else: ax_positive = ndim + ax assert ax_positive < ndim, "axis must be less than ndim" axis_normed.append(ax_positive) axis = [int(i) for i in axis_normed] all_arrays = list(args) n_inputs = len(all_arrays) if weights is not None: all_arrays.append(weights) has_weights = True else: has_weights = False dtype = "i8" if not has_weights else weights.dtype # Broadcast input arrays. Note that this dispatches to `dsa.broadcast_arrays` as necessary. all_arrays = broadcast_arrays(*all_arrays) # Since all arrays now have the same shape, just get the axes of the first. input_axes = tuple(_range(all_arrays[0].ndim)) # Some sanity checks and format bins and range correctly bins = _ensure_correctly_formatted_bins(bins, n_inputs) range = _ensure_correctly_formatted_range(range, n_inputs) # histogram_bin_edges triggers computation on dask arrays. It would be possible # to write a version of this that doesn't trigger when `range` is provided, but # for now let's just use np.histogram_bin_edges if is_dask_array: if not all(isinstance(b, np.ndarray) for b in bins): raise TypeError( "When using dask arrays, bins must be provided as numpy array(s) of edges" ) else: bins = [ np.histogram_bin_edges( a, bins=b, range=r, weights=all_arrays[-1] if has_weights else None ) for a, b, r in zip(all_arrays, bins, range) ] bincount_kwargs = dict( weights=has_weights, axis=axis, bins=bins, density=density, block_size=block_size, ) # remove these axes from the inputs if axis is not None: drop_axes = tuple(axis) else: drop_axes = input_axes if _any_dask_array(weights, *all_arrays): # We should be able to just apply the bin_count function to every # block and then sum over all blocks to get the total bin count. # The main challenge is to figure out the chunk shape that will come # out of _bincount. We might also need to add dummy dimensions to sum # over in the _bincount function import dask.array as dsa # Important note from blockwise docs # > Any index, like i missing from the output index is interpreted as a contraction... # > In the case of a contraction the passed function should expect an iterable of blocks # > on any array that holds that index. # This means that we need to have all the input indexes present in the output index # However, they will be reduced to singleton (len 1) dimensions adjust_chunks = {i: (lambda x: 1) for i in drop_axes} new_axes_start = max(input_axes) + 1 new_axes = {new_axes_start + i: len(bin) - 1 for i, bin in enumerate(bins)} out_index = input_axes + tuple(new_axes) blockwise_args = [] for arg in all_arrays: blockwise_args.append(arg) blockwise_args.append(input_axes) bin_counts = dsa.blockwise( _bincount, out_index, *blockwise_args, new_axes=new_axes, adjust_chunks=adjust_chunks, meta=np.array((), dtype), **bincount_kwargs, ) # sum over the block dims bin_counts = bin_counts.sum(drop_axes) else: # drop the extra axis used for summing over blocks bin_counts = _bincount(*all_arrays, **bincount_kwargs).squeeze(drop_axes) if density: # Normalize by dividing by bin counts and areas such that all the # histogram data integrated over all dimensions = 1 bin_widths = [np.diff(b) for b in bins] if n_inputs == 1: bin_areas = bin_widths[0] elif n_inputs == 2: bin_areas = np.outer(*bin_widths) else: # Slower, but N-dimensional logic bin_areas =*bin_widths)) # Sum over the last n_inputs axes, which correspond to the bins. All other axes # are "bystander" axes. Sums must be done independently for each bystander axes # so that nans are dealt with correctly (#51) bin_axes = tuple(_range(-n_inputs, 0)) bin_count_sums = bin_counts.sum(axis=bin_axes) bin_count_sums_shape = bin_count_sums.shape + len(bin_axes) * (1,) h = bin_counts / bin_areas / reshape(bin_count_sums, bin_count_sums_shape) else: h = bin_counts return h, bins