Struct DotGeneralAccumulation 

pub struct DotGeneralAccumulation {
    pub lhs_conj: bool,
    pub rhs_conj: bool,
    pub alpha: ContractionScalar,
    pub beta: ContractionScalar,
}

Output-update semantics for dot-general accumulation.

This keeps contraction axes in DotGeneralConfig and output update semantics here, so cached and non-cached backend traits can share the same accumulation contract.

Examples

use tenferro_tensor::{ContractionScalar, DotGeneralAccumulation, DType};

let accum = DotGeneralAccumulation::overwrite(DType::F64).unwrap();
assert_eq!(accum.alpha, ContractionScalar::F64(1.0));
assert_eq!(accum.beta, ContractionScalar::F64(0.0));

Fields

lhs_conj: bool

rhs_conj: bool

alpha: ContractionScalar

beta: ContractionScalar

Implementations

impl DotGeneralAccumulation

pub fn overwrite(dtype: DType) -> Result<Self>

Return overwrite semantics, out = lhs dot rhs, for dtype.

pub fn add_to(dtype: DType) -> Result<Self>

Return additive update semantics, out += lhs dot rhs, for dtype.

Examples

use tenferro_tensor::{ContractionScalar, DType, DotGeneralAccumulation};

let accum = DotGeneralAccumulation::add_to(DType::F64)?;
assert_eq!(accum.alpha, ContractionScalar::F64(1.0));
assert_eq!(accum.beta, ContractionScalar::F64(1.0));

pub fn scaled(alpha: ContractionScalar, beta: ContractionScalar) -> Result<Self>

Return scaled update semantics, out = alpha * lhs dot rhs + beta * out.

Examples

use tenferro_tensor::{ContractionScalar, DotGeneralAccumulation};

let accum = DotGeneralAccumulation::scaled(
    ContractionScalar::F32(0.5),
    ContractionScalar::F32(2.0),
)?;
assert_eq!(accum.alpha, ContractionScalar::F32(0.5));

Trait Implementations

impl Clone for DotGeneralAccumulation

fn clone(&self) -> DotGeneralAccumulation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DotGeneralAccumulation

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

Formats the value using the given formatter.

impl PartialEq for DotGeneralAccumulation

fn eq(&self, other: &DotGeneralAccumulation) -> 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 Copy for DotGeneralAccumulation

impl StructuralPartialEq for DotGeneralAccumulation