Struct ConcreteEinsumPlan 

pub struct ConcreteEinsumPlan { /* private fields */ }

Prepared concrete einsum plan for repeated executions with fixed input dtype and shape metadata.

Preparing a plan parses and optimizes the contraction tree once. Execution validates the later inputs against the prepared dtype and shape contract, then runs the stored tree without re-planning.

Examples

use tenferro_cpu::CpuBackend;
use tenferro_einsum::ConcreteEinsumPlan;
use tenferro_tensor::Tensor;

let lhs = Tensor::from_vec_col_major(vec![2, 3], vec![1.0_f64; 6]).unwrap();
let rhs = Tensor::from_vec_col_major(vec![3, 4], vec![1.0_f64; 12]).unwrap();
let plan = ConcreteEinsumPlan::prepare([&lhs, &rhs], "ij,jk->ik")?;

let mut backend = CpuBackend::new();
let out = plan.execute([&lhs, &rhs], &mut backend)?;
assert_eq!(out.shape(), &[2, 4]);

Implementations

impl ConcreteEinsumPlan

pub fn prepare<'a, I>(inputs: I, subscripts: &str) -> Result<Self>

where I: AsRef<[&'a Tensor]>,

Prepare a plan from dtype-erased concrete tensor inputs and string notation.

pub fn prepare_subscripts<'a, I>( inputs: I, subscripts: &EinsumSubscripts, ) -> Result<Self>

where I: AsRef<[&'a Tensor]>,

Prepare a plan from dtype-erased concrete tensor inputs and parsed integer-label subscripts.

pub fn prepare_typed<'a, T, I>(inputs: I, subscripts: &str) -> Result<Self>

where T: TensorScalar, I: AsRef<[&'a TypedTensor<T>]>,

Prepare a plan from typed concrete tensor inputs and string notation.

pub fn prepare_typed_subscripts<'a, T, I>( inputs: I, subscripts: &EinsumSubscripts, ) -> Result<Self>

where T: TensorScalar, I: AsRef<[&'a TypedTensor<T>]>,

Prepare a plan from typed concrete tensor inputs and parsed integer-label subscripts.

pub fn prepare_read<'a, I>(inputs: I, subscripts: &str) -> Result<Self>

where I: AsRef<[TensorRead<'a>]>,

Prepare a plan from read-only tensor inputs and string notation.

pub fn prepare_read_subscripts<'a, I>( inputs: I, subscripts: &EinsumSubscripts, ) -> Result<Self>

where I: AsRef<[TensorRead<'a>]>,

Prepare a plan from read-only tensor inputs and parsed integer-label subscripts.

pub fn execute<'a, I, B>(&self, inputs: I, backend: &mut B) -> Result<Tensor>

where I: AsRef<[&'a Tensor]>, B: TensorBackend,

Execute this plan on dtype-erased concrete tensor inputs.

pub fn execute_typed<'a, T, I, B>( &self, inputs: I, backend: &mut B, ) -> Result<TypedTensor<T>>

where T: TensorScalar, I: AsRef<[&'a TypedTensor<T>]>, B: TensorBackend,

Execute this plan on typed concrete tensor inputs.

pub fn execute_read<'a, I, B>( &self, inputs: I, backend: &mut B, ) -> Result<Tensor>

where I: AsRef<[TensorRead<'a>]>, B: TensorBackend,

Execute this plan on read-only tensor inputs.

pub fn execute_into<'a, I, B>( &self, inputs: I, backend: &mut B, out: TensorWrite<'_>, ) -> Result<()>

where I: AsRef<[&'a Tensor]>, B: TensorBackend,

Execute this plan on dtype-erased concrete tensor inputs into caller-provided output.

pub fn execute_typed_into<'a, T, I, B>( &self, inputs: I, backend: &mut B, out: &mut TypedTensor<T>, ) -> Result<()>

where T: TensorScalar, I: AsRef<[&'a TypedTensor<T>]>, B: TensorBackend,

Execute this plan on typed concrete tensor inputs into caller-provided output.

pub fn execute_read_into<'a, I, B>( &self, inputs: I, backend: &mut B, out: TensorWrite<'_>, ) -> Result<()>

where I: AsRef<[TensorRead<'a>]>, B: TensorBackend,

Execute this plan on read-only tensor inputs into caller-provided output.

pub fn execute_read_into_accum<'a, I, B>( &self, inputs: I, backend: &mut B, accumulation: DotGeneralAccumulation, out: TensorWrite<'_>, ) -> Result<()>

where I: AsRef<[TensorRead<'a>]>, B: TensorBackend,

Execute this plan on read-only inputs with scaled output accumulation.

accumulation follows the dot-general contract: out = alpha * einsum(inputs) + beta * out.

Examples

use tenferro_cpu::CpuBackend;
use tenferro_einsum::ConcreteEinsumPlan;
use tenferro_tensor::{
    DotGeneralAccumulation, DType, Tensor, TensorRead, TensorWrite,
};

let lhs = Tensor::from_vec_col_major(vec![1], vec![2.0_f64])?;
let rhs = Tensor::from_vec_col_major(vec![1], vec![3.0_f64])?;
let mut out = Tensor::from_vec_col_major(vec![], vec![1.0_f64])?;
let plan = ConcreteEinsumPlan::prepare([&lhs, &rhs], "i,i->")?;
let mut backend = CpuBackend::new();
plan.execute_read_into_accum(
    [TensorRead::from_tensor(&lhs), TensorRead::from_tensor(&rhs)],
    &mut backend,
    DotGeneralAccumulation::add_to(DType::F64)?,
    TensorWrite::from_tensor(&mut out),
)?;
assert_eq!(out.as_slice::<f64>()?, &[7.0]);

Trait Implementations

impl Debug for ConcreteEinsumPlan

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

Formats the value using the given formatter.