Struct tc_collection::tensor::sparse::SparseTensor

pub struct SparseTensor<Txn, FE, A> { /* private fields */ }

Implementations

impl<Txn, FE, A> SparseTensor<Txn, FE, A>

pub fn into_inner(self) -> A

impl<Txn, FE, T: CType> SparseTensor<Txn, FE, SparseAccess<Txn, FE, T>>

pub fn from_access<A: Into<SparseAccess<Txn, FE, T>>>(accessor: A) -> Self

impl<Txn, FE, A> SparseTensor<Txn, FE, A>

where Txn: ThreadSafe, FE: ThreadSafe, A: SparseInstance + TensorPermitRead,

pub async fn into_elements( self, txn_id: TxnId ) -> TCResult<Elements<Elements<A::DType>>>

Trait Implementations

impl<Txn, FE, A: Clone> Clone for SparseTensor<Txn, FE, A>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Txn, FE, A: Debug> Debug for SparseTensor<Txn, FE, A>

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

Formats the value using the given formatter.

impl<Txn, FE, A> From<A> for SparseTensor<Txn, FE, A>

fn from(accessor: A) -> Self

Converts to this type from the input type.

impl<Txn, FE> From<SparseTensor<Txn, FE, SparseAccess<Txn, FE, f32>>> for SparseView<Txn, FE>

fn from(tensor: SparseTensor<Txn, FE, SparseAccess<Txn, FE, f32>>) -> Self

Converts to this type from the input type.

impl<Txn, FE> From<SparseTensor<Txn, FE, SparseAccess<Txn, FE, f64>>> for SparseView<Txn, FE>

fn from(tensor: SparseTensor<Txn, FE, SparseAccess<Txn, FE, f64>>) -> Self

Converts to this type from the input type.

impl<Txn, FE, L, R> TensorBoolean<SparseTensor<Txn, FE, R>> for SparseTensor<Txn, FE, L>

where Txn: Transaction<FE>, FE: AsType<Node> + ThreadSafe, L: SparseInstance + Into<SparseAccess<Txn, FE, L::DType>>, R: SparseInstance<DType = L::DType> + Into<SparseAccess<Txn, FE, R::DType>>, Number: From<L::DType> + From<R::DType>, SparseAccessCast<Txn, FE>: From<SparseAccess<Txn, FE, L::DType>>,

type Combine = SparseTensor<Txn, FE, SparseCompare<Txn, FE, u8>>

The result type of a boolean operation.

type LeftCombine = SparseTensor<Txn, FE, SparseCompareLeft<Txn, FE, u8>>

The result type of a boolean operation which may ignore right-hand values.

fn and(self, other: SparseTensor<Txn, FE, R>) -> TCResult<Self::LeftCombine>

Logical and

fn or(self, other: SparseTensor<Txn, FE, R>) -> TCResult<Self::Combine>

Logical or

fn xor(self, other: SparseTensor<Txn, FE, R>) -> TCResult<Self::Combine>

Logical xor

impl<Txn, FE, A> TensorBooleanConst for SparseTensor<Txn, FE, A>

where Txn: Transaction<FE>, FE: AsType<Node> + ThreadSafe, A: SparseInstance + Into<SparseAccess<Txn, FE, A::DType>>, DenseAccess<Txn, FE, A::DType>: From<DenseSparse<A>>, DenseAccessCast<Txn, FE>: From<DenseAccess<Txn, FE, A::DType>>, SparseAccessCast<Txn, FE>: From<SparseAccess<Txn, FE, A::DType>>,

type Combine = SparseTensor<Txn, FE, SparseCompareConst<Txn, FE, u8>>

The return type of a boolean operation.

fn and_const(self, other: Number) -> TCResult<Self::Combine>

Logical and

fn or_const(self, other: Number) -> TCResult<Self::Combine>

Logical or

fn xor_const(self, other: Number) -> TCResult<Self::Combine>

Logical xor

impl<Txn, FE, L, R> TensorCompare<SparseTensor<Txn, FE, R>> for SparseTensor<Txn, FE, L>

where Txn: Transaction<FE>, FE: AsType<Node> + ThreadSafe, L: SparseInstance + Into<SparseAccess<Txn, FE, L::DType>> + Debug, R: SparseInstance<DType = L::DType> + Into<SparseAccess<Txn, FE, R::DType>> + Debug, SparseAccessCast<Txn, FE>: From<SparseAccess<Txn, FE, L::DType>>,

type Compare = SparseTensor<Txn, FE, SparseCompare<Txn, FE, u8>>

The result of a comparison operation

fn eq(self, other: SparseTensor<Txn, FE, R>) -> TCResult<Self::Compare>

Element-wise equality

fn gt(self, other: SparseTensor<Txn, FE, R>) -> TCResult<Self::Compare>

Element-wise greater-than

fn ge(self, other: SparseTensor<Txn, FE, R>) -> TCResult<Self::Compare>

Element-wise greater-or-equal

fn lt(self, other: SparseTensor<Txn, FE, R>) -> TCResult<Self::Compare>

Element-wise less-than

fn le(self, other: SparseTensor<Txn, FE, R>) -> TCResult<Self::Compare>

Element-wise less-or-equal

fn ne(self, other: SparseTensor<Txn, FE, R>) -> TCResult<Self::Compare>

Element-wise not-equal

impl<Txn, FE, A> TensorCompareConst for SparseTensor<Txn, FE, A>

where Txn: Transaction<FE>, FE: AsType<Node> + ThreadSafe, A: SparseInstance + Into<SparseAccess<Txn, FE, A::DType>>, SparseAccessCast<Txn, FE>: From<SparseAccess<Txn, FE, A::DType>>,

type Compare = SparseTensor<Txn, FE, SparseCompareConst<Txn, FE, u8>>

The result of a comparison operation

fn eq_const(self, other: Number) -> TCResult<Self::Compare>

Element-wise equality

fn gt_const(self, other: Number) -> TCResult<Self::Compare>

Element-wise greater-than

fn ge_const(self, other: Number) -> TCResult<Self::Compare>

Element-wise greater-or-equal

fn lt_const(self, other: Number) -> TCResult<Self::Compare>

Element-wise less-than

fn le_const(self, other: Number) -> TCResult<Self::Compare>

Element-wise less-or-equal

fn ne_const(self, other: Number) -> TCResult<Self::Compare>

Element-wise not-equal

impl<Txn, FE, Cond, Then, OrElse, T> TensorCond<SparseTensor<Txn, FE, Then>, SparseTensor<Txn, FE, OrElse>> for SparseTensor<Txn, FE, Cond>

where Txn: ThreadSafe, FE: ThreadSafe, Cond: SparseInstance<DType = u8> + Debug, Then: SparseInstance<DType = T> + Debug, OrElse: SparseInstance<DType = T> + Debug,

type Cond = SparseTensor<Txn, FE, SparseCond<Cond, Then, OrElse>>

The type of Tensor returned by cond

fn cond( self, then: SparseTensor<Txn, FE, Then>, or_else: SparseTensor<Txn, FE, OrElse> ) -> TCResult<Self::Cond>

Use this tensor as a condition to select elements from then or or_else.

impl<Txn, FE, A> TensorConvert for SparseTensor<Txn, FE, A>

where Txn: Transaction<FE>, FE: AsType<Node> + ThreadSafe, A: SparseInstance,

type Dense = DenseTensor<Txn, FE, DenseSparse<A>>

A dense representation of this Tensor

type Sparse = SparseTensor<Txn, FE, A>

A sparse representation of this Tensor

fn into_dense(self) -> Self::Dense

Return a dense representation of this Tensor.

fn into_sparse(self) -> Self::Sparse

Return a sparse representation of this Tensor.

impl<Txn, FE, A> TensorInstance for SparseTensor<Txn, FE, A>

where Txn: ThreadSafe, FE: ThreadSafe, A: TensorInstance,

fn dtype(&self) -> NumberType

fn shape(&self) -> &Shape

fn ndim(&self) -> usize

fn size(&self) -> u64

fn schema(&self) -> Schema

impl<Txn, FE, L, R, T> TensorMath<SparseTensor<Txn, FE, R>> for SparseTensor<Txn, FE, L>

where Txn: Transaction<FE>, FE: AsType<Node> + ThreadSafe, L: SparseInstance<DType = T>, R: SparseInstance<DType = T>, T: CType + DType,

type Combine = SparseTensor<Txn, FE, SparseCombine<L, R, T>>

The result type of a math operation

type LeftCombine = SparseTensor<Txn, FE, SparseCombineLeft<L, R, T>>

The result type of a math operation which may ignore right-hand-side values

fn add(self, other: SparseTensor<Txn, FE, R>) -> TCResult<Self::Combine>

Add two tensors together.

fn div(self, other: SparseTensor<Txn, FE, R>) -> TCResult<Self::LeftCombine>

Divide self by other.

fn log(self, base: SparseTensor<Txn, FE, R>) -> TCResult<Self::LeftCombine>

Element-wise logarithm of self with respect to the given base.

fn mul(self, other: SparseTensor<Txn, FE, R>) -> TCResult<Self::LeftCombine>

Multiply two tensors together.

fn pow(self, other: SparseTensor<Txn, FE, R>) -> TCResult<Self::LeftCombine>

Raise self to the power of other.

fn sub(self, other: SparseTensor<Txn, FE, R>) -> TCResult<Self::Combine>

Subtract other from self.

impl<Txn, FE, A> TensorMathConst for SparseTensor<Txn, FE, A>

where Txn: ThreadSafe, FE: ThreadSafe, A: SparseInstance, A::DType: CastFrom<Number>, <A::DType as CType>::Float: CastFrom<Number>, Number: From<A::DType>,

type Combine = SparseTensor<Txn, FE, SparseCombineConst<A, <A as SparseInstance>::DType>>

The return type of a math operation

fn add_const(self, other: Number) -> TCResult<Self::Combine>

Add a constant to this tensor

fn div_const(self, other: Number) -> TCResult<Self::Combine>

Divide self by other.

fn log_const(self, base: Number) -> TCResult<Self::Combine>

Element-wise logarithm

fn mul_const(self, other: Number) -> TCResult<Self::Combine>

Multiply self by other.

fn pow_const(self, other: Number) -> TCResult<Self::Combine>

Raise self to the power other.

fn sub_const(self, other: Number) -> TCResult<Self::Combine>

Subtract other from self.

impl<Txn, FE, A> TensorRead for SparseTensor<Txn, FE, A>

where Txn: Transaction<FE>, FE: ThreadSafe, A: SparseInstance + TensorPermitRead, Number: From<A::DType>,

fn read_value<'async_trait>( self, txn_id: TxnId, coord: Coord ) -> Pin<Box<dyn Future<Output = TCResult<Number>> + Send + 'async_trait>>

where Self: 'async_trait,

Read a single value from this Tensor.

impl<Txn, FE, A> TensorReduce for SparseTensor<Txn, FE, A>

where Txn: Transaction<FE>, FE: DenseCacheFile + AsType<Buffer<A::DType>> + AsType<Node>, A: SparseInstance + TensorPermitRead + Clone, A::DType: Debug, Buffer<A::DType>: FromStream<Context = ()>, Number: From<A::DType> + CastInto<A::DType>, SparseAccess<Txn, FE, A::DType>: From<A>,

type Reduce = SparseTensor<Txn, FE, SparseReduce<Txn, FE, <A as SparseInstance>::DType>>

The result type of a reduce operation

fn all<'async_trait>( self, txn_id: TxnId ) -> Pin<Box<dyn Future<Output = TCResult<bool>> + Send + 'async_trait>>

where Self: 'async_trait,

Return true if all elements in this Tensor are nonzero.

fn any<'async_trait>( self, txn_id: TxnId ) -> Pin<Box<dyn Future<Output = TCResult<bool>> + Send + 'async_trait>>

where Self: 'async_trait,

Return true if any element in this Tensor is nonzero.

fn max(self, axes: Axes, keepdims: bool) -> TCResult<Self::Reduce>

Return the maximum of this Tensor along the given axis.

fn max_all<'async_trait>( self, txn_id: TxnId ) -> Pin<Box<dyn Future<Output = TCResult<Number>> + Send + 'async_trait>>

where Self: 'async_trait,

Return the maximum element in this Tensor.

fn min(self, axes: Axes, keepdims: bool) -> TCResult<Self::Reduce>

Return the minimum of this Tensor along the given axis.

fn min_all<'async_trait>( self, txn_id: TxnId ) -> Pin<Box<dyn Future<Output = TCResult<Number>> + Send + 'async_trait>>

where Self: 'async_trait,

Return the minimum element in this Tensor.

fn product(self, axes: Axes, keepdims: bool) -> TCResult<Self::Reduce>

Return the product of this Tensor along the given axis.

fn product_all<'async_trait>( self, txn_id: TxnId ) -> Pin<Box<dyn Future<Output = TCResult<Number>> + Send + 'async_trait>>

where Self: 'async_trait,

Return the product of all elements in this Tensor.

fn sum(self, axes: Axes, keepdims: bool) -> TCResult<Self::Reduce>

Return the sum of this Tensor along the given axis.

fn sum_all<'async_trait>( self, txn_id: TxnId ) -> Pin<Box<dyn Future<Output = TCResult<Number>> + Send + 'async_trait>>

where Self: 'async_trait,

Return the sum of all elements in this Tensor.

impl<Txn, FE, A> TensorTransform for SparseTensor<Txn, FE, A>

where Txn: Transaction<FE>, FE: AsType<Node> + ThreadSafe, A: SparseInstance + Into<SparseAccess<Txn, FE, A::DType>>, A::DType: CastFrom<Number> + Debug, Number: From<A::DType>,

type Broadcast = SparseTensor<Txn, FE, SparseBroadcast<Txn, FE, <A as SparseInstance>::DType>>

A broadcast Tensor

type Expand = SparseTensor<Txn, FE, SparseExpand<A>>

A Tensor with an expanded dimension

type Reshape = SparseTensor<Txn, FE, SparseReshape<A>>

A reshaped Tensor

type Slice = SparseTensor<Txn, FE, SparseSlice<A>>

A Tensor slice

type Transpose = SparseTensor<Txn, FE, SparseTranspose<A>>

A transposed Tensor

fn broadcast(self, shape: Shape) -> TCResult<Self::Broadcast>

Broadcast this Tensor to the given shape.

fn expand(self, axes: Axes) -> TCResult<Self::Expand>

Insert a new dimension of size 1 at each of the given axes.

fn reshape(self, shape: Shape) -> TCResult<Self::Reshape>

Change the shape of this Tensor.

fn slice(self, range: Range) -> TCResult<Self::Slice>

Return a slice of this Tensor with the given range.

fn transpose(self, permutation: Option<Axes>) -> TCResult<Self::Transpose>

Transpose this Tensor by reordering its axes according to the given permutation. If no permutation is given, the axes will be reversed.

impl<Txn, FE, A> TensorUnary for SparseTensor<Txn, FE, A>

where Txn: ThreadSafe, FE: ThreadSafe, A: SparseInstance,

type Unary = SparseTensor<Txn, FE, SparseUnary<A, <A as SparseInstance>::DType>>

The return type of a unary operation

fn abs(self) -> TCResult<Self::Unary>

Element-wise absolute value

fn exp(self) -> TCResult<Self::Unary>

Element-wise exponentiation

fn ln(self) -> TCResult<Self::Unary>

Element-wise natural logarithm

fn round(self) -> TCResult<Self::Unary>

Element-wise round to the nearest integer

impl<Txn, FE, A> TensorUnaryBoolean for SparseTensor<Txn, FE, A>

where Txn: Transaction<FE>, FE: AsType<Node> + ThreadSafe, A: SparseInstance + Into<SparseAccess<Txn, FE, A::DType>>, SparseAccessCast<Txn, FE>: From<SparseAccess<Txn, FE, A::DType>>,

type Unary = SparseTensor<Txn, FE, SparseUnaryCast<Txn, FE, u8>>

The return type of a unary operation

fn not(self) -> TCResult<Self::Unary>

Element-wise logical not