# API

## Top level functions

`abs`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.absolute.
`absolute`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.absolute.
`add`(x1, x2, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.add.
`all`(a[, axis, keepdims, split_every, out]) | Test whether all array elements along a given axis evaluate to True.
`allclose`(arr1, arr2[, rtol, atol, equal_nan]) | Returns True if two arrays are element-wise equal within a tolerance.
`angle`(x[, deg]) | Return the angle of the complex argument.
`any`(a[, axis, keepdims, split_every, out]) | Test whether any array element along a given axis evaluates to True.
`append`(arr, values[, axis]) | Append values to the end of an array.
`apply_along_axis`(func1d, axis, arr, *args[, ...]) | Apply a function to 1-D slices along the given axis.
`apply_over_axes`(func, a, axes) | Apply a function repeatedly over multiple axes.
`arange`(*args[, chunks, like, dtype]) | Return evenly spaced values from start to stop with step size step.
`arccos`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.arccos.
`arccosh`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.arccosh.
`arcsin`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.arcsin.
`arcsinh`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.arcsinh.
`arctan`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.arctan.
`arctan2`(x1, x2, /[, out, where, casting, ...]) | This docstring was copied from numpy.arctan2.
`arctanh`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.arctanh.
`argmax`(a[, axis, keepdims, split_every, out]) | Returns the indices of the maximum values along an axis.
`argmin`(a[, axis, keepdims, split_every, out]) | Returns the indices of the minimum values along an axis.
`argtopk`(a, k[, axis, split_every]) | Extract the indices of the k largest elements from a on the given axis, and return them sorted from largest to smallest.
`argwhere`(a) | Find the indices of array elements that are non-zero, grouped by element.
`around`(x[, decimals]) | Round an array to the given number of decimals.
`array`(object[, dtype, copy, order, subok, ...]) | This docstring was copied from numpy.array.
`asanyarray`(a[, dtype, order, like, inline_array]) | Convert the input to a dask array.
`asarray`(a[, allow_unknown_chunksizes, ...]) | Convert the input to a dask array.
`atleast_1d`(*arys) | Convert inputs to arrays with at least one dimension.
`atleast_2d`(*arys) | View inputs as arrays with at least two dimensions.
`atleast_3d`(*arys) | View inputs as arrays with at least three dimensions.
`average`(a[, axis, weights, returned, keepdims]) | Compute the weighted average along the specified axis.
`bincount`(x, /[, weights, minlength]) | This docstring was copied from numpy.bincount.
`bitwise_and`(x1, x2, /[, out, where, ...]) | This docstring was copied from numpy.bitwise_and.
`bitwise_not`(x, /[, out, where, casting, ...]) | This docstring was copied from numpy.invert.
`bitwise_or`(x1, x2, /[, out, where, casting, ...]) | This docstring was copied from numpy.bitwise_or.
`bitwise_xor`(x1, x2, /[, out, where, ...]) | This docstring was copied from numpy.bitwise_xor.
`block`(arrays[, allow_unknown_chunksizes]) | Assemble an nd-array from nested lists of blocks.
`blockwise`(func, out_ind, *args[, name, ...]) | Tensor operation: Generalized inner and outer products
`broadcast_arrays`(*args[, subok]) | Broadcast any number of arrays against each other.
`broadcast_to`(x, shape[, chunks, meta]) | Broadcast an array to a new shape.
`cbrt`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.cbrt.
`coarsen`(reduction, x, axes[, trim_excess]) | Coarsen array by applying reduction to fixed size neighborhoods
`ceil`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.ceil.
`choose`(a, choices) | Construct an array from an index array and a list of arrays to choose from.
`clip`(*args, **kwargs) | Clip (limit) the values in an array.
`compress`(condition, a[, axis]) | Return selected slices of an array along given axis.
`concatenate`(seq[, axis, ...]) | Concatenate arrays along an existing axis
`conj`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.conjugate.
`copysign`(x1, x2, /[, out, where, casting, ...]) | This docstring was copied from numpy.copysign.
`corrcoef`(x[, y, rowvar]) | Return Pearson product-moment correlation coefficients.
`cos`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.cos.
`cosh`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.cosh.
`count_nonzero`(a[, axis]) | Counts the number of non-zero values in the array `a`.
`cov`(m[, y, rowvar, bias, ddof]) | Estimate a covariance matrix, given data and weights.
`cumprod`(x[, axis, dtype, out, method]) | Return the cumulative product of elements along a given axis.
`cumsum`(x[, axis, dtype, out, method]) | Return the cumulative sum of the elements along a given axis.
`deg2rad`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.deg2rad.
`degrees`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.degrees.
`delete`(arr, obj, axis) | Return a new array with sub-arrays along an axis deleted.
`diag`(v[, k]) | Extract a diagonal or construct a diagonal array.
`diagonal`(a[, offset, axis1, axis2]) | Return specified diagonals.
`diff`(a[, n, axis, prepend, append]) | Calculate the n-th discrete difference along the given axis.
`divide`(x1, x2, /[, out, where, casting, ...]) | This docstring was copied from numpy.divide.
`divmod`(x1, x2[, out1, out2], / [[, out, ...]) | This docstring was copied from numpy.divmod.
`digitize`(a, bins[, right]) | Return the indices of the bins to which each value in input array belongs.
`dot`(a, b[, out]) | This docstring was copied from numpy.dot.
`dstack`(tup[, allow_unknown_chunksizes]) | Stack arrays in sequence depth wise (along third axis).
`ediff1d`(ary[, to_end, to_begin]) | The differences between consecutive elements of an array.
`einsum`(subscripts, *operands[, out, dtype, ...]) | This docstring was copied from numpy.einsum.
`empty`(*args, **kwargs) | Blocked variant of empty_like
`empty_like`(a[, dtype, order, chunks, name, ...]) | Return a new array with the same shape and type as a given array.
`equal`(x1, x2, /[, out, where, casting, ...]) | This docstring was copied from numpy.equal.
`exp`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.exp.
`exp2`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.exp2.
`expand_dims`(a, axis) | Expand the shape of an array.
`expm1`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.expm1.
`extract`(condition, arr) | Return the elements of an array that satisfy some condition.
`eye`(N[, chunks, M, k, dtype]) | Return a 2-D Array with ones on the diagonal and zeros elsewhere.
`fabs`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.fabs.
`fix`(*args, **kwargs) | Round to nearest integer towards zero.
`flatnonzero`(a) | Return indices that are non-zero in the flattened version of a.
`flip`(m[, axis]) | Reverse element order along axis.
`flipud`(m) | Reverse the order of elements along axis 0 (up/down).
`fliplr`(m) | Reverse the order of elements along axis 1 (left/right).
`float_power`(x1, x2, /[, out, where, ...]) | This docstring was copied from numpy.float_power.
`floor`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.floor.
`floor_divide`(x1, x2, /[, out, where, ...]) | This docstring was copied from numpy.floor_divide.
`fmax`(x1, x2, /[, out, where, casting, ...]) | This docstring was copied from numpy.fmax.
`fmin`(x1, x2, /[, out, where, casting, ...]) | This docstring was copied from numpy.fmin.
`fmod`(x1, x2, /[, out, where, casting, ...]) | This docstring was copied from numpy.fmod.
`frexp`(x[, out1, out2], / [[, out, where, ...]) | This docstring was copied from numpy.frexp.
`fromfunction`(func[, chunks, shape, dtype]) | Construct an array by executing a function over each coordinate.
`frompyfunc`(func, /, nin, nout, *[, identity]) | This docstring was copied from numpy.frompyfunc.
`full`(shape, fill_value, *args, **kwargs) | Blocked variant of full_like
`full_like`(a, fill_value[, order, dtype, ...]) | Return a full array with the same shape and type as a given array.
`gradient`(f, *varargs[, axis]) | Return the gradient of an N-dimensional array.
`greater`(x1, x2, /[, out, where, casting, ...]) | This docstring was copied from numpy.greater.
`greater_equal`(x1, x2, /[, out, where, ...]) | This docstring was copied from numpy.greater_equal.
`histogram`(a[, bins, range, normed, weights, ...]) | Blocked variant of `numpy.histogram()`.
`histogram2d`(x, y[, bins, range, normed, ...]) | Blocked variant of `numpy.histogram2d()`.
`histogramdd`(sample, bins[, range, normed, ...]) | Blocked variant of `numpy.histogramdd()`.
`hstack`(tup[, allow_unknown_chunksizes]) | Stack arrays in sequence horizontally (column wise).
`hypot`(x1, x2, /[, out, where, casting, ...]) | This docstring was copied from numpy.hypot.
`i0`(*args, **kwargs) | Modified Bessel function of the first kind, order 0.
`imag`(*args, **kwargs) | Return the imaginary part of the complex argument.
`indices`(dimensions[, dtype, chunks]) | Implements NumPy's `indices` for Dask Arrays.
`insert`(arr, obj, values, axis) | Insert values along the given axis before the given indices.
`invert`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.invert.
`isclose`(arr1, arr2[, rtol, atol, equal_nan]) | Returns a boolean array where two arrays are element-wise equal within a tolerance.
`iscomplex`(*args, **kwargs) | Returns a bool array, where True if input element is complex.
`isfinite`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.isfinite.
`isin`(element, test_elements[, ...]) | Calculates `element in test_elements`, broadcasting over element only.
`isinf`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.isinf.
`isneginf` | This docstring was copied from numpy.equal.
`isnan`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.isnan.
`isnull`(values) | pandas.isnull for dask arrays
`isposinf` | This docstring was copied from numpy.equal.
`isreal`(*args, **kwargs) | Returns a bool array, where True if input element is real.
`ldexp`(x1, x2, /[, out, where, casting, ...]) | This docstring was copied from numpy.ldexp.
`left_shift`(x1, x2, /[, out, where, casting, ...]) | This docstring was copied from numpy.left_shift.
`less`(x1, x2, /[, out, where, casting, ...]) | This docstring was copied from numpy.less.
`less_equal`(x1, x2, /[, out, where, casting, ...]) | This docstring was copied from numpy.less_equal.
`linspace`(start, stop[, num, endpoint, ...]) | Return num evenly spaced values over the closed interval [start, stop].
`log`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.log.
`log10`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.log10.
`log1p`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.log1p.
`log2`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.log2.
`logaddexp`(x1, x2, /[, out, where, casting, ...]) | This docstring was copied from numpy.logaddexp.
`logaddexp2`(x1, x2, /[, out, where, casting, ...]) | This docstring was copied from numpy.logaddexp2.
`logical_and`(x1, x2, /[, out, where, ...]) | This docstring was copied from numpy.logical_and.
`logical_not`(x, /[, out, where, casting, ...]) | This docstring was copied from numpy.logical_not.
`logical_or`(x1, x2, /[, out, where, casting, ...]) | This docstring was copied from numpy.logical_or.
`logical_xor`(x1, x2, /[, out, where, ...]) | This docstring was copied from numpy.logical_xor.
`map_overlap`(func, *args[, depth, boundary, ...]) | Map a function over blocks of arrays with some overlap
`map_blocks`(func, *args[, name, token, ...]) | Map a function across all blocks of a dask array.
`matmul`(x1, x2, /[, out, casting, order, ...]) | This docstring was copied from numpy.matmul.
`max`(a[, axis, keepdims, split_every, out]) | Return the maximum of an array or maximum along an axis.
`maximum`(x1, x2, /[, out, where, casting, ...]) | This docstring was copied from numpy.maximum.
`mean`(a[, axis, dtype, keepdims, ...]) | Compute the arithmetic mean along the specified axis.
`median`(a[, axis, keepdims, out]) | Compute the median along the specified axis.
`meshgrid`(*xi[, sparse, indexing]) | Return a tuple of coordinate matrices from coordinate vectors.
`min`(a[, axis, keepdims, split_every, out]) | Return the minimum of an array or minimum along an axis.
`minimum`(x1, x2, /[, out, where, casting, ...]) | This docstring was copied from numpy.minimum.
`mod`(x1, x2, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.remainder.
`modf`(x[, out1, out2], / [[, out, where, ...]) | This docstring was copied from numpy.modf.
`moment`(a, order[, axis, dtype, keepdims, ...]) | Calculate the nth centralized moment.
`moveaxis`(a, source, destination) | Move axes of an array to new positions.
`multiply`(x1, x2, /[, out, where, casting, ...]) | This docstring was copied from numpy.multiply.
`nanargmax`(a[, axis, keepdims, split_every, out]) | Return the indices of the maximum values in the specified axis ignoring NaNs.
`nanargmin`(a[, axis, keepdims, split_every, out]) | Return the indices of the minimum values in the specified axis ignoring NaNs.
`nancumprod`(x, axis[, dtype, out, method]) | Return the cumulative product of array elements over a given axis treating Not a Numbers (NaNs) as one.
`nancumsum`(x, axis[, dtype, out, method]) | Return the cumulative sum of array elements over a given axis treating Not a Numbers (NaNs) as zero.
`nanmax`(a[, axis, keepdims, split_every, out]) | Return the maximum of an array or maximum along an axis, ignoring any NaNs.
`nanmean`(a[, axis, dtype, keepdims, ...]) | Compute the arithmetic mean along the specified axis, ignoring NaNs.
`nanmedian`(a[, axis, keepdims, out]) | Compute the median along the specified axis, while ignoring NaNs.
`nanmin`(a[, axis, keepdims, split_every, out]) | Return minimum of an array or minimum along an axis, ignoring any NaNs.
`nanprod`(a[, axis, dtype, keepdims, ...]) | Return the product of array elements over a given axis treating Not a Numbers (NaNs) as ones.
`nanquantile`(a, q[, axis, out, ...]) | Compute the qth quantile of the data along the specified axis, while ignoring nan values.
`nanpercentile`(a, q, **kwargs) | Compute the qth percentile of the data along the specified axis, while ignoring nan values.
`nanstd`(a[, axis, dtype, keepdims, ddof, ...]) | Compute the standard deviation along the specified axis, while ignoring NaNs.
`nansum`(a[, axis, dtype, keepdims, ...]) | Return the sum of array elements over a given axis treating Not a Numbers (NaNs) as zero.
`nanvar`(a[, axis, dtype, keepdims, ddof, ...]) | Compute the variance along the specified axis, while ignoring NaNs.
`nan_to_num`(*args, **kwargs) | Replace NaN with zero and infinity with large finite numbers (default behaviour) or with the numbers defined by the user using the nan, posinf and/or neginf keywords.
`negative`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.negative.
`nextafter`(x1, x2, /[, out, where, casting, ...]) | This docstring was copied from numpy.nextafter.
`nonzero`(a) | Return the indices of the elements that are non-zero.
`not_equal`(x1, x2, /[, out, where, casting, ...]) | This docstring was copied from numpy.not_equal.
`notnull`(values) | pandas.notnull for dask arrays
`ones`(*args, **kwargs) | Blocked variant of ones_like
`ones_like`(a[, dtype, order, chunks, name, shape]) | Return an array of ones with the same shape and type as a given array.
`outer`(a, b) | Compute the outer product of two vectors.
`pad`(array, pad_width[, mode]) | Pad an array.
`percentile`(a, q[, method, internal_method]) | Approximate percentile of 1-D array
`push`(array, n, axis) | Dask-version of bottleneck.push
`PerformanceWarning` | A warning given when bad chunking may cause poor performance
`piecewise`(x, condlist, funclist, *args, **kw) | Evaluate a piecewise-defined function.
`positive`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.positive.
`power`(x1, x2, /[, out, where, casting, ...]) | This docstring was copied from numpy.power.
`prod`(a[, axis, dtype, keepdims, ...]) | Return the product of array elements over a given axis.
`ptp`(a[, axis]) | Range of values (maximum - minimum) along an axis.
`quantile`(a, q[, axis, out, overwrite_input, ...]) | Compute the q-th quantile of the data along the specified axis.
`rad2deg`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.rad2deg.
`radians`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.radians.
`ravel`(array_like) | Return a contiguous flattened array.
`ravel_multi_index`(multi_index, dims[, mode, ...]) | Converts a tuple of index arrays into an array of flat indices, applying boundary modes to the multi-index.
`real`(*args, **kwargs) | Return the real part of the complex argument.
`reciprocal`(x, /[, out, where, casting, ...]) | This docstring was copied from numpy.reciprocal.
`rechunk`(x[, chunks, threshold, ...]) | Convert blocks in dask array x for new chunks.
`reduction`(x, chunk, aggregate[, axis, ...]) | General version of reductions
`register_chunk_type`(type) | Register the given type as a valid chunk and downcast array type
`remainder`(x1, x2, /[, out, where, casting, ...]) | This docstring was copied from numpy.remainder.
`repeat`(a, repeats[, axis]) | Repeat each element of an array after themselves
`reshape`(x, shape[, merge_chunks, limit]) | Reshape array to new shape
`reshape_blockwise`(x, shape[, chunks]) | Blockwise-reshape into a new shape.
`result_type`(*arrays_and_dtypes) | This docstring was copied from numpy.result_type.
`right_shift`(x1, x2, /[, out, where, ...]) | This docstring was copied from numpy.right_shift.
`rint`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.rint.
`roll`(array, shift[, axis]) | Roll array elements along a given axis.
`rollaxis`(a, axis[, start]) |
`rot90`(m[, k, axes]) | Rotate an array by 90 degrees in the plane specified by axes.
`round`(a[, decimals]) | Evenly round to the given number of decimals.
`searchsorted`(a, v[, side, sorter]) | Find indices where elements should be inserted to maintain order.
`select`(condlist, choicelist[, default]) | Return an array drawn from elements in choicelist, depending on conditions.
`shape`(array) | Return the shape of an array.
`shuffle`(x, indexer, axis[, chunks]) | Reorders one dimensions of a Dask Array based on an indexer.
`sign`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.sign.
`signbit`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.signbit.
`sin`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.sin.
`sinc`(*args, **kwargs) | Return the normalized sinc function.
`sinh`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.sinh.
`spacing`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.spacing.
`sqrt`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.sqrt.
`square`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.square.
`squeeze`(a[, axis]) | Remove axes of length one from a.
`stack`(seq[, axis, allow_unknown_chunksizes]) | Stack arrays along a new axis
`std`(a[, axis, dtype, keepdims, ddof, ...]) | Compute the standard deviation along the specified axis.
`subtract`(x1, x2, /[, out, where, casting, ...]) | This docstring was copied from numpy.subtract.
`sum`(a[, axis, dtype, keepdims, split_every, out]) | Sum of array elements over a given axis.
`swapaxes`(a, axis1, axis2) | Interchange two axes of an array.
`take`(a, indices[, axis]) | Take elements from an array along an axis.
`tan`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.tan.
`tanh`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.tanh.
`tensordot`(lhs, rhs[, axes]) | Compute tensor dot product along specified axes.
`tile`(A, reps) | Construct an array by repeating A the number of times given by reps.
`topk`(a, k[, axis, split_every]) | Extract the k largest elements from a on the given axis, and return them sorted from largest to smallest.
`trace`(a[, offset, axis1, axis2, dtype]) | Return the sum along diagonals of the array.
`transpose`(a[, axes]) | Returns an array with axes transposed.
`tri`(N[, M, k, dtype, chunks, like]) | An array with ones at and below the given diagonal and zeros elsewhere.
`tril`(m[, k]) | Lower triangle of an array.
`tril_indices`(n[, k, m, chunks]) | Return the indices for the lower-triangle of an (n, m) array.
`tril_indices_from`(arr[, k]) | Return the indices for the lower-triangle of arr.
`triu`(m[, k]) | Upper triangle of an array.
`triu_indices`(n[, k, m, chunks]) | Return the indices for the upper-triangle of an (n, m) array.
`triu_indices_from`(arr[, k]) | Return the indices for the upper-triangle of arr.
`true_divide`(x1, x2, /[, out, where, ...]) | This docstring was copied from numpy.divide.
`trunc`(x, /[, out, where, casting, order, ...]) | This docstring was copied from numpy.trunc.
`union1d`(ar1, ar2) | Find the union of two arrays.
`unique`(ar[, return_index, return_inverse, ...]) | Find the unique elements of an array.
`unravel_index`(indices, shape[, order]) | This docstring was copied from numpy.unravel_index.
`var`(a[, axis, dtype, keepdims, ddof, ...]) | Compute the variance along the specified axis.
`vdot`(a, b, /) | This docstring was copied from numpy.vdot.
`vstack`(tup[, allow_unknown_chunksizes]) | Stack arrays in sequence vertically (row wise).
`where`(condition, [x, y], /) | This docstring was copied from numpy.where.
`zeros`(*args, **kwargs) | Blocked variant of zeros_like
`zeros_like`(a[, dtype, order, chunks, name, ...]) | Return an array of zeros with the same shape and type as a given array.

## Array

`Array`(dask, name, chunks[, dtype, meta, shape]) | Parallel Dask Array
`Array.all`([axis, keepdims, split_every, out]) | Returns True if all elements evaluate to True.
`Array.any`([axis, keepdims, split_every, out]) | Returns True if any of the elements evaluate to True.
`Array.argmax`([axis, keepdims, split_every, out]) | Return indices of the maximum values along the given axis.
`Array.argmin`([axis, keepdims, split_every, out]) | Return indices of the minimum values along the given axis.
`Array.argtopk`(k[, axis, split_every]) | The indices of the top k elements of an array.
`Array.astype`(dtype, **kwargs) | Copy of the array, cast to a specified type.
`Array.blocks` | An array-like interface to the blocks of an array.
`Array.choose`(choices) | Use an index array to construct a new array from a set of choices.
`Array.chunks` | Chunks property.
`Array.chunksize` |
`Array.clip`([min, max]) | Return an array whose values are limited to `[min, max]`.
`Array.compute`(**kwargs) | Compute this dask collection
`Array.compute_chunk_sizes`() | Compute the chunk sizes for a Dask array.
`Array.conj`() | Complex-conjugate all elements.
`Array.copy`() | Copy array.
`Array.cumprod`(axis[, dtype, out, method]) | Return the cumulative product of the elements along the given axis.
`Array.cumsum`(axis[, dtype, out, method]) | Return the cumulative sum of the elements along the given axis.
`Array.dask` |
`Array.dot`(other) | Dot product of self and other.
`Array.dtype` |
`Array.flatten`() | Return a flattened array.
`Array.imag` |
`Array.itemsize` | Length of one array element in bytes
`Array.map_blocks`(*args[, name, token, ...]) | Map a function across all blocks of a dask array.
`Array.map_overlap`(func, depth[, boundary, trim]) | Map a function over blocks of the array with some overlap
`Array.max`([axis, keepdims, split_every, out]) | Return the maximum along a given axis.
`Array.mean`([axis, dtype, keepdims, ...]) | Returns the average of the array elements along given axis.
`Array.min`([axis, keepdims, split_every, out]) | Return the minimum along a given axis.
`Array.moment`(order[, axis, dtype, keepdims, ...]) | Calculate the nth centralized moment.
`Array.name` |
`Array.nbytes` | Number of bytes in array
`Array.ndim` |
`Array.nonzero`() | Return the indices of the elements that are non-zero.
`Array.npartitions` |
`Array.numblocks` |
`Array.partitions` | Slice an array by partitions.
`Array.persist`(**kwargs) | Persist this dask collection into memory
`Array.prod`([axis, dtype, keepdims, ...]) | Return the product of the array elements over the given axis
`Array.ravel`() | Return a flattened array.
`Array.real` |
`Array.rechunk`([chunks, threshold, ...]) | Convert blocks in dask array x for new chunks.
`Array.repeat`(repeats[, axis]) | Repeat elements of an array.
`Array.reshape`(*shape[, merge_chunks, limit]) | Reshape array to new shape
`Array.round`([decimals]) | Return array with each element rounded to the given number of decimals.
`Array.shape` |
`Array.shuffle`(indexer, axis[, chunks]) | Reorders one dimensions of a Dask Array based on an indexer.
`Array.size` | Number of elements in array
`Array.squeeze`([axis]) | Remove axes of length one from array.
`Array.std`([axis, dtype, keepdims, ddof, ...]) | Returns the standard deviation of the array elements along given axis.
`Array.store`(targets[, lock, regions, ...]) | Store dask arrays in array-like objects, overwrite data in target
`Array.sum`([axis, dtype, keepdims, ...]) | Return the sum of the array elements over the given axis.
`Array.swapaxes`(axis1, axis2) | Return a view of the array with `axis1` and `axis2` interchanged.
`Array.to_backend`([backend]) | Move to a new Array backend
`Array.to_dask_dataframe`([columns, index, meta]) | Convert dask Array to dask Dataframe
`Array.to_delayed`([optimize_graph]) | Convert into an array of `dask.delayed.Delayed` objects, one per chunk.
`Array.to_hdf5`(filename, datapath, **kwargs) | Store array in HDF5 file
`Array.to_svg`([size]) | Convert chunks from Dask Array into an SVG Image
`Array.to_tiledb`(uri, *args, **kwargs) | Save array to the TileDB storage manager
`Array.to_zarr`(*args, **kwargs) | Save array to the zarr storage format
`Array.topk`(k[, axis, split_every]) | The top k elements of an array.
`Array.trace`([offset, axis1, axis2, dtype]) | Return the sum along diagonals of the array.
`Array.transpose`(*axes) | Reverse or permute the axes of an array.
`Array.var`([axis, dtype, keepdims, ddof, ...]) | Returns the variance of the array elements, along given axis.
`Array.view`([dtype, order]) | Get a view of the array as a new data type
`Array.vindex` | Vectorized indexing with broadcasting.
`Array.visualize`([filename, format, ...]) | Render the computation of this object's task graph using graphviz.

## Fast Fourier Transforms

`fft.fft_wrap`(fft_func[, kind, dtype, ...]) | Wrap 1D, 2D, and ND real and complex FFT functions
`fft.fft`(a[, n, axis, norm]) | Wrapping of numpy.fft.fft
`fft.fft2`(a[, s, axes, norm]) | Wrapping of numpy.fft.fft2
`fft.fftn`(a[, s, axes, norm]) | Wrapping of numpy.fft.fftn
`fft.ifft`(a[, n, axis, norm]) | Wrapping of numpy.fft.ifft
`fft.ifft2`(a[, s, axes, norm]) | Wrapping of numpy.fft.ifft2
`fft.ifftn`(a[, s, axes, norm]) | Wrapping of numpy.fft.ifftn
`fft.rfft`(a[, n, axis, norm]) | Wrapping of numpy.fft.rfft
`fft.rfft2`(a[, s, axes, norm]) | Wrapping of numpy.fft.rfft2
`fft.rfftn`(a[, s, axes, norm]) | Wrapping of numpy.fft.rfftn
`fft.irfft`(a[, n, axis, norm]) | Wrapping of numpy.fft.irfft
`fft.irfft2`(a[, s, axes, norm]) | Wrapping of numpy.fft.irfft2
`fft.irfftn`(a[, s, axes, norm]) | Wrapping of numpy.fft.irfftn
`fft.hfft`(a[, n, axis, norm]) | Wrapping of numpy.fft.hfft
`fft.ihfft`(a[, n, axis, norm]) | Wrapping of numpy.fft.ihfft
`fft.fftfreq`(n[, d, chunks]) | Return the Discrete Fourier Transform sample frequencies.
`fft.rfftfreq`(n[, d, chunks]) | Return the Discrete Fourier Transform sample frequencies (for usage with rfft, irfft).
`fft.fftshift`(x[, axes]) | Shift the zero-frequency component to the center of the spectrum.
`fft.ifftshift`(x[, axes]) | The inverse of fftshift.

## Linear Algebra

`linalg.cholesky`(a[, lower]) | Returns the Cholesky decomposition, \(A = L L^*\) or \(A = U^* U\) of a Hermitian positive-definite matrix A.
`linalg.inv`(a) | Compute the inverse of a matrix with LU decomposition and forward / backward substitutions.
`linalg.lstsq`(a, b) | Return the least-squares solution to a linear matrix equation using QR decomposition.
`linalg.lu`(a) | Compute the lu decomposition of a matrix.
`linalg.norm`(x[, ord, axis, keepdims]) | Matrix or vector norm.
`linalg.qr`(a) | Compute the qr factorization of a matrix.
`linalg.solve`(a, b[, sym_pos, assume_a]) | Solve the equation `a x = b` for `x`.
`linalg.solve_triangular`(a, b[, lower]) | Solve the equation a x = b for x, assuming a is a triangular matrix.
`linalg.svd`(a[, coerce_signs]) | Compute the singular value decomposition of a matrix.
`linalg.svd_compressed`(a, k[, iterator, ...]) | Randomly compressed rank-k thin Singular Value Decomposition.
`linalg.sfqr`(data[, name]) | Direct Short-and-Fat QR
`linalg.tsqr`(data[, compute_svd, ...]) | Direct Tall-and-Skinny QR algorithm

## Masked Arrays

`ma.average`(a[, axis, weights, returned, ...]) | Return the weighted average of array over the given axis.
`ma.empty_like`(prototype[, dtype, order, ...]) | This docstring was copied from numpy.ma.core.empty_like.
`ma.filled`(a[, fill_value]) | Return input as an ~numpy.ndarray, with masked values replaced by fill_value.
`ma.fix_invalid`(a[, fill_value]) | Return input with invalid data masked and replaced by a fill value.
`ma.getdata`(a) | Return the data of a masked array as an ndarray.
`ma.getmaskarray`(a) | Return the mask of a masked array, or full boolean array of False.
`ma.masked_array`(data[, mask, fill_value]) | An array class with possibly masked values.
`ma.masked_equal`(a, value) | Mask an array where equal to a given value.
`ma.masked_greater`(x, value[, copy]) | Mask an array where greater than a given value.
`ma.masked_greater_equal`(x, value[, copy]) | Mask an array where greater than or equal to a given value.
`ma.masked_inside`(x, v1, v2) | Mask an array inside a given interval.
`ma.masked_invalid`(a) | Mask an array where invalid values occur (NaNs or infs).
`ma.masked_less`(x, value[, copy]) | Mask an array where less than a given value.
`ma.masked_less_equal`(x, value[, copy]) | Mask an array where less than or equal to a given value.
`ma.masked_not_equal`(x, value[, copy]) | Mask an array where not equal to a given value.
`ma.masked_outside`(x, v1, v2) | Mask an array outside a given interval.
`ma.masked_values`(x, value[, rtol, atol, shrink]) | Mask using floating point equality.
`ma.masked_where`(condition, a) | Mask an array where a condition is met.
`ma.nonzero`(self) | This docstring was copied from numpy.ma.core.nonzero.
`ma.ones_like`(a, **kwargs) | Return an array of ones with the same shape and type as a given array.
`ma.set_fill_value`(a, fill_value) | Set the filling value of a, if a is a masked array.
`ma.where`(condition[, x, y]) | Return a masked array with elements from x or y, depending on condition.
`ma.zeros_like`(a, **kwargs) | Return an array of zeros with the same shape and type as a given array.

## Random

`random.beta`(*args, **kwargs) | Draw samples from a Beta distribution.
`random.binomial`(*args, **kwargs) | Draw samples from a binomial distribution.
`random.chisquare`(*args, **kwargs) | Draw samples from a chi-square distribution.
`random.choice`(*args, **kwargs) | Generates a random sample from a given 1-D array
`random.default_rng`([seed]) | Construct a new Generator with the default BitGenerator (PCG64).
`random.exponential`(*args, **kwargs) | Draw samples from an exponential distribution.
`random.f`(*args, **kwargs) | Draw samples from an F distribution.
`random.gamma`(*args, **kwargs) | Draw samples from a Gamma distribution.
`random.geometric`(*args, **kwargs) | Draw samples from the geometric distribution.
`random.gumbel`(*args, **kwargs) | Draw samples from a Gumbel distribution.
`random.hypergeometric`(*args, **kwargs) | Draw samples from a Hypergeometric distribution.
`random.laplace`(*args, **kwargs) | Draw samples from the Laplace or double exponential distribution with specified location (or mean) and scale (decay).
`random.logistic`(*args, **kwargs) | Draw samples from a logistic distribution.
`random.lognormal`(*args, **kwargs) | Draw samples from a log-normal distribution.
`random.logseries`(*args, **kwargs) | Draw samples from a logarithmic series distribution.
`random.multinomial`(*args, **kwargs) | Draw samples from a multinomial distribution.
`random.negative_binomial`(*args, **kwargs) | Draw samples from a negative binomial distribution.
`random.noncentral_chisquare`(*args, **kwargs) | Draw samples from a noncentral chi-square distribution.
`random.noncentral_f`(*args, **kwargs) | Draw samples from the noncentral F distribution.
`random.normal`(*args, **kwargs) | Draw random samples from a normal (Gaussian) distribution.
`random.pareto`(*args, **kwargs) | Draw samples from a Pareto II or Lomax distribution with specified shape.
`random.permutation`(*args, **kwargs) | Randomly permute a sequence, or return a permuted range.
`random.poisson`(*args, **kwargs) | Draw samples from a Poisson distribution.
`random.power`(*args, **kwargs) | Draws samples in [0, 1] from a power distribution with positive exponent a - 1.
`random.randint`(*args, **kwargs) | Return random integers from low (inclusive) to high (exclusive).
`random.random`(*args, **kwargs) | Return random floats in the half-open interval [0.0, 1.0).
`random.random_integers`(*args, **kwargs) | Random integers of type numpy.int_ between low and high, inclusive.
`random.random_sample`(*args, **kwargs) | Return random floats in the half-open interval [0.0, 1.0).
`random.rayleigh`(*args, **kwargs) | Draw samples from a Rayleigh distribution.
`random.standard_cauchy`(*args, **kwargs) | Draw samples from a standard Cauchy distribution with mode = 0.
`random.standard_exponential`(*args, **kwargs) | Draw samples from the standard exponential distribution.
`random.standard_gamma`(*args, **kwargs) | Draw samples from a standard Gamma distribution.
`random.standard_normal`(*args, **kwargs) | Draw samples from a standard Normal distribution (mean=0, stdev=1).
`random.standard_t`(*args, **kwargs) | Draw samples from a standard Student's t distribution with df degrees of freedom.
`random.triangular`(*args, **kwargs) | Draw samples from the triangular distribution over the interval `[left, right]`.
`random.uniform`(*args, **kwargs) | Draw samples from a uniform distribution.
`random.vonmises`(*args, **kwargs) | Draw samples from a von Mises distribution.
`random.wald`(*args, **kwargs) | Draw samples from a Wald, or inverse Gaussian, distribution.
`random.weibull`(*args, **kwargs) | Draw samples from a Weibull distribution.
`random.zipf`(*args, **kwargs) | Draw samples from a Zipf distribution.

## Stats

`stats.ttest_ind`(a, b[, axis, equal_var]) | This docstring was copied from scipy.stats.ttest_ind.
`stats.ttest_1samp`(a, popmean[, axis, nan_policy]) | This docstring was copied from scipy.stats.ttest_1samp.
`stats.ttest_rel`(a, b[, axis, nan_policy]) | This docstring was copied from scipy.stats.ttest_rel.
`stats.chisquare`(f_obs[, f_exp, ddof, axis]) | Calculate a one-way chi-square test.
`stats.power_divergence`(f_obs[, f_exp, ddof, ...]) | This docstring was copied from scipy.stats.power_divergence.
`stats.skew`(a[, axis, bias, nan_policy]) | This docstring was copied from scipy.stats.skew.
`stats.skewtest`(a[, axis, nan_policy]) | This docstring was copied from scipy.stats.skewtest.
`stats.kurtosis`(a[, axis, fisher, bias, ...]) | This docstring was copied from scipy.stats.kurtosis.
`stats.kurtosistest`(a[, axis, nan_policy]) | This docstring was copied from scipy.stats.kurtosistest.
`stats.normaltest`(a[, axis, nan_policy]) | This docstring was copied from scipy.stats.normaltest.
`stats.f_oneway`(*args) | This docstring was copied from scipy.stats.f_oneway.
`stats.moment`(a[, moment, axis, nan_policy]) | This docstring was copied from scipy.stats.moment.

## Image Support

`image.imread`(filename[, imread, preprocess]) | Read a stack of images into a dask array

## Slightly Overlapping Computations

`overlap.overlap`(x, depth, boundary, *[, ...]) | Share boundaries between neighboring blocks
`overlap.map_overlap`(func, *args[, depth, ...]) | Map a function over blocks of arrays with some overlap
`lib.stride_tricks.sliding_window_view`(x, ...) | Create a sliding window view into the array with the given window shape.
`overlap.trim_internal`(x, axes[, boundary]) | Trim sides from each block
`overlap.trim_overlap`(x, depth[, boundary]) | Trim sides from each block.

## Create and Store Arrays

`from_array`(x[, chunks, name, lock, asarray, ...]) | Create dask array from something that looks like an array.
`from_delayed`(value, shape[, dtype, meta, name]) | Create a dask array from a dask delayed value
`from_npy_stack`(dirname[, mmap_mode]) | Load dask array from stack of npy files
`from_zarr`(url[, component, storage_options, ...]) | Load array from the zarr storage format
`from_tiledb`(uri[, attribute, chunks, ...]) | Load array from the TileDB storage format
`store`(sources, targets[, lock, regions, ...]) | Store dask arrays in array-like objects, overwrite data in target
`to_hdf5`(filename, *args[, chunks]) | Store arrays in HDF5 file
`to_zarr`(arr, url[, component, ...]) | Save array to the zarr storage format
`to_npy_stack`(dirname, x[, axis]) | Write dask array to a stack of .npy files
`to_tiledb`(darray, uri[, compute, ...]) | Save array to the TileDB storage format

## Generalized Ufuncs

`apply_gufunc`(func, signature, *args[, axes, ...]) | Apply a generalized ufunc or similar python function to arrays.
`as_gufunc`([signature]) | Decorator for `dask.array.gufunc`.
`gufunc`(pyfunc, *[, signature, vectorize, ...]) | Binds pyfunc into `dask.array.apply_gufunc` when called.

## Internal functions

`blockwise`(func, out_ind, *args[, name, ...]) | Tensor operation: Generalized inner and outer products
`normalize_chunks`(chunks[, shape, limit, ...]) | Normalize chunks to tuple of tuples
`unify_chunks`(*args, **kwargs) | Unify chunks across a sequence of arrays

## Dask Metadata

`meta_from_array`(x[, ndim, dtype]) | Normalize an array to appropriate meta object