Struct SparseTensorIndexCOO

pub struct SparseTensorIndexCOO<'a> {
    pub _tab: Table<'a>,
}

---

EXPERIMENTAL: Data structures for sparse tensors Coordinate (COO) format of sparse tensor index.

COO’s index list are represented as a NxM matrix, where N is the number of non-zero values, and M is the number of dimensions of a sparse tensor.

indicesBuffer stores the location and size of the data of this indices matrix. The value type and the stride of the indices matrix is specified in indicesType and indicesStrides fields.

For example, let X be a 2x3x4x5 tensor, and it has the following 6 non-zero values:

  X[0, 1, 2, 0] := 1
  X[1, 1, 2, 3] := 2
  X[0, 2, 1, 0] := 3
  X[0, 1, 3, 0] := 4
  X[0, 1, 2, 1] := 5
  X[1, 2, 0, 4] := 6

In COO format, the index matrix of X is the following 4x6 matrix:

  [[0, 0, 0, 0, 1, 1],
   [1, 1, 1, 2, 1, 2],
   [2, 2, 3, 1, 2, 0],
   [0, 1, 0, 0, 3, 4]]

When isCanonical is true, the indices is sorted in lexicographical order (row-major order), and it does not have duplicated entries. Otherwise, the indices may not be sorted, or may have duplicated entries.

Fields

_tab: Table<'a>

Implementations

impl<'a> SparseTensorIndexCOO<'a>

pub const VT_INDICESTYPE: u16 = 4u16

pub const VT_INDICESSTRIDES: u16 = 6u16

pub const VT_INDICESBUFFER: u16 = 8u16

pub const VT_ISCANONICAL: u16 = 10u16

pub unsafe fn init_from_table(table: Table<'a>) -> SparseTensorIndexCOO<'a>

pub fn create<'bldr, 'args, 'mut_bldr, A>( _fbb: &'mut_bldr mut FlatBufferBuilder<'bldr, A>, args: &'args SparseTensorIndexCOOArgs<'args>, ) -> WIPOffset<SparseTensorIndexCOO<'bldr>>

where 'bldr: 'args, 'args: 'mut_bldr, A: Allocator + 'bldr,

pub fn indicesType(&self) -> Int<'a>

The type of values in indicesBuffer

pub fn indicesStrides(&self) -> Option<Vector<'a, i64>>

Non-negative byte offsets to advance one value cell along each dimension If omitted, default to row-major order (C-like).

pub fn indicesBuffer(&self) -> &'a Buffer

The location and size of the indices matrix’s data

pub fn isCanonical(&self) -> bool

This flag is true if and only if the indices matrix is sorted in row-major order, and does not have duplicated entries. This sort order is the same as of Tensorflow’s SparseTensor, but it is inverse order of SciPy’s canonical coo_matrix (SciPy employs column-major order for its coo_matrix).

Trait Implementations

impl<'a> Clone for SparseTensorIndexCOO<'a>

fn clone(&self) -> SparseTensorIndexCOO<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SparseTensorIndexCOO<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'a> Follow<'a> for SparseTensorIndexCOO<'a>

type Inner = SparseTensorIndexCOO<'a>

unsafe fn follow( buf: &'a [u8], loc: usize, ) -> <SparseTensorIndexCOO<'a> as Follow<'a>>::Inner

Safety

impl<'a> PartialEq for SparseTensorIndexCOO<'a>

fn eq(&self, other: &SparseTensorIndexCOO<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Verifiable for SparseTensorIndexCOO<'_>

fn run_verifier( v: &mut Verifier<'_, '_>, pos: usize, ) -> Result<(), InvalidFlatbuffer>

Runs the verifier for this type, assuming its at position pos in the verifier’s buffer. Should not need to be called directly.

impl<'a> Copy for SparseTensorIndexCOO<'a>

impl<'a> StructuralPartialEq for SparseTensorIndexCOO<'a>