Struct GemmPlan 

pub struct GemmPlan<'a> { /* private fields */ }

Read-only GEMM decomposition plan for a pairwise contraction step.

Examples

use tenferro_einsum::{ContractionTree, Subscripts};

let subs = Subscripts::new(&[&[0, 1], &[1, 2]], &[0, 2]);
let tree = ContractionTree::from_pairs(&subs, &[&[2, 3], &[3, 4]], &[(0, 1)]).unwrap();
let gemm = tree.step_plan(0).unwrap().gemm();

assert_eq!(gemm.lhs_gemm_shape(), &[2, 3]);

Implementations

impl<'a> GemmPlan<'a>

pub fn left_only_modes(&self) -> &'a [u32]

Return modes present only on the left operand and output.

Examples

use tenferro_einsum::{ContractionTree, Subscripts};

let subs = Subscripts::new(&[&[0, 1], &[1, 2]], &[0, 2]);
let tree = ContractionTree::from_pairs(&subs, &[&[2, 3], &[3, 4]], &[(0, 1)]).unwrap();
let gemm = tree.step_plan(0).unwrap().gemm();

assert_eq!(gemm.left_only_modes(), &[0]);

pub fn left_only_shape(&self) -> &'a [usize]

Return dimension sizes for Self::left_only_modes.

Examples

use tenferro_einsum::{ContractionTree, Subscripts};

let subs = Subscripts::new(&[&[0, 1], &[1, 2]], &[0, 2]);
let tree = ContractionTree::from_pairs(&subs, &[&[2, 3], &[3, 4]], &[(0, 1)]).unwrap();
let gemm = tree.step_plan(0).unwrap().gemm();

assert_eq!(gemm.left_only_shape(), &[2]);

pub fn right_only_modes(&self) -> &'a [u32]

Return modes present only on the right operand and output.

Examples

use tenferro_einsum::{ContractionTree, Subscripts};

let subs = Subscripts::new(&[&[0, 1], &[1, 2]], &[0, 2]);
let tree = ContractionTree::from_pairs(&subs, &[&[2, 3], &[3, 4]], &[(0, 1)]).unwrap();
let gemm = tree.step_plan(0).unwrap().gemm();

assert_eq!(gemm.right_only_modes(), &[2]);

pub fn right_only_shape(&self) -> &'a [usize]

Return dimension sizes for Self::right_only_modes.

Examples

use tenferro_einsum::{ContractionTree, Subscripts};

let subs = Subscripts::new(&[&[0, 1], &[1, 2]], &[0, 2]);
let tree = ContractionTree::from_pairs(&subs, &[&[2, 3], &[3, 4]], &[(0, 1)]).unwrap();
let gemm = tree.step_plan(0).unwrap().gemm();

assert_eq!(gemm.right_only_shape(), &[4]);

pub fn contracted_modes(&self) -> &'a [u32]

Return modes contracted between the pairwise operands.

Examples

use tenferro_einsum::{ContractionTree, Subscripts};

let subs = Subscripts::new(&[&[0, 1], &[1, 2]], &[0, 2]);
let tree = ContractionTree::from_pairs(&subs, &[&[2, 3], &[3, 4]], &[(0, 1)]).unwrap();
let gemm = tree.step_plan(0).unwrap().gemm();

assert_eq!(gemm.contracted_modes(), &[1]);

pub fn contracted_shape(&self) -> &'a [usize]

Return dimension sizes for Self::contracted_modes.

Examples

use tenferro_einsum::{ContractionTree, Subscripts};

let subs = Subscripts::new(&[&[0, 1, 2], &[1, 2, 3]], &[0, 3]);
let tree = ContractionTree::from_pairs(
    &subs,
    &[&[2, 3, 4], &[3, 4, 5]],
    &[(0, 1)],
)
.unwrap();
let gemm = tree.step_plan(0).unwrap().gemm();

assert_eq!(gemm.contracted_shape(), &[3, 4]);

pub fn batch_modes(&self) -> &'a [u32]

Return modes shared by both operands and preserved in the output.

Examples

use tenferro_einsum::{ContractionTree, Subscripts};

let subs = Subscripts::new(&[&[3, 0, 1], &[1, 2, 3]], &[3, 0, 2]);
let tree = ContractionTree::from_pairs(&subs, &[&[5, 2, 3], &[3, 4, 5]], &[(0, 1)]).unwrap();
let gemm = tree.step_plan(0).unwrap().gemm();

assert_eq!(gemm.batch_modes(), &[3]);

pub fn batch_shape(&self) -> &'a [usize]

Return dimension sizes for Self::batch_modes.

Examples

use tenferro_einsum::{ContractionTree, Subscripts};

let subs = Subscripts::new(&[&[3, 0, 1], &[1, 2, 3]], &[3, 0, 2]);
let tree = ContractionTree::from_pairs(&subs, &[&[5, 2, 3], &[3, 4, 5]], &[(0, 1)]).unwrap();
let gemm = tree.step_plan(0).unwrap().gemm();

assert_eq!(gemm.batch_shape(), &[5]);

pub fn lhs_target_modes(&self) -> &'a [u32]

Return target mode order for preparing the left GEMM operand.

Examples

use tenferro_einsum::{ContractionTree, Subscripts};

let subs = Subscripts::new(&[&[0, 1], &[1, 2]], &[0, 2]);
let tree = ContractionTree::from_pairs(&subs, &[&[2, 3], &[3, 4]], &[(0, 1)]).unwrap();
let gemm = tree.step_plan(0).unwrap().gemm();

assert_eq!(gemm.lhs_target_modes(), &[0, 1]);

pub fn rhs_target_modes(&self) -> &'a [u32]

Return target mode order for preparing the right GEMM operand.

Examples

use tenferro_einsum::{ContractionTree, Subscripts};

let subs = Subscripts::new(&[&[0, 1], &[1, 2]], &[0, 2]);
let tree = ContractionTree::from_pairs(&subs, &[&[2, 3], &[3, 4]], &[(0, 1)]).unwrap();
let gemm = tree.step_plan(0).unwrap().gemm();

assert_eq!(gemm.rhs_target_modes(), &[1, 2]);

pub fn canonical_output_modes(&self) -> &'a [u32]

Return canonical output mode order before any final permutation.

Examples

use tenferro_einsum::{ContractionTree, Subscripts};

let subs = Subscripts::new(&[&[0, 1], &[1, 2]], &[2, 0]);
let tree = ContractionTree::from_pairs(&subs, &[&[2, 3], &[3, 4]], &[(0, 1)]).unwrap();
let gemm = tree.step_plan(0).unwrap().gemm();

assert_eq!(gemm.canonical_output_modes(), &[0, 2]);

pub fn m(&self) -> usize

Return fused left-only dimension size.

Examples

use tenferro_einsum::{ContractionTree, Subscripts};

let subs = Subscripts::new(&[&[0, 1], &[1, 2]], &[0, 2]);
let tree = ContractionTree::from_pairs(&subs, &[&[2, 3], &[3, 4]], &[(0, 1)]).unwrap();
let gemm = tree.step_plan(0).unwrap().gemm();

assert_eq!(gemm.m(), 2);

pub fn n(&self) -> usize

Return fused right-only dimension size.

Examples

use tenferro_einsum::{ContractionTree, Subscripts};

let subs = Subscripts::new(&[&[0, 1], &[1, 2]], &[0, 2]);
let tree = ContractionTree::from_pairs(&subs, &[&[2, 3], &[3, 4]], &[(0, 1)]).unwrap();
let gemm = tree.step_plan(0).unwrap().gemm();

assert_eq!(gemm.n(), 4);

pub fn k(&self) -> usize

Return fused contracted dimension size.

Examples

use tenferro_einsum::{ContractionTree, Subscripts};

let subs = Subscripts::new(&[&[0, 1], &[1, 2]], &[0, 2]);
let tree = ContractionTree::from_pairs(&subs, &[&[2, 3], &[3, 4]], &[(0, 1)]).unwrap();
let gemm = tree.step_plan(0).unwrap().gemm();

assert_eq!(gemm.k(), 3);

pub fn lhs_gemm_shape(&self) -> &'a [usize]

Return prepared left operand GEMM shape.

Examples

use tenferro_einsum::{ContractionTree, Subscripts};

let subs = Subscripts::new(&[&[0, 1], &[1, 2]], &[0, 2]);
let tree = ContractionTree::from_pairs(&subs, &[&[2, 3], &[3, 4]], &[(0, 1)]).unwrap();
let gemm = tree.step_plan(0).unwrap().gemm();

assert_eq!(gemm.lhs_gemm_shape(), &[2, 3]);

pub fn rhs_gemm_shape(&self) -> &'a [usize]

Return prepared right operand GEMM shape.

Examples

use tenferro_einsum::{ContractionTree, Subscripts};

let subs = Subscripts::new(&[&[0, 1], &[1, 2]], &[0, 2]);
let tree = ContractionTree::from_pairs(&subs, &[&[2, 3], &[3, 4]], &[(0, 1)]).unwrap();
let gemm = tree.step_plan(0).unwrap().gemm();

assert_eq!(gemm.rhs_gemm_shape(), &[3, 4]);

pub fn output_gemm_shape(&self) -> &'a [usize]

Return GEMM output shape before expanding fused dimensions.

Examples

use tenferro_einsum::{ContractionTree, Subscripts};

let subs = Subscripts::new(&[&[0, 1], &[1, 2]], &[0, 2]);
let tree = ContractionTree::from_pairs(&subs, &[&[2, 3], &[3, 4]], &[(0, 1)]).unwrap();
let gemm = tree.step_plan(0).unwrap().gemm();

assert_eq!(gemm.output_gemm_shape(), &[2, 4]);

pub fn expanded_output_shape(&self) -> &'a [usize]

Return expanded output shape in canonical output mode order.

Examples

use tenferro_einsum::{ContractionTree, Subscripts};

let subs = Subscripts::new(&[&[0, 1], &[1, 2]], &[0, 2]);
let tree = ContractionTree::from_pairs(&subs, &[&[2, 3], &[3, 4]], &[(0, 1)]).unwrap();
let gemm = tree.step_plan(0).unwrap().gemm();

assert_eq!(gemm.expanded_output_shape(), &[2, 4]);

pub fn needs_final_permute(&self) -> bool

Return whether canonical output requires a final permutation.

Examples

use tenferro_einsum::{ContractionTree, Subscripts};

let subs = Subscripts::new(&[&[0, 1], &[1, 2]], &[2, 0]);
let tree = ContractionTree::from_pairs(&subs, &[&[2, 3], &[3, 4]], &[(0, 1)]).unwrap();
let gemm = tree.step_plan(0).unwrap().gemm();

assert!(gemm.needs_final_permute());

Trait Implementations

impl<'a> Clone for GemmPlan<'a>

fn clone(&self) -> GemmPlan<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for GemmPlan<'a>

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

Formats the value using the given formatter.

impl<'a> Copy for GemmPlan<'a>