def kron(a, b): """Returns the kronecker product of two arrays. Args: a (~cupy.ndarray): The first argument. b (~cupy.ndarray): The second argument. Returns: ~cupy.ndarray: Output array. .. seealso:: :func:`numpy.kron` """ a_ndim = a.ndim b_ndim = b.ndim if a_ndim == 0 or b_ndim == 0: return cupy.multiply(a, b) ndim = b_ndim a_shape = a.shape b_shape = b.shape if a_ndim != b_ndim: if b_ndim > a_ndim: a_shape = (1,) * (b_ndim - a_ndim) + a_shape else: b_shape = (1,) * (a_ndim - b_ndim) + b_shape ndim = a_ndim axis = ndim - 1 out = core.tensordot_core(a, b, None, a.size, b.size, 1, a_shape + b_shape) for _ in six.moves.range(ndim): out = core.concatenate_method(out, axis=axis) return out
def concatenate(tup, axis=0): """Joins arrays along an axis. Args: tup (sequence of arrays): Arrays to be joined. All of these should have same dimensionalities except the specified axis. axis (int): The axis to join arrays along. Returns: cupy.ndarray: Joined array. .. seealso:: :func:`numpy.concatenate` """ return core.concatenate_method(tup, axis)
def concatenate(tup, axis=0): """Joins arrays along an axis. Args: tup (sequence of arrays): Arrays to be joined. All of these should have same dimensionalities except the specified axis. axis (int): The axis to join arrays along. Returns: cupy.ndarray: Joined array. .. seealso:: :func:`numpy.concatenate` """ return core.concatenate_method(tup, axis)
def concatenate(tup, axis=0): """Joins arrays along an axis. Args: tup (sequence of arrays): Arrays to be joined. All of these should have same dimensionalities except the specified axis. axis (int or None): The axis to join arrays along. If axis is None, arrays are flattened before use. Default is 0. Returns: cupy.ndarray: Joined array. .. seealso:: :func:`numpy.concatenate` """ if axis is None: tup = [m.ravel() for m in tup] axis = 0 return core.concatenate_method(tup, axis)
def cov(a, y=None, rowvar=True, bias=False, ddof=None): """Returns the covariance matrix of an array. This function currently does not support ``fweights`` and ``aweights`` options. Args: a (cupy.ndarray): Array to compute covariance matrix. y (cupy.ndarray): An additional set of variables and observations. rowvar (bool): If ``True``, then each row represents a variable, with observations in the columns. Otherwise, the relationship is transposed. bias (bool): If ``False``, normalization is by ``(N - 1)``, where N is the number of observations given (unbiased estimate). If ``True``, then normalization is by ``N``. ddof (int): If not ``None`` the default value implied by bias is overridden. Note that ``ddof=1`` will return the unbiased estimate and ``ddof=0`` will return the simple average. Returns: cupy.ndarray: The covariance matrix of the input array. .. seealso:: :func:`numpy.cov` """ if ddof is not None and ddof != int(ddof): raise ValueError('ddof must be integer') if a.ndim > 2: raise ValueError('Input must be <= 2-d') if y is None: dtype = numpy.promote_types(a.dtype, numpy.float64) else: if y.ndim > 2: raise ValueError('y must be <= 2-d') dtype = functools.reduce(numpy.promote_types, (a.dtype, y.dtype, numpy.float64)) X = cupy.array(a, ndmin=2, dtype=dtype) if not rowvar and X.shape[0] != 1: X = X.T if X.shape[0] == 0: return cupy.array([]).reshape(0, 0) if y is not None: y = cupy.array(y, copy=False, ndmin=2, dtype=dtype) if not rowvar and y.shape[0] != 1: y = y.T X = core.concatenate_method((X, y), axis=0) if ddof is None: ddof = 0 if bias else 1 fact = X.shape[1] - ddof if fact <= 0: warnings.warn('Degrees of freedom <= 0 for slice', RuntimeWarning, stacklevel=2) fact = 0.0 X -= X.mean(axis=1)[:, None] out = X.dot(X.T.conj()) * (1 / cupy.float64(fact)) return out.squeeze()