brainevent.binary_csrmv

Contents

brainevent.binary_csrmv#

brainevent.binary_csrmv = <NameScope(brainevent.binary_csrmv)>#

Product of a CSR sparse matrix and a dense vector using event-driven (binary) computation.

Computes y = A @ v (or y = A.T @ v when transpose=True) where A is stored in Compressed Sparse Row format and v is treated as a binary event vector. Elements of v that are True (boolean) or positive (float) are considered active events; only those contribute to the result, enabling efficient event-driven sparse–dense products commonly used in spiking neural networks.

The function supports physical units via brainunit. If data or v carry units, the result is returned in the corresponding product unit.

Parameters:

  • data (Array | ndarray | Quantity | Number) – Non-zero weight values of the CSR matrix. Shape (nse,) for heterogeneous weights or (1,) for a single homogeneous weight shared across all connections.

  • indices (Array | ndarray) – Column indices of the non-zero elements. Shape (nse,) with integer dtype (int32, int64, uint32, or uint64).

  • indptr (Array | ndarray) – Row index pointer array. Shape (shape[0] + 1,) and same dtype as indices. indptr[i] and indptr[i+1] delimit the non-zero entries of row i.

  • v (Array | ndarray | Quantity | Number) – Dense event vector. Shape (shape[0],) when transpose=True or (shape[1],) when transpose=False. Dtype may be boolean (events indicated by True) or floating-point (events indicated by values > 0).

  • shape (Tuple[int, int]) – Two-element tuple (m, k) giving the logical shape of the sparse matrix A.

  • transpose (bool) – If True, the sparse matrix is transposed before multiplication, i.e. compute A.T @ v. Default is False.

  • backend (str | None) – Compute backend to use. One of 'numba', 'pallas', or None (auto-select). Default is None.

Returns:

y – Result vector. Shape (shape[1],) when transpose=True or (shape[0],) when transpose=False.

Return type:

Array | ndarray | Quantity | Number

See also

binary_csrmm

Binary CSR matrix–matrix multiplication.

csrmv

Standard (non-event-driven) CSR matrix–vector multiplication.

Notes

This operation is event-driven: instead of performing a full sparse–dense product, it skips columns (or rows, when transposed) for which the corresponding entry in v is inactive (False or <= 0). This yields significant speed-ups when the event vector is sparse.

Mathematically, the non-transposed operation computes:

y[i] = sum_{j in nz(i)} A[i, j] * e(v[j])

where nz(i) denotes the set of column indices with non-zero entries in row i, and e(v[j]) is the event indicator:

e(v[j]) = 1  if v[j] is True (bool) or v[j] > 0 (float) e(v[j]) = 0  otherwise

When transpose=True, the transposed operation computes:

y[j] = sum_{i in nz_col(j)} A[i, j] * e(v[i])

where nz_col(j) denotes the set of row indices with non-zero entries in column j.

For homogeneous weights (data of shape (1,)), A[i, j] is the constant data[0] for all non-zero positions.

The operation is differentiable with respect to both data and v via custom JVP and transpose rules.

References

Examples

>>> import jax.numpy as jnp
>>> from brainevent._csr.binary import binary_csrmv
>>> data = jnp.array([0.5])           # homogeneous weight
>>> indices = jnp.array([0, 2, 1, 2], dtype=jnp.int32)
>>> indptr = jnp.array([0, 2, 4], dtype=jnp.int32)
>>> v = jnp.array([True, False, True])  # binary event vector
>>> binary_csrmv(data, indices, indptr, v, shape=(2, 3))
Contents