Struct Standard 

#[repr(transparent)]
pub struct Standard<T: Scalar>(pub T);

Standard arithmetic semiring with addition and multiplication.

This represents the usual (+, ×) operations used in linear algebra.

Example

use omeinsum::algebra::{Standard, Semiring};

let a = Standard(2.0f32);
let b = Standard(3.0f32);

assert_eq!(a.add(b).to_scalar(), 5.0);  // 2 + 3 = 5
assert_eq!(a.mul(b).to_scalar(), 6.0);  // 2 × 3 = 6

Tuple Fields

0: T

Trait Implementations

impl<T: Scalar + Zero + One + PartialEq + Add<Output = T> + Mul<Output = T>> Algebra for Standard<T>

type Index = u32

Index type for argmax tracking

fn add_with_argmax( self, _self_idx: Self::Index, rhs: Self, _rhs_idx: Self::Index, ) -> (Self, Self::Index)

Addition with argmax tracking.

fn add_backward( self, _rhs: Self, grad_out: Self::Scalar, _winner_idx: Option<Self::Index>, ) -> (Self::Scalar, Self::Scalar)

Backward pass for addition.

fn mul_backward( self, rhs: Self, grad_out: Self::Scalar, ) -> (Self::Scalar, Self::Scalar)

Backward pass for multiplication.

fn needs_argmax() -> bool

Whether this algebra requires argmax tracking for backprop.

fn is_better(&self, _other: &Self) -> bool

Check if self is “better” than other for tropical selection.

impl<T: Clone + Scalar> Clone for Standard<T>

fn clone(&self) -> Standard<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Scalar> Debug for Standard<T>

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

Formats the value using the given formatter.

impl<T: PartialEq + Scalar> PartialEq for Standard<T>

fn eq(&self, other: &Standard<T>) -> 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<T: Scalar + Zero + One + PartialEq + Add<Output = T> + Mul<Output = T>> Semiring for Standard<T>

type Scalar = T

The underlying scalar type

fn zero() -> Self

Additive identity (zero element for ⊕)

fn one() -> Self

Multiplicative identity (one element for ⊗)

fn add(self, rhs: Self) -> Self

Addition operation (⊕)

fn mul(self, rhs: Self) -> Self

Multiplication operation (⊗)

fn from_scalar(s: T) -> Self

Create from scalar value

fn to_scalar(self) -> T

Extract scalar value

fn is_zero(&self) -> bool

Check if this is the zero element

impl<T: Copy + Scalar> Copy for Standard<T>

impl<T: Scalar> StructuralPartialEq for Standard<T>