src.array package

Subpackages

• src.array.dense package
  • Submodules
  • src.array.dense.dense module
    • DenseArray
      • DenseArray.as_array()
      • DenseArray.as_csr()
      • DenseArray.as_dense()
      • DenseArray.as_nparray()
      • DenseArray.as_type()
      • DenseArray.broadcast_to()
      • DenseArray.compress()
      • DenseArray.compress_axis()
      • DenseArray.concat()
      • DenseArray.copy()
      • DenseArray.cos()
      • DenseArray.count_nonzero()
      • DenseArray.diagonal()
      • DenseArray.distance()
      • DenseArray.distance_lazy()
      • DenseArray.exp()
      • DenseArray.expand_dims()
      • DenseArray.fill_diagonal()
      • DenseArray.full()
      • DenseArray.icos()
      • DenseArray.iexp()
      • DenseArray.ilog()
      • DenseArray.isin()
      • DenseArray.isqrt()
      • DenseArray.log()
      • DenseArray.max()
      • DenseArray.mean()
      • DenseArray.min()
      • DenseArray.ones()
      • DenseArray.reshape()
      • DenseArray.shape
      • DenseArray.sin()
      • DenseArray.sqrt()
      • DenseArray.squeeze()
      • DenseArray.stack()
      • DenseArray.sum()
      • DenseArray.zeros()
  • Module contents
    • DenseArray
      • DenseArray.as_array()
      • DenseArray.as_csr()
      • DenseArray.as_dense()
      • DenseArray.as_nparray()
      • DenseArray.as_type()
      • DenseArray.broadcast_to()
      • DenseArray.compress()
      • DenseArray.compress_axis()
      • DenseArray.concat()
      • DenseArray.copy()
      • DenseArray.cos()
      • DenseArray.count_nonzero()
      • DenseArray.diagonal()
      • DenseArray.distance()
      • DenseArray.distance_lazy()
      • DenseArray.exp()
      • DenseArray.expand_dims()
      • DenseArray.fill_diagonal()
      • DenseArray.full()
      • DenseArray.icos()
      • DenseArray.iexp()
      • DenseArray.ilog()
      • DenseArray.isin()
      • DenseArray.isqrt()
      • DenseArray.log()
      • DenseArray.max()
      • DenseArray.mean()
      • DenseArray.min()
      • DenseArray.ones()
      • DenseArray.reshape()
      • DenseArray.shape
      • DenseArray.sin()
      • DenseArray.sqrt()
      • DenseArray.squeeze()
      • DenseArray.stack()
      • DenseArray.sum()
      • DenseArray.zeros()
• src.array.linalg package
  • Submodules
  • src.array.linalg.eigen_decomp module
    • eigen_decomp()
  • Module contents
    • eigen_decomp()
• src.array.sparse package
  • Submodules
  • src.array.sparse.csr module
    • CsrArray
      • CsrArray.as_array()
      • CsrArray.as_csr()
      • CsrArray.as_nparray()
      • CsrArray.broadcast_to()
      • CsrArray.compress()
      • CsrArray.compress_axis()
      • CsrArray.concat()
      • CsrArray.count_nonzero()
      • CsrArray.diagonal()
      • CsrArray.expand_dims()
      • CsrArray.fill_diagonal()
      • CsrArray.get_dense_index()
      • CsrArray.indices
      • CsrArray.indptr
      • CsrArray.mask_as_csr_index()
      • CsrArray.max()
      • CsrArray.mean()
      • CsrArray.min()
      • CsrArray.ncols
      • CsrArray.nrows
      • CsrArray.reshape()
      • CsrArray.shape
      • CsrArray.squeeze()
      • CsrArray.stack()
      • CsrArray.sum()
  • src.array.sparse.sparse module
    • SparseArray
      • SparseArray.as_dense()
      • SparseArray.as_type()
      • SparseArray.copy()
      • SparseArray.cos()
      • SparseArray.exp()
      • SparseArray.get_dense_index()
      • SparseArray.icos()
      • SparseArray.iexp()
      • SparseArray.ilog()
      • SparseArray.index
      • SparseArray.isin()
      • SparseArray.isqrt()
      • SparseArray.log()
      • SparseArray.shape
      • SparseArray.sin()
      • SparseArray.sparsity
      • SparseArray.sqrt()
  • Module contents
    • CsrArray
      • CsrArray.as_array()
      • CsrArray.as_csr()
      • CsrArray.as_nparray()
      • CsrArray.broadcast_to()
      • CsrArray.compress()
      • CsrArray.compress_axis()
      • CsrArray.concat()
      • CsrArray.count_nonzero()
      • CsrArray.diagonal()
      • CsrArray.expand_dims()
      • CsrArray.fill_diagonal()
      • CsrArray.get_dense_index()
      • CsrArray.indices
      • CsrArray.indptr
      • CsrArray.mask_as_csr_index()
      • CsrArray.max()
      • CsrArray.mean()
      • CsrArray.min()
      • CsrArray.ncols
      • CsrArray.nrows
      • CsrArray.reshape()
      • CsrArray.shape
      • CsrArray.squeeze()
      • CsrArray.stack()
      • CsrArray.sum()
    • SparseArray
      • SparseArray.as_dense()
      • SparseArray.as_type()
      • SparseArray.copy()
      • SparseArray.cos()
      • SparseArray.exp()
      • SparseArray.get_dense_index()
      • SparseArray.icos()
      • SparseArray.iexp()
      • SparseArray.ilog()
      • SparseArray.index
      • SparseArray.isin()
      • SparseArray.isqrt()
      • SparseArray.log()
      • SparseArray.shape
      • SparseArray.sin()
      • SparseArray.sparsity
      • SparseArray.sqrt()

Submodules

src.array.base module

class src.array.base.BaseArray(*args, **kwargs)

Bases: Generic[Data], ABC

Parameters:

• args (Any)

• kwargs (Any)

abstractmethod classmethod as_array(*args, **kwargs)

Parameters:

• args (Any)

• kwargs (Any)

Return type:

Self

abstractmethod as_csr(*args, **kwargs)

Parameters:

• args (Any)

• kwargs (Any)

Return type:

CsrArray[Data]

abstractmethod as_dense(*args, **kwargs)

Parameters:

• args (Any)

• kwargs (Any)

Return type:

DenseArray[Data]

abstractmethod as_nparray(*args, **kwargs)

Parameters:

• args (Any)

• kwargs (Any)

Return type:

ndarray[tuple[int, …], Data]

abstractmethod as_type(*args, **kwargs)

Parameters:

• args (Any)

• kwargs (Any)

Return type:

Self

abstractmethod broadcast_to(*, shape)

Parameters:

shape (int | Sequence[int])

Return type:

Self

abstractmethod compress(*, keep, axis=0)

Parameters:

• keep (Any | Sequence[Any])

• axis (int | Sequence[int] | None)

Return type:

BaseArray[Data]

abstractmethod compress_axis(*, keep, axis=0)

Parameters:

• keep (Any)

• axis (int | None)

Return type:

BaseArray[Data]

abstractmethod classmethod concat(arrs, /, *, axis=0)

Parameters:

• arrs (Sequence[Self])

• axis (int)

Return type:

Self

abstractmethod copy(*args, **kwargs)

Parameters:

• args (Any)

• kwargs (Any)

Return type:

Self

abstractmethod cos(*args, **kwargs)

Parameters:

• args (Any)

• kwargs (Any)

Return type:

Self

abstractmethod count_nonzero(*, axis=None, keepdims=False)

Parameters:

• axis (int | Sequence[int] | None)

• keepdims (bool)

Return type:

BaseArray[Data]

abstractmethod diagonal()

Return type:

BaseArray[Data]

property dtype: type

abstractmethod exp(*args, **kwargs)

Parameters:

• args (Any)

• kwargs (Any)

Return type:

Self

abstractmethod expand_dims(*, axis)

Parameters:

axis (int | Sequence[int])

Return type:

Self

abstractmethod fill_diagonal(*args, **kwargs)

Parameters:

• args (Any)

• kwargs (Any)

Return type:

Self

property format: Literal['dense', 'csr']

abstractmethod icos()

Return type:

Self

abstractmethod iexp()

Return type:

Self

abstractmethod ilog()

Return type:

Self

property is_dense: bool

property is_sparse: bool

abstractmethod isin()

Return type:

Self

abstractmethod isqrt()

Return type:

Self

abstractmethod log(*args, **kwargs)

Parameters:

• args (Any)

• kwargs (Any)

Return type:

Self

abstractmethod max(*, axis=None, keepdims=False)

Parameters:

• axis (int | Sequence[int] | None)

• keepdims (bool)

Return type:

BaseArray[Data]

abstractmethod mean(*, axis=None, keepdims=False)

Parameters:

• axis (int | Sequence[int] | None)

• keepdims (bool)

Return type:

BaseArray[Data]

abstractmethod min(*, axis=None, keepdims=False)

Parameters:

• axis (int | Sequence[int] | None)

• keepdims (bool)

Return type:

BaseArray[Data]

property ndim: int

property nnz: int

abstractmethod reshape(*, shape)

Parameters:

shape (int | Sequence[int])

Return type:

Self

abstract property shape: tuple[int, ...]

abstractmethod sin(*args, **kwargs)

Parameters:

• args (Any)

• kwargs (Any)

Return type:

Self

property size: int

abstractmethod sqrt(*args, **kwargs)

Parameters:

• args (Any)

• kwargs (Any)

Return type:

Self

abstractmethod squeeze(*, axis)

Parameters:

axis (int | Sequence[int])

Return type:

Self

abstractmethod classmethod stack(arrs, /, *, axis=0)

Parameters:

• arrs (Sequence[Self])

• axis (int)

Return type:

Self

abstractmethod sum(*, axis=None, keepdims=False)

Parameters:

• axis (int | Sequence[int] | None)

• keepdims (bool)

Return type:

BaseArray[Data]

property values: Storage[Data]

src.array.base.unwrap(stg_like)

Parameters:

stg_like (Any)

Return type:

Any

src.array.base.unwrap_args(args)

Parameters:

args (tuple)

Return type:

tuple

src.array.base.unwrap_kwargs(kwargs)

Parameters:

kwargs (dict)

Return type:

dict[str, Any]

Module contents

src.array.BACKEND

alias of NumpyBackend

class src.array.BaseArray(*args, **kwargs)

Bases: Generic[Data], ABC

Parameters:

• args (Any)

• kwargs (Any)

abstractmethod classmethod as_array(*args, **kwargs)

Parameters:

• args (Any)

• kwargs (Any)

Return type:

Self

abstractmethod as_csr(*args, **kwargs)

Parameters:

• args (Any)

• kwargs (Any)

Return type:

CsrArray[Data]

abstractmethod as_dense(*args, **kwargs)

Parameters:

• args (Any)

• kwargs (Any)

Return type:

DenseArray[Data]

abstractmethod as_nparray(*args, **kwargs)

Parameters:

• args (Any)

• kwargs (Any)

Return type:

ndarray[tuple[int, …], Data]

abstractmethod as_type(*args, **kwargs)

Parameters:

• args (Any)

• kwargs (Any)

Return type:

Self

abstractmethod broadcast_to(*, shape)

Parameters:

shape (int | Sequence[int])

Return type:

Self

abstractmethod compress(*, keep, axis=0)

Parameters:

• keep (Any | Sequence[Any])

• axis (int | Sequence[int] | None)

Return type:

BaseArray[Data]

abstractmethod compress_axis(*, keep, axis=0)

Parameters:

• keep (Any)

• axis (int | None)

Return type:

BaseArray[Data]

abstractmethod classmethod concat(arrs, /, *, axis=0)

Parameters:

• arrs (Sequence[Self])

• axis (int)

Return type:

Self

abstractmethod copy(*args, **kwargs)

Parameters:

• args (Any)

• kwargs (Any)

Return type:

Self

abstractmethod cos(*args, **kwargs)

Parameters:

• args (Any)

• kwargs (Any)

Return type:

Self

abstractmethod count_nonzero(*, axis=None, keepdims=False)

Parameters:

• axis (int | Sequence[int] | None)

• keepdims (bool)

Return type:

BaseArray[Data]

abstractmethod diagonal()

Return type:

BaseArray[Data]

property dtype: type

abstractmethod exp(*args, **kwargs)

Parameters:

• args (Any)

• kwargs (Any)

Return type:

Self

abstractmethod expand_dims(*, axis)

Parameters:

axis (int | Sequence[int])

Return type:

Self

abstractmethod fill_diagonal(*args, **kwargs)

Parameters:

• args (Any)

• kwargs (Any)

Return type:

Self

property format: Literal['dense', 'csr']

abstractmethod icos()

Return type:

Self

abstractmethod iexp()

Return type:

Self

abstractmethod ilog()

Return type:

Self

property is_dense: bool

property is_sparse: bool

abstractmethod isin()

Return type:

Self

abstractmethod isqrt()

Return type:

Self

abstractmethod log(*args, **kwargs)

Parameters:

• args (Any)

• kwargs (Any)

Return type:

Self

abstractmethod max(*, axis=None, keepdims=False)

Parameters:

• axis (int | Sequence[int] | None)

• keepdims (bool)

Return type:

BaseArray[Data]

abstractmethod mean(*, axis=None, keepdims=False)

Parameters:

• axis (int | Sequence[int] | None)

• keepdims (bool)

Return type:

BaseArray[Data]

abstractmethod min(*, axis=None, keepdims=False)

Parameters:

• axis (int | Sequence[int] | None)

• keepdims (bool)

Return type:

BaseArray[Data]

property ndim: int

property nnz: int

abstractmethod reshape(*, shape)

Parameters:

shape (int | Sequence[int])

Return type:

Self

abstract property shape: tuple[int, ...]

abstractmethod sin(*args, **kwargs)

Parameters:

• args (Any)

• kwargs (Any)

Return type:

Self

property size: int

abstractmethod sqrt(*args, **kwargs)

Parameters:

• args (Any)

• kwargs (Any)

Return type:

Self

abstractmethod squeeze(*, axis)

Parameters:

axis (int | Sequence[int])

Return type:

Self

abstractmethod classmethod stack(arrs, /, *, axis=0)

Parameters:

• arrs (Sequence[Self])

• axis (int)

Return type:

Self

abstractmethod sum(*, axis=None, keepdims=False)

Parameters:

• axis (int | Sequence[int] | None)

• keepdims (bool)

Return type:

BaseArray[Data]

property values: Storage[Data]

class src.array.CsrArray(values_like, index_like, /, *, shape, dtype=None, copy_values=False, copy_index=False)

Bases: Generic[Data], SparseArray[Data]

Parameters:

• values_like (Any)

• index_like (Sequence[Any])

• shape (Sequence[int])

• dtype (Optional[type])

• copy_values (bool)

• copy_index (bool)

static as_array(values_like, index_like, /, *, shape=None, dtype=None, copy_values=False, copy_index=False)

Parameters:

• values_like (Any)

• index_like (Sequence[Any])

• shape (Sequence[int] | None)

• dtype (type | None)

• copy_values (bool)

• copy_index (bool)

Return type:

CsrArray[Data]

as_csr(copy_values=True, copy_index=True)

Parameters:

• copy_values (bool)

• copy_index (bool)

Return type:

Self

as_nparray()

Return type:

ndarray

static broadcast_to(*, shape)

Parameters:

shape (int | Sequence[int])

Return type:

NoReturn

compress(*, keep, axis=0)

Parameters:

• keep (Any | Sequence[Any])

• axis (int | Sequence[int] | None)

Return type:

CsrArray[Data]

compress_axis(*, keep, axis=0)

Parameters:

• keep (Any)

• axis (int | None)

Return type:

CsrArray[Data]

static concat(arrs, /, *, axis=0)

Parameters:

• arrs (Sequence[CsrArray[Data]])

• axis (int)

Return type:

CsrArray[Data]

count_nonzero(*, axis=None, keepdims=False)

Parameters:

• axis (int | Sequence[int] | None)

• keepdims (bool)

Return type:

DenseArray[Data]

diagonal()

Return type:

BaseArray[Data]

static expand_dims(*, axis)

Parameters:

axis (int | Sequence[int])

Return type:

NoReturn

fill_diagonal(other)

Parameters:

other (Any)

Return type:

CsrArray[Data]

get_dense_index()

Return type:

tuple[Storage[Data], Storage[Data]]

property indices: Storage[Data]

property indptr: Storage[Data]

static mask_as_csr_index(mask_like)

Parameters:

mask_like (Any)

Return type:

tuple[Storage[Data], Storage[Data], tuple[int, int]]

max(*, axis=None, keepdims=False)

Parameters:

• axis (int | Sequence[int] | None)

• keepdims (bool)

Return type:

DenseArray[Data]

mean(*, axis=None, keepdims=False)

Parameters:

• axis (int | Sequence[int] | None)

• keepdims (bool)

Return type:

DenseArray[Data]

min(*, axis=None, keepdims=False)

Parameters:

• axis (int | Sequence[int] | None)

• keepdims (bool)

Return type:

DenseArray[Data]

property ncols: int

property nrows: int

static reshape(*, shape)

Parameters:

shape (int | Sequence[int])

Return type:

NoReturn

property shape: tuple[int, int]

static squeeze(*, axis)

Parameters:

axis (int | Sequence[int])

Return type:

NoReturn

static stack(arrs, /, *, axis=0)

Parameters:

• arrs (Sequence[CsrArray[Data]])

• axis (int)

Return type:

NoReturn

sum(*, axis=None, keepdims=False)

Parameters:

• axis (int | Sequence[int] | None)

• keepdims (bool)

Return type:

DenseArray[Data]

class src.array.DenseArray(arr_like, /, *, dtype=None, copy=False, **kwargs)

Bases: Generic[Data], BaseArray[Data]

Parameters:

• arr_like (Any)

• dtype (Optional[type])

• copy (bool)

• kwargs (Any)

static as_array(arr_like, /, *, dtype=None, copy=False)

Parameters:

• arr_like (Any)

• dtype (type | None)

• copy (bool)

Return type:

DenseArray[Data]

as_csr()

Return type:

NoReturn

as_dense(copy=False)

Parameters:

copy (bool)

Return type:

DenseArray[Data]

as_nparray()

Return type:

ndarray

as_type(*, dtype, copy=False)

Parameters:

• dtype (type)

• copy (bool)

Return type:

DenseArray[Data]

broadcast_to(*args, **kwargs)

Parameters:

• self (DenseArray[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

DenseArray[Data]

compress(*args, **kwargs)

Parameters:

• self (DenseArray[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

DenseArray[Data]

compress_axis(*args, **kwargs)

Parameters:

• self (DenseArray[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

DenseArray[Data]

static concat(arrs, /, *, axis=0)

Parameters:

• arrs (Sequence[DenseArray[Data]])

• axis (int)

Return type:

DenseArray[Data]

copy(*args, **kwargs)

Parameters:

• self (DenseArray[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

DenseArray[Data]

cos(*args, **kwargs)

Parameters:

• self (DenseArray[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

DenseArray[Data]

count_nonzero(*args, **kwargs)

Parameters:

• self (DenseArray[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

DenseArray[Data]

diagonal(*args, **kwargs)

Parameters:

• self (DenseArray[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

DenseArray[Data]

distance(*args, **kwargs)

Parameters:

• self (DenseArray[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

DenseArray[Data]

distance_lazy(*args, **kwargs)

Parameters:

• self (DenseArray[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Iterator[DenseArray[Data]]

exp(*args, **kwargs)

Parameters:

• self (DenseArray[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

DenseArray[Data]

expand_dims(*args, **kwargs)

Parameters:

• self (DenseArray[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

DenseArray[Data]

fill_diagonal(*args, **kwargs)

Parameters:

• self (DenseArray[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

DenseArray[Data]

static full(fill_value, /, *, shape, dtype=None)

Parameters:

• fill_value (Any)

• shape (int | Sequence[int])

• dtype (type | None)

Return type:

DenseArray[Data]

icos(*args, **kwargs)

Parameters:

• self (DenseArray[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

DenseArray[Data]

iexp(*args, **kwargs)

Parameters:

• self (DenseArray[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

DenseArray[Data]

ilog(*args, **kwargs)

Parameters:

• self (DenseArray[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

DenseArray[Data]

isin(*args, **kwargs)

Parameters:

• self (DenseArray[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

DenseArray[Data]

isqrt(*args, **kwargs)

Parameters:

• self (DenseArray[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

DenseArray[Data]

log(*args, **kwargs)

Parameters:

• self (DenseArray[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

DenseArray[Data]

max(*args, **kwargs)

Parameters:

• self (DenseArray[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

DenseArray[Data]

mean(*args, **kwargs)

Parameters:

• self (DenseArray[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

DenseArray[Data]

min(*args, **kwargs)

Parameters:

• self (DenseArray[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

DenseArray[Data]

static ones(*, shape, dtype=None)

Parameters:

• shape (int | Sequence[int])

• dtype (type | None)

Return type:

DenseArray[Data]

reshape(*args, **kwargs)

Parameters:

• self (DenseArray[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

DenseArray[Data]

property shape: tuple[int, ...]

sin(*args, **kwargs)

Parameters:

• self (DenseArray[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

DenseArray[Data]

sqrt(*args, **kwargs)

Parameters:

• self (DenseArray[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

DenseArray[Data]

squeeze(*args, **kwargs)

Parameters:

• self (DenseArray[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

DenseArray[Data]

static stack(arrs, /, *, axis=0)

Parameters:

• arrs (Sequence[DenseArray[Data]])

• axis (int)

Return type:

DenseArray[Data]

sum(*args, **kwargs)

Parameters:

• self (DenseArray[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

DenseArray[Data]

static zeros(*, shape, dtype=None)

Parameters:

• shape (int | Sequence[int])

• dtype (type | None)

Return type:

DenseArray[Data]

class src.array.SparseArray(values_like, index_like, /, *, shape, dtype=None, copy_values=False, copy_index=False, **kwargs)

Bases: Generic[Data], BaseArray[Data]

Parameters:

• values_like (Any)

• index_like (Sequence[Any])

• shape (Sequence[int])

• dtype (Optional[type])

• copy_values (bool)

• copy_index (bool)

• kwargs (Any)

as_dense(fill_value)

Parameters:

fill_value (Any)

Return type:

DenseArray[Data]

as_type(*, dtype, copy_values=False, copy_index=False)

Parameters:

• dtype (type)

• copy_values (bool)

• copy_index (bool)

Return type:

Self

copy(copy_values=True, copy_index=True)

Parameters:

• copy_values (bool)

• copy_index (bool)

Return type:

Self

cos(copy_index=False)

Parameters:

• self (SparseArray[Data])

• copy_index (bool)

Return type:

SparseArray[Data]

exp(copy_index=False)

Parameters:

• self (SparseArray[Data])

• copy_index (bool)

Return type:

SparseArray[Data]

abstractmethod get_dense_index()

Return type:

tuple[Storage[Data], …]

icos()

Parameters:

self (SparseArray[Data])

Return type:

SparseArray[Data]

iexp()

Parameters:

self (SparseArray[Data])

Return type:

SparseArray[Data]

ilog()

Parameters:

self (SparseArray[Data])

Return type:

SparseArray[Data]

property index: tuple[Storage[Data], ...]

isin()

Parameters:

self (SparseArray[Data])

Return type:

SparseArray[Data]

isqrt()

Parameters:

self (SparseArray[Data])

Return type:

SparseArray[Data]

log(copy_index=False)

Parameters:

• self (SparseArray[Data])

• copy_index (bool)

Return type:

SparseArray[Data]

property shape: tuple[int, ...]

sin(copy_index=False)

Parameters:

• self (SparseArray[Data])

• copy_index (bool)

Return type:

SparseArray[Data]

property sparsity: float

sqrt(copy_index=False)

Parameters:

• self (SparseArray[Data])

• copy_index (bool)

Return type:

SparseArray[Data]

class src.array.Storage(stg_like, /, *, dtype=None, copy=False)

Bases: Generic[Data]

Parameters:

• stg_like (Any)

• dtype (Optional[type])

• copy (bool)

abs(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

add_at(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

add_between(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

static arange(*, start, stop, step=None, dtype=None)

Parameters:

• start (int)

• stop (int)

• step (int | None)

• dtype (type | None)

Return type:

Storage[Data]

static as_index(index_like, /, *, copy=False, assert_flat=True)

Parameters:

• index_like (Any)

• copy (bool)

• assert_flat (bool)

Return type:

Storage[Data]

static as_mask(mask_like, /, *, copy=False, assert_flat=False)

Parameters:

• mask_like (Any)

• copy (bool)

• assert_flat (bool)

Return type:

Storage[Data]

static as_storage(stg_like, /, *, dtype=None, copy=False)

Parameters:

• stg_like (Any)

• dtype (type | None)

• copy (bool)

Return type:

Storage[Data]

as_type(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

static as_values(values_like, /, *, dtype=None, copy=False, assert_flat=False)

Parameters:

• values_like (Any)

• dtype (type | None)

• copy (bool)

• assert_flat (bool)

Return type:

Storage[Data]

bin_count(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

broadcast_to(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

compress(*, keep, axis=0)

Parameters:

• keep (Any | Sequence[Any])

• axis (int | Sequence[int] | None)

Return type:

Storage[Data]

compress_axis(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

static concat(stgs, /, *, axis=0)

Parameters:

• stgs (Sequence[Storage[Data]])

• axis (int)

Return type:

Storage[Data]

copy(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

cos(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

count_nonzero(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

cumsum(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

property data: Data

diagonal(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

diff(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

distance(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

distance_lazy(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Iterator[Storage[Data]]

property dtype: type

exp(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

expand_dims(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

fill_diagonal(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

flat_nonzero(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

static full(fill_value, /, *, shape, dtype=None)

Parameters:

• fill_value (Any)

• shape (int | Sequence[int])

• dtype (type | None)

Return type:

Storage[Data]

iabs(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

icos(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

iexp(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

ilog(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

isin(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

isqrt(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

log(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

max(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

mean(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

min(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

property ndim: int

static ones(*, shape, dtype=None)

Parameters:

• shape (int | Sequence[int])

• dtype (type | None)

Return type:

Storage[Data]

repeat(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

reshape(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

segment_max(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

segment_mean(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

segment_min(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

segment_sum(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

property shape: tuple[int, ...]

sin(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

property size: int

sqrt(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

squeeze(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

static stack(stgs, /, *, axis=0)

Parameters:

• stgs (Sequence[Storage[Data]])

• axis (int)

Return type:

Storage[Data]

sum(*args, **kwargs)

Parameters:

• self (Storage[Data])

• args (~_OpArgs)

• kwargs (~_OpArgs)

Return type:

Storage[Data]

static zeros(*, shape, dtype=None)

Parameters:

• shape (int | Sequence[int])

• dtype (type | None)

Return type:

Storage[Data]