Struct Mat 

pub struct Mat<S: TropicalSemiring> { /* private fields */ }

Owned matrix storing semiring values.

The matrix stores values in column-major order (Fortran/BLAS convention). Use factory methods to create matrices:

use tropical_gemm::{Mat, MaxPlus, TropicalSemiring};

let zeros = Mat::<MaxPlus<f32>>::zeros(3, 4);
let identity = Mat::<MaxPlus<f32>>::identity(3);
let custom = Mat::<MaxPlus<f32>>::from_fn(2, 2, |i, j| {
    MaxPlus::<f32>::from_scalar((i + j) as f32)
});

Implementations

impl<S: TropicalSemiring> Mat<S>

pub fn zeros(nrows: usize, ncols: usize) -> Self

Create a matrix filled with tropical zeros.

For MaxPlus, this fills with -∞. For MinPlus, this fills with +∞.

pub fn identity(n: usize) -> Self

Create a tropical identity matrix.

Diagonal elements are tropical one (0 for MaxPlus/MinPlus). Off-diagonal elements are tropical zero (-∞ for MaxPlus, +∞ for MinPlus).

pub fn from_fn<F>(nrows: usize, ncols: usize, f: F) -> Self

where F: FnMut(usize, usize) -> S,

Create a matrix from a function.

The function is called with (row, col) indices. Data is stored in column-major order internally.

pub fn from_col_major(data: &[S::Scalar], nrows: usize, ncols: usize) -> Self

where S::Scalar: Copy,

Create a matrix from column-major scalar data.

Each scalar is wrapped in the semiring type. Data should be in column-major order: first column, then second column, etc.

pub fn from_row_major(data: &[S::Scalar], nrows: usize, ncols: usize) -> Self

where S::Scalar: Copy,

👎Deprecated since 0.4.0: use from_col_major instead for direct column-major input; this method has O(m×n) transpose overhead

Create a matrix from row-major scalar data.

This is a convenience method that converts row-major input to column-major storage.

Performance Warning

This method performs an O(m×n) transpose operation. For performance-critical code, provide data in column-major order and use [from_col_major] instead.

pub fn from_vec(data: Vec<S>, nrows: usize, ncols: usize) -> Self

Create a matrix from a vector of semiring values.

pub fn nrows(&self) -> usize

Number of rows.

pub fn ncols(&self) -> usize

Number of columns.

pub fn as_slice(&self) -> &[S]

Get the underlying data as a slice.

pub fn as_mut_slice(&mut self) -> &mut [S]

Get the underlying data as a mutable slice.

pub fn get_value(&self, i: usize, j: usize) -> S::Scalar

Get the scalar value at position (i, j).

This is a convenience method that extracts the underlying scalar without requiring a trait import.

Example

use tropical_gemm::{Mat, MaxPlus};

let m = Mat::<MaxPlus<f64>>::from_row_major(&[1.0, 2.0, 3.0, 4.0], 2, 2);
assert_eq!(m.get_value(0, 0), 1.0);
assert_eq!(m.get_value(1, 1), 4.0);

pub fn as_ref(&self) -> MatRef<'_, S>

where S::Scalar: Copy,

Convert to an immutable matrix reference.

The returned reference views the scalar values.

pub fn as_mut_ptr(&mut self) -> *mut S

Get a mutable pointer to the data.

impl<S> Mat<S>

where S: TropicalSemiring + KernelDispatch, S::Scalar: Copy,

pub fn matmul(&self, b: &Mat<S>) -> Mat<S>

Perform tropical matrix multiplication: C = A ⊗ B.

Computes C[i,j] = ⊕_k (A[i,k] ⊗ B[k,j])

Panics

Panics if dimensions don’t match (self.ncols != b.nrows).

Example

use tropical_gemm::{Mat, MaxPlus, TropicalSemiring};

let a = Mat::<MaxPlus<f64>>::from_row_major(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0], 2, 3);
let b = Mat::<MaxPlus<f64>>::from_row_major(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0], 3, 2);

let c = a.matmul(&b);

// C[0,0] = max(1+1, 2+3, 3+5) = 8
assert_eq!(c[(0, 0)].value(), 8.0);

pub fn matmul_ref(&self, b: &MatRef<'_, S>) -> Mat<S>

Perform tropical matrix multiplication with a MatRef.

This allows mixing owned and reference matrices.

impl<S> Mat<S>

where S: TropicalWithArgmax<Index = u32> + KernelDispatch, S::Scalar: Copy,

pub fn matmul_argmax(&self, b: &Mat<S>) -> MatWithArgmax<S>

Perform tropical matrix multiplication with argmax tracking.

Returns both the result matrix and the argmax indices indicating which k-index produced each optimal value.

Example

use tropical_gemm::{Mat, MaxPlus, TropicalSemiring};

let a = Mat::<MaxPlus<f64>>::from_row_major(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0], 2, 3);
let b = Mat::<MaxPlus<f64>>::from_row_major(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0], 3, 2);

let result = a.matmul_argmax(&b);

assert_eq!(result.get(0, 0).value(), 8.0);
assert_eq!(result.get_argmax(0, 0), 2); // k=2 gave max

pub fn matmul_batched_with_argmax( a_batch: &[Mat<S>], b_batch: &[Mat<S>], ) -> Vec<MatWithArgmax<S>>

Batched tropical matrix multiplication with argmax tracking.

Computes C[i] = A[i] ⊗ B[i] for each pair of matrices in the batch, tracking which k-index produced each optimal value.

All matrices in a_batch must have the same dimensions, and all matrices in b_batch must have the same dimensions.

Panics

Panics if:

• a_batch and b_batch have different lengths
• Matrices in a_batch have different dimensions
• Matrices in b_batch have different dimensions
• Inner dimensions don’t match (A.ncols != B.nrows)

Example

use tropical_gemm::{Mat, MaxPlus};

let a1 = Mat::<MaxPlus<f32>>::from_row_major(&[1.0, 2.0, 3.0, 4.0], 2, 2);
let a2 = Mat::<MaxPlus<f32>>::from_row_major(&[5.0, 6.0, 7.0, 8.0], 2, 2);
let b1 = Mat::<MaxPlus<f32>>::from_row_major(&[1.0, 0.0, 0.0, 1.0], 2, 2);
let b2 = Mat::<MaxPlus<f32>>::from_row_major(&[1.0, 2.0, 3.0, 4.0], 2, 2);

let results = Mat::matmul_batched_with_argmax(&[a1, a2], &[b1, b2]);
assert_eq!(results.len(), 2);

impl<S> Mat<S>

where S: TropicalSemiring + KernelDispatch, S::Scalar: Copy,

pub fn matmul_batched(a_batch: &[Mat<S>], b_batch: &[Mat<S>]) -> Vec<Mat<S>>

Batched tropical matrix multiplication.

Computes C[i] = A[i] ⊗ B[i] for each pair of matrices in the batch. All matrices in a_batch must have the same dimensions, and all matrices in b_batch must have the same dimensions.

Panics

Panics if:

• a_batch and b_batch have different lengths
• Matrices in a_batch have different dimensions
• Matrices in b_batch have different dimensions
• Inner dimensions don’t match (A.ncols != B.nrows)

Example

use tropical_gemm::{Mat, MaxPlus};

let a1 = Mat::<MaxPlus<f32>>::from_row_major(&[1.0, 2.0, 3.0, 4.0], 2, 2);
let a2 = Mat::<MaxPlus<f32>>::from_row_major(&[5.0, 6.0, 7.0, 8.0], 2, 2);
let b1 = Mat::<MaxPlus<f32>>::from_row_major(&[1.0, 0.0, 0.0, 1.0], 2, 2);
let b2 = Mat::<MaxPlus<f32>>::from_row_major(&[1.0, 2.0, 3.0, 4.0], 2, 2);

let results = Mat::matmul_batched(&[a1, a2], &[b1, b2]);
assert_eq!(results.len(), 2);

Trait Implementations

impl<S: Clone + TropicalSemiring> Clone for Mat<S>

fn clone(&self) -> Mat<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug + TropicalSemiring> Debug for Mat<S>

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

Formats the value using the given formatter.

impl<S: TropicalSemiring> Index<(usize, usize)> for Mat<S>

type Output = S

The returned type after indexing.

fn index(&self, (i, j): (usize, usize)) -> &S

Performs the indexing (container[index]) operation.

impl<S: TropicalSemiring> IndexMut<(usize, usize)> for Mat<S>

fn index_mut(&mut self, (i, j): (usize, usize)) -> &mut S

Performs the mutable indexing (container[index]) operation.

impl<S> Mul<&Mat<S>> for &Mat<S>

where S: TropicalSemiring + KernelDispatch, S::Scalar: Copy,

type Output = Mat<S>

The resulting type after applying the * operator.

fn mul(self, rhs: &Mat<S>) -> Mat<S>

Performs the * operation.

impl<'a, S> Mul<&'a MatRef<'a, S>> for &Mat<S>

where S: TropicalSemiring + KernelDispatch, S::Scalar: Copy,

type Output = Mat<S>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a MatRef<'a, S>) -> Mat<S>

Performs the * operation.

impl<S> Mul for Mat<S>

where S: TropicalSemiring + KernelDispatch, S::Scalar: Copy,

type Output = Mat<S>

The resulting type after applying the * operator.

fn mul(self, rhs: Mat<S>) -> Mat<S>

Performs the * operation.