lacuna.array_api#

lacuna.array_api.abs(x)[source]#

lacuna.array_api.acos(x)[source]#

lacuna.array_api.acosh(x)[source]#

lacuna.array_api.add(x, y)[source]#

lacuna.array_api.all(x, axis=None, keepdims=False)[source]#

lacuna.array_api.any(x, axis=None, keepdims=False)[source]#

lacuna.array_api.arange(start, stop=None, step=1, *, dtype=None, device=None)[source]#

lacuna.array_api.argmax(x, axis=None, keepdims=False)[source]#

lacuna.array_api.argmin(x, axis=None, keepdims=False)[source]#

lacuna.array_api.argsort(x, axis=-1)[source]#

lacuna.array_api.asarray(obj, /, *, dtype=None, device=None, copy=None)[source]#

lacuna.array_api.asin(x)[source]#

lacuna.array_api.asinh(x)[source]#

lacuna.array_api.astype(x, dtype, /, *, copy=True)[source]#

lacuna.array_api.atan(x)[source]#

lacuna.array_api.atan2(y, x)[source]#

lacuna.array_api.atanh(x)[source]#

lacuna.array_api.bitwise_and(x, y)[source]#

lacuna.array_api.bitwise_invert(x)[source]#

lacuna.array_api.bitwise_left_shift(x, y)[source]#

lacuna.array_api.bitwise_or(x, y)[source]#

lacuna.array_api.bitwise_right_shift(x, y)[source]#

lacuna.array_api.bitwise_xor(x, y)[source]#

lacuna.array_api.broadcast_arrays(*arrays)[source]#

lacuna.array_api.broadcast_to(x, shape)[source]#

lacuna.array_api.can_cast(from_dtype, to_dtype, /)[source]#

lacuna.array_api.ceil(x)[source]#

lacuna.array_api.concat(arrays, axis=0)[source]#

lacuna.array_api.conj(x)[source]#

lacuna.array_api.copysign(x, y)[source]#

lacuna.array_api.cos(x)[source]#

lacuna.array_api.cosh(x)[source]#

lacuna.array_api.count_nonzero(x, axis=None, keepdims=False)[source]#

lacuna.array_api.cumulative_prod(x, axis=None)[source]#

lacuna.array_api.cumulative_sum(x, axis=None)[source]#

lacuna.array_api.diff(x, *, n=1, axis=-1)[source]#

lacuna.array_api.divide(x, y)[source]#

lacuna.array_api.empty(shape, *, dtype=None, device=None)[source]#

lacuna.array_api.empty_like(x, *, dtype=None, device=None)[source]#

lacuna.array_api.equal(x, y)[source]#

lacuna.array_api.exp(x)[source]#

lacuna.array_api.expand_dims(x, axis)[source]#

lacuna.array_api.expm1(x)[source]#

lacuna.array_api.eye(n_rows, n_cols=None, k=0, *, dtype=None, device=None)[source]#

Create an identity matrix (Array API compliant).

Parameters:

n_rows (int) – Number of rows (for square matrix, this is the size).
n_cols (int, optional) – Number of columns (if None, creates square matrix).
k (int, optional) – Diagonal offset (default: 0 for main diagonal).
dtype (dtype, optional) – Data type (default: float64).
device (str, optional) – Device (default: “cpu”).

Returns:

Identity matrix using Rust backend.

Return type:

CSR

Notes

Currently only supports k=0 (main diagonal) and square matrices.

Examples

>>> import lacuna.array_api as xp
>>> I = xp.eye(5)
>>> I.sum()
5.0

lacuna.array_api.finfo(dtype)[source]#

lacuna.array_api.flip(x, axis=None)[source]#

lacuna.array_api.floor(x)[source]#

lacuna.array_api.floor_divide(x, y)[source]#

lacuna.array_api.from_dlpack(dlpack_obj)[source]#

lacuna.array_api.full(shape, fill_value, *, dtype=None, device=None)[source]#

lacuna.array_api.full_like(x, fill_value, *, dtype=None, device=None)[source]#

lacuna.array_api.greater(x, y)[source]#

lacuna.array_api.greater_equal(x, y)[source]#

lacuna.array_api.iinfo(dtype)[source]#

lacuna.array_api.imag(x)[source]#

lacuna.array_api.isdtype(dtype, kind)[source]#

lacuna.array_api.isfinite(x)[source]#

lacuna.array_api.isinf(x)[source]#

lacuna.array_api.isnan(x)[source]#

lacuna.array_api.less(x, y)[source]#

lacuna.array_api.less_equal(x, y)[source]#

lacuna.array_api.linspace(start, stop, num, *, dtype=None, device=None)[source]#

lacuna.array_api.log(x)[source]#

lacuna.array_api.log10(x)[source]#

lacuna.array_api.log1p(x)[source]#

lacuna.array_api.log2(x)[source]#

lacuna.array_api.logaddexp(x, y)[source]#

lacuna.array_api.logical_and(x, y)[source]#

lacuna.array_api.logical_not(x)[source]#

lacuna.array_api.logical_or(x, y)[source]#

lacuna.array_api.logical_xor(x, y)[source]#

lacuna.array_api.matmul(x, y)[source]#

lacuna.array_api.matrix_transpose(x)[source]#

lacuna.array_api.max(x, axis=None, keepdims=False)[source]#

lacuna.array_api.maximum(x, y)[source]#

lacuna.array_api.mean(x, axis=None, keepdims=False)[source]#

lacuna.array_api.meshgrid(*arrays, indexing='xy')[source]#

lacuna.array_api.min(x, axis=None, keepdims=False)[source]#

lacuna.array_api.minimum(x, y)[source]#

lacuna.array_api.moveaxis(x, source, destination)[source]#

lacuna.array_api.multiply(x, y)[source]#

lacuna.array_api.negative(x)[source]#

lacuna.array_api.nextafter(x, y)[source]#

lacuna.array_api.nonzero(x)[source]#

lacuna.array_api.not_equal(x, y)[source]#

lacuna.array_api.ones(shape, *, dtype=None, device=None)[source]#

lacuna.array_api.ones_like(x, *, dtype=None, device=None)[source]#

lacuna.array_api.permute_dims(x, axes)[source]#

lacuna.array_api.positive(x)[source]#

lacuna.array_api.pow(x, y)[source]#

lacuna.array_api.prod(x, axis=None, keepdims=False)[source]#

lacuna.array_api.real(x)[source]#

lacuna.array_api.remainder(x, y)[source]#

lacuna.array_api.repeat(x, repeats, axis=None)[source]#

lacuna.array_api.reshape(x, newshape)[source]#

lacuna.array_api.result_type(*arrays_and_dtypes)[source]#

lacuna.array_api.roll(x, shift, axis=None)[source]#

lacuna.array_api.round(x)[source]#

lacuna.array_api.searchsorted(x, v, *, side='left')[source]#

lacuna.array_api.sign(x)[source]#

lacuna.array_api.signbit(x)[source]#

lacuna.array_api.sin(x)[source]#

lacuna.array_api.sinh(x)[source]#

lacuna.array_api.sort(x, axis=-1)[source]#

lacuna.array_api.sqrt(x)[source]#

lacuna.array_api.square(x)[source]#

lacuna.array_api.squeeze(x, axis=None)[source]#

lacuna.array_api.stack(arrays, axis=0)[source]#

lacuna.array_api.std(x, axis=None, correction=0.0, keepdims=False)[source]#

lacuna.array_api.subtract(x, y)[source]#

lacuna.array_api.sum(x, axis=None, keepdims=False)[source]#

lacuna.array_api.take(x, indices, /, *, axis=None)[source]#

lacuna.array_api.take_along_axis(x, indices, axis)[source]#

lacuna.array_api.tan(x)[source]#

lacuna.array_api.tanh(x)[source]#

lacuna.array_api.tensordot(x, y, *, axes=2)[source]#

lacuna.array_api.tile(x, reps)[source]#

lacuna.array_api.tril(x, k=0)[source]#

lacuna.array_api.triu(x, k=0)[source]#

lacuna.array_api.trunc(x)[source]#

lacuna.array_api.unique_all(x)[source]#

lacuna.array_api.unique_counts(x)[source]#

lacuna.array_api.unique_inverse(x)[source]#

lacuna.array_api.unique_values(x)[source]#

lacuna.array_api.unstack(x, axis=0)[source]#

lacuna.array_api.var(x, axis=None, correction=0.0, keepdims=False)[source]#

lacuna.array_api.vecdot(x, y, *, axis=None)[source]#

lacuna.array_api.where(cond, x, y)[source]#

lacuna.array_api.zeros(shape, *, dtype=None, device=None)[source]#

Create a sparse zero matrix (Array API compliant).

Parameters:

shape (tuple of int) – Matrix shape (nrows, ncols).
dtype (dtype, optional) – Data type (default: float64).
device (str, optional) – Device (default: “cpu”).

Returns:

Sparse zero matrix using Rust backend.

Return type:

CSR

Examples

>>> import lacuna.array_api as xp
>>> A = xp.zeros((10, 20))
>>> A.nnz
0

lacuna.array_api.zeros_like(x, *, dtype=None, device=None)[source]#

Modules

`constants`
`creation`
`dtypes`
`elementwise`
`indexing`
`linalg`
`manipulation`
`reductions`
`searching`
`sets`
`sorting`

lacuna.array_api#

This Page