Struct TropicalMaxMul 

#[repr(transparent)]
pub struct TropicalMaxMul<T: TropicalScalar>(pub T);

TropicalMaxMul semiring: (ℝ⁺, max, ×)

• Addition (⊕) = max
• Multiplication (⊗) = ×
• Zero = 0
• One = 1

This is used for:

• Probability computations (non-log space)
• Fuzzy logic with product t-norm

Tuple Fields

0: T

Implementations

impl<T: TropicalScalar> TropicalMaxMul<T>

pub fn new(value: T) -> Self

Create a new TropicalMaxMul value.

Trait Implementations

impl<T: TropicalScalar> Add for TropicalMaxMul<T>

type Output = TropicalMaxMul<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Clone + TropicalScalar> Clone for TropicalMaxMul<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Copy + TropicalScalar> Copy for TropicalMaxMul<T>

impl<T: TropicalScalar> Debug for TropicalMaxMul<T>

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

Formats the value using the given formatter.

impl<T: TropicalScalar> Default for TropicalMaxMul<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: TropicalScalar> Display for TropicalMaxMul<T>

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

Formats the value using the given formatter.

impl<T: TropicalScalar> From<T> for TropicalMaxMul<T>

fn from(value: T) -> Self

Converts to this type from the input type.

impl KernelDispatch for TropicalMaxMul<f32>

unsafe fn dispatch_gemm_with_argmax( m: usize, n: usize, k: usize, a: *const f32, lda: usize, trans_a: Transpose, b: *const f32, ldb: usize, trans_b: Transpose, result: &mut GemmWithArgmax<Self>, )

Dispatch argmax, defaulting to the portable kernel for custom types.

unsafe fn dispatch_gemm_with_argmax_with_workspace( m: usize, n: usize, k: usize, a: *const f32, lda: usize, trans_a: Transpose, b: *const f32, ldb: usize, trans_b: Transpose, result: &mut GemmWithArgmax<Self>, workspace: &mut GemmWorkspace<Self::Scalar>, )

Dispatch argmax using reusable packing storage.

unsafe fn dispatch_gemm( m: usize, n: usize, k: usize, a: *const Self::Scalar, lda: usize, trans_a: Transpose, b: *const Self::Scalar, ldb: usize, trans_b: Transpose, c: *mut Self, ldc: usize, )

Dispatch to the appropriate kernel based on CPU features.

unsafe fn dispatch_gemm_with_workspace( m: usize, n: usize, k: usize, a: *const f32, lda: usize, trans_a: Transpose, b: *const f32, ldb: usize, trans_b: Transpose, c: *mut Self, ldc: usize, workspace: &mut GemmWorkspace<Self::Scalar>, )

Dispatch using reusable packing storage. Custom implementations retain their existing dispatch unless they override this method to use workspace.

impl KernelDispatch for TropicalMaxMul<f64>

unsafe fn dispatch_gemm_with_argmax( m: usize, n: usize, k: usize, a: *const f64, lda: usize, trans_a: Transpose, b: *const f64, ldb: usize, trans_b: Transpose, result: &mut GemmWithArgmax<Self>, )

Dispatch argmax, defaulting to the portable kernel for custom types.

unsafe fn dispatch_gemm_with_argmax_with_workspace( m: usize, n: usize, k: usize, a: *const f64, lda: usize, trans_a: Transpose, b: *const f64, ldb: usize, trans_b: Transpose, result: &mut GemmWithArgmax<Self>, workspace: &mut GemmWorkspace<Self::Scalar>, )

Dispatch argmax using reusable packing storage.

unsafe fn dispatch_gemm( m: usize, n: usize, k: usize, a: *const Self::Scalar, lda: usize, trans_a: Transpose, b: *const Self::Scalar, ldb: usize, trans_b: Transpose, c: *mut Self, ldc: usize, )

Dispatch to the appropriate kernel based on CPU features.

unsafe fn dispatch_gemm_with_workspace( m: usize, n: usize, k: usize, a: *const f64, lda: usize, trans_a: Transpose, b: *const f64, ldb: usize, trans_b: Transpose, c: *mut Self, ldc: usize, workspace: &mut GemmWorkspace<Self::Scalar>, )

Dispatch using reusable packing storage. Custom implementations retain their existing dispatch unless they override this method to use workspace.

impl KernelDispatch for TropicalMaxMul<i32>

unsafe fn dispatch_gemm( m: usize, n: usize, k: usize, a: *const Self::Scalar, lda: usize, trans_a: Transpose, b: *const Self::Scalar, ldb: usize, trans_b: Transpose, c: *mut Self, ldc: usize, )

Dispatch to the appropriate kernel based on CPU features.

unsafe fn dispatch_gemm_with_workspace( m: usize, n: usize, k: usize, a: *const Self::Scalar, lda: usize, trans_a: Transpose, b: *const Self::Scalar, ldb: usize, trans_b: Transpose, c: *mut Self, ldc: usize, workspace: &mut GemmWorkspace<Self::Scalar>, )

Dispatch using reusable packing storage. Custom implementations retain their existing dispatch unless they override this method to use workspace.

unsafe fn dispatch_gemm_with_argmax( m: usize, n: usize, k: usize, a: *const Self::Scalar, lda: usize, trans_a: Transpose, b: *const Self::Scalar, ldb: usize, trans_b: Transpose, result: &mut GemmWithArgmax<Self>, )

where Self: TropicalWithArgmax<Index = u32>,

Dispatch argmax, defaulting to the portable kernel for custom types.

unsafe fn dispatch_gemm_with_argmax_with_workspace( m: usize, n: usize, k: usize, a: *const Self::Scalar, lda: usize, trans_a: Transpose, b: *const Self::Scalar, ldb: usize, trans_b: Transpose, result: &mut GemmWithArgmax<Self>, workspace: &mut GemmWorkspace<Self::Scalar>, )

where Self: TropicalWithArgmax<Index = u32>,

Dispatch argmax using reusable packing storage.

impl KernelDispatch for TropicalMaxMul<i64>

unsafe fn dispatch_gemm( m: usize, n: usize, k: usize, a: *const Self::Scalar, lda: usize, trans_a: Transpose, b: *const Self::Scalar, ldb: usize, trans_b: Transpose, c: *mut Self, ldc: usize, )

Dispatch to the appropriate kernel based on CPU features.

unsafe fn dispatch_gemm_with_workspace( m: usize, n: usize, k: usize, a: *const Self::Scalar, lda: usize, trans_a: Transpose, b: *const Self::Scalar, ldb: usize, trans_b: Transpose, c: *mut Self, ldc: usize, workspace: &mut GemmWorkspace<Self::Scalar>, )

Dispatch using reusable packing storage. Custom implementations retain their existing dispatch unless they override this method to use workspace.

unsafe fn dispatch_gemm_with_argmax( m: usize, n: usize, k: usize, a: *const Self::Scalar, lda: usize, trans_a: Transpose, b: *const Self::Scalar, ldb: usize, trans_b: Transpose, result: &mut GemmWithArgmax<Self>, )

where Self: TropicalWithArgmax<Index = u32>,

Dispatch argmax, defaulting to the portable kernel for custom types.

unsafe fn dispatch_gemm_with_argmax_with_workspace( m: usize, n: usize, k: usize, a: *const Self::Scalar, lda: usize, trans_a: Transpose, b: *const Self::Scalar, ldb: usize, trans_b: Transpose, result: &mut GemmWithArgmax<Self>, workspace: &mut GemmWorkspace<Self::Scalar>, )

where Self: TropicalWithArgmax<Index = u32>,

Dispatch argmax using reusable packing storage.

impl Microkernel<TropicalMaxMul<f32>> for Avx2MaxMulF32Kernel

const MR: usize = 8

Rows of the microkernel (typically 4-8 for f32).

const NR: usize = 8

Columns of the microkernel (typically 4-8 for f32).

unsafe fn execute( &self, mr: usize, nr: usize, k: usize, a: *const f32, b: *const f32, c: *mut TropicalMaxMul<f32>, ldc: usize, )

Execute the microkernel.

impl<T: TropicalScalar> Mul for TropicalMaxMul<T>

type Output = TropicalMaxMul<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: PartialEq + TropicalScalar> PartialEq for TropicalMaxMul<T>

fn eq(&self, other: &TropicalMaxMul<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: TropicalScalar> SimdTropical for TropicalMaxMul<T>

const SIMD_AVAILABLE: bool = true

Whether SIMD operations are available for this type.

const SIMD_WIDTH: usize = 8

The SIMD width in elements.

impl<T: PartialEq + TropicalScalar> StructuralPartialEq for TropicalMaxMul<T>

impl<T: TropicalScalar> TropicalSemiring for TropicalMaxMul<T>

type Scalar = T

The underlying scalar type.

fn scalar_slice(values: &[Self]) -> Option<&[Self::Scalar]>

Borrow scalar storage when the representation permits it. The default uses a cached value projection in owned matrix views.

fn tropical_zero() -> Self

Returns the additive identity (zero element for ⊕).

fn tropical_one() -> Self

Returns the multiplicative identity (one element for ⊗).

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

Tropical addition (⊕).

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

Tropical multiplication (⊗).

fn value(&self) -> T

Get the underlying scalar value.

fn from_scalar(s: T) -> Self

Create from a scalar value.

impl<T: TropicalScalar> TropicalWithArgmax for TropicalMaxMul<T>

type Index = u32

The index type used for argmax tracking.

fn tropical_add_argmax( self, self_idx: u32, rhs: Self, rhs_idx: u32, ) -> (Self, u32)

Tropical addition with argmax tracking.

fn is_no_contribution(&self) -> bool

Whether this (output) value is a tropical-zero “no contribution” cell whose argmax index should be canonicalized at GEMM write-back.