Struct tc_collection::tensor::dense::DenseTensor

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

Implementations

impl<Txn, FE, A> DenseTensor<Txn, FE, A>

pub fn into_inner(self) -> A

impl<Txn, FE, T: CType> DenseTensor<Txn, FE, DenseAccess<Txn, FE, T>>

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

Trait Implementations

impl<Txn, FE, A: Clone> Clone for DenseTensor<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 DenseTensor<Txn, FE, A>

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

Formats the value using the given formatter.

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

fn from(accessor: A) -> Self

Converts to this type from the input type.

impl<Txn, FE> From<DenseTensor<Txn, FE, DenseAccess<Txn, FE, f32>>> for DenseView<Txn, FE>

fn from(tensor: DenseTensor<Txn, FE, DenseAccess<Txn, FE, f32>>) -> Self

Converts to this type from the input type.

impl<Txn, FE> From<DenseTensor<Txn, FE, DenseAccess<Txn, FE, f64>>> for DenseView<Txn, FE>

fn from(tensor: DenseTensor<Txn, FE, DenseAccess<Txn, FE, f64>>) -> Self

Converts to this type from the input type.

impl<Txn, FE, L, R, T> TensorBoolean<DenseTensor<Txn, FE, R>> for DenseTensor<Txn, FE, L>

where Txn: Transaction<FE>, FE: DenseCacheFile + AsType<Buffer<T>> + AsType<Node>, L: DenseInstance<DType = T> + Into<DenseAccess<Txn, FE, T>> + Debug, R: DenseInstance<DType = T> + Into<DenseAccess<Txn, FE, T>> + Debug, T: CType + DType + Debug, DenseAccessCast<Txn, FE>: From<DenseAccess<Txn, FE, T>>, DenseTensor<Txn, FE, R>: Debug, Buffer<T>: FromStream<Context = ()>, Number: From<T> + CastInto<T>, Self: Debug,

type Combine = DenseTensor<Txn, FE, DenseCompare<Txn, FE, u8>>

The result type of a boolean operation.

type LeftCombine = DenseTensor<Txn, FE, DenseCompare<Txn, FE, u8>>

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

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

Logical and

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

Logical or

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

Logical xor

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

where Txn: ThreadSafe, FE: ThreadSafe, A: DenseInstance + Into<DenseAccess<Txn, FE, A::DType>>, DenseAccessCast<Txn, FE>: From<DenseAccess<Txn, FE, A::DType>>,

type Combine = DenseTensor<Txn, FE, DenseCompareConst<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, T> TensorCompare<DenseTensor<Txn, FE, R>> for DenseTensor<Txn, FE, L>

where Txn: ThreadSafe, FE: ThreadSafe, L: DenseInstance<DType = T> + Into<DenseAccessCast<Txn, FE>>, R: DenseInstance<DType = T> + Into<DenseAccessCast<Txn, FE>>, T: CType + DType,

type Compare = DenseTensor<Txn, FE, DenseCompare<Txn, FE, u8>>

The result of a comparison operation

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

Element-wise equality

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

Element-wise greater-than

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

Element-wise greater-or-equal

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

Element-wise less-than

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

Element-wise less-or-equal

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

Element-wise not-equal

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

where Txn: ThreadSafe, FE: ThreadSafe, A: DenseInstance + Into<DenseAccessCast<Txn, FE>>,

type Compare = DenseTensor<Txn, FE, DenseCompareConst<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<DenseTensor<Txn, FE, Then>, DenseTensor<Txn, FE, OrElse>> for DenseTensor<Txn, FE, Cond>

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

type Cond = DenseTensor<Txn, FE, DenseCond<Cond, Then, OrElse>>

The type of Tensor returned by cond

fn cond( self, then: DenseTensor<Txn, FE, Then>, or_else: DenseTensor<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 DenseTensor<Txn, FE, A>

where Txn: ThreadSafe, FE: ThreadSafe, A: DenseInstance + Into<DenseAccess<Txn, FE, A::DType>> + Clone,

type Dense = DenseTensor<Txn, FE, A>

A dense representation of this Tensor

type Sparse = SparseTensor<Txn, FE, SparseDense<Txn, FE, <A as DenseInstance>::DType>>

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> TensorDiagonal for DenseTensor<Txn, FE, A>

where Txn: ThreadSafe, FE: ThreadSafe, A: DenseInstance,

type Diagonal = DenseTensor<Txn, FE, DenseDiagonal<A>>

The type of Tensor returned by diagonal

fn diagonal(self) -> TCResult<Self::Diagonal>

impl<Txn, FE, A> TensorInstance for DenseTensor<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> TensorMatMul<DenseTensor<Txn, FE, R>> for DenseTensor<Txn, FE, L>

where Txn: ThreadSafe, FE: ThreadSafe, L: DenseInstance<DType = T>, R: DenseInstance<DType = T>, T: CType + DType,

type MatMul = DenseTensor<Txn, FE, DenseMatMul<L, R>>

The type of Tensor returned by matmul

fn matmul(self, other: DenseTensor<Txn, FE, R>) -> TCResult<Self::MatMul>

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

where Txn: ThreadSafe, FE: ThreadSafe, L: DenseInstance<DType = T>, R: DenseInstance<DType = T>, T: CType + DType,

type Combine = DenseTensor<Txn, FE, DenseCombine<L, R, T>>

The result type of a math operation

type LeftCombine = DenseTensor<Txn, FE, DenseCombine<L, R, T>>

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

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

Add two tensors together.

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

Divide self by other.

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

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

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

Multiply two tensors together.

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

Raise self to the power of other.

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

Subtract other from self.

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

where Txn: ThreadSafe, FE: ThreadSafe, A: DenseInstance, Number: CastInto<A::DType>,

type Combine = DenseTensor<Txn, FE, DenseConst<A, <A as DenseInstance>::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 DenseTensor<Txn, FE, A>

where Txn: Transaction<FE>, FE: DenseCacheFile + AsType<Buffer<A::DType>> + AsType<Node>, A: DenseInstance + 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 DenseTensor<Txn, FE, A>

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

type Reduce = DenseTensor<Txn, FE, DenseReduce<DenseAccess<Txn, FE, <A as DenseInstance>::DType>, <A as DenseInstance>::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 DenseTensor<Txn, FE, A>

where Txn: ThreadSafe, FE: ThreadSafe, A: DenseInstance,

type Broadcast = DenseTensor<Txn, FE, DenseBroadcast<A>>

A broadcast Tensor

type Expand = DenseTensor<Txn, FE, DenseExpand<A>>

A Tensor with an expanded dimension

type Reshape = DenseTensor<Txn, FE, DenseReshape<A>>

A reshaped Tensor

type Slice = DenseTensor<Txn, FE, DenseSlice<A>>

A Tensor slice

type Transpose = DenseTensor<Txn, FE, DenseTranspose<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: ThreadSafe, FE: ThreadSafe, A: DenseInstance> TensorUnary for DenseTensor<Txn, FE, A>

type Unary = DenseTensor<Txn, FE, DenseUnary<A, <A as DenseInstance>::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 DenseTensor<Txn, FE, A>

where Txn: Transaction<FE>, FE: DenseCacheFile, A: DenseInstance + Into<DenseAccessCast<Txn, FE>>,

type Unary = DenseTensor<Txn, FE, DenseUnaryCast<Txn, FE, u8>>

The return type of a unary operation

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

Element-wise logical not