Enum DimExpr 

pub enum DimExpr {
    Const(usize),
    InputDim {
        input_idx: usize,
        axis: usize,
    },
    Add(Box<DimExpr>, Box<DimExpr>),
    Sub(Box<DimExpr>, Box<DimExpr>),
    Mul(Box<DimExpr>, Box<DimExpr>),
    FloorDiv(Box<DimExpr>, Box<DimExpr>),
    Min(Box<DimExpr>, Box<DimExpr>),
    Max(Box<DimExpr>, Box<DimExpr>),
}

Arithmetic expression over tensor dimension sizes.

Evaluated at execution time from actual input tensor shapes. InputDim { input_idx, axis } references the axis size of the op’s input_idx-th input tensor.

Examples

use tenferro_ops::dim_expr::DimExpr;

let expr = DimExpr::mul(
    DimExpr::InputDim {
        input_idx: 0,
        axis: 0,
    },
    DimExpr::InputDim {
        input_idx: 0,
        axis: 1,
    },
);
assert_eq!(expr.eval(&[&[3, 4]]), 12);

Variants

Const(usize)

A concrete dimension size.

InputDim

Axis size of the op’s input_idx-th input tensor.

Fields

input_idx: usize

axis: usize

Add(Box<DimExpr>, Box<DimExpr>)

Sum of two dimension expressions.

Sub(Box<DimExpr>, Box<DimExpr>)

Difference of two dimension expressions.

Mul(Box<DimExpr>, Box<DimExpr>)

Product of two dimension expressions.

FloorDiv(Box<DimExpr>, Box<DimExpr>)

Floor division of two dimension expressions.

Min(Box<DimExpr>, Box<DimExpr>)

Minimum of two dimension expressions.

Max(Box<DimExpr>, Box<DimExpr>)

Maximum of two dimension expressions.

Implementations

impl DimExpr

pub fn eval(&self, input_shapes: &[&[usize]]) -> usize

Evaluate the expression using actual input tensor shapes.

Panics

Panics if an InputDim node references an input_idx that is out of bounds for input_shapes, or an axis that is out of bounds for the corresponding shape slice.

Examples

use tenferro_ops::dim_expr::DimExpr;

let expr = DimExpr::add(
    DimExpr::InputDim {
        input_idx: 0,
        axis: 0,
    },
    DimExpr::Const(2),
);
assert_eq!(expr.eval(&[&[5, 7]]), 7);

pub fn max_input_idx(&self) -> Option<usize>

Return the maximum referenced input_idx, or None if the expression contains only constants.

Examples

use tenferro_ops::dim_expr::DimExpr;

let expr = DimExpr::add(
    DimExpr::InputDim {
        input_idx: 0,
        axis: 0,
    },
    DimExpr::InputDim {
        input_idx: 2,
        axis: 1,
    },
);
assert_eq!(expr.max_input_idx(), Some(2));

pub fn remap(&self, from: usize, to: usize) -> Self

Remap InputDim { input_idx: from, .. } to InputDim { input_idx: to, .. }.

Examples

use tenferro_ops::dim_expr::DimExpr;

let expr = DimExpr::InputDim {
    input_idx: 0,
    axis: 1,
};
assert_eq!(expr.remap(0, 2), DimExpr::InputDim { input_idx: 2, axis: 1 });

pub fn constant(v: usize) -> Self

Construct a constant dimension expression.

Examples

use tenferro_ops::dim_expr::DimExpr;

assert_eq!(DimExpr::constant(4), DimExpr::Const(4));

pub fn add(a: Self, b: Self) -> Self

Construct an addition node.

Examples

use tenferro_ops::dim_expr::DimExpr;

let expr = DimExpr::add(DimExpr::Const(2), DimExpr::Const(3));
assert_eq!(expr.eval(&[]), 5);

pub fn sub(a: Self, b: Self) -> Self

Construct a subtraction node.

Examples

use tenferro_ops::dim_expr::DimExpr;

let expr = DimExpr::sub(DimExpr::Const(7), DimExpr::Const(2));
assert_eq!(expr.eval(&[]), 5);

pub fn mul(a: Self, b: Self) -> Self

Construct a multiplication node.

Examples

use tenferro_ops::dim_expr::DimExpr;

let expr = DimExpr::mul(DimExpr::Const(3), DimExpr::Const(4));
assert_eq!(expr.eval(&[]), 12);

pub fn floor_div(a: Self, b: Self) -> Self

Construct a floor-division node.

Examples

use tenferro_ops::dim_expr::DimExpr;

let expr = DimExpr::floor_div(DimExpr::Const(9), DimExpr::Const(2));
assert_eq!(expr.eval(&[]), 4);

pub fn min(a: Self, b: Self) -> Self

Construct a minimum node.

Examples

use tenferro_ops::dim_expr::DimExpr;

let expr = DimExpr::min(DimExpr::Const(3), DimExpr::Const(5));
assert_eq!(expr.eval(&[]), 3);

pub fn max(a: Self, b: Self) -> Self

Construct a maximum node.

Examples

use tenferro_ops::dim_expr::DimExpr;

let expr = DimExpr::max(DimExpr::Const(3), DimExpr::Const(5));
assert_eq!(expr.eval(&[]), 5);

pub fn is_const(&self) -> bool

Return true when this expression is a constant.

Examples

use tenferro_ops::dim_expr::DimExpr;

assert!(DimExpr::Const(3).is_const());

pub fn from_concrete(shape: &[usize]) -> Vec<Self>

Convert a concrete shape to constant expressions.

Examples

use tenferro_ops::dim_expr::DimExpr;

assert_eq!(DimExpr::from_concrete(&[2, 3]), vec![DimExpr::Const(2), DimExpr::Const(3)]);

pub fn input_shape(input_idx: usize, rank: usize) -> Vec<Self>

Build [InputDim(input_idx, 0), ..., InputDim(input_idx, rank - 1)].

Examples

use tenferro_ops::dim_expr::DimExpr;

let shape = DimExpr::input_shape(1, 2);
assert_eq!(
    shape,
    vec![
        DimExpr::InputDim { input_idx: 1, axis: 0 },
        DimExpr::InputDim { input_idx: 1, axis: 1 },
    ]
);

pub fn eval_all(exprs: &[Self], input_shapes: &[&[usize]]) -> Vec<usize>

Evaluate a slice of expressions against actual input shapes.

Examples

use tenferro_ops::dim_expr::DimExpr;

let exprs = vec![
    DimExpr::InputDim { input_idx: 0, axis: 0 },
    DimExpr::Const(4),
];
assert_eq!(DimExpr::eval_all(&exprs, &[&[3, 5]]), vec![3, 4]);

pub fn remap_all(exprs: &[Self], from: usize, to: usize) -> Vec<Self>

Remap all InputDim references in a slice of expressions.

Examples

use tenferro_ops::dim_expr::DimExpr;

let exprs = vec![DimExpr::InputDim { input_idx: 0, axis: 0 }];
assert_eq!(
    DimExpr::remap_all(&exprs, 0, 1),
    vec![DimExpr::InputDim { input_idx: 1, axis: 0 }]
);

pub fn max_input_idx_all(exprs: &[Self]) -> Option<usize>

Compute the maximum referenced input_idx across a slice.

Examples

use tenferro_ops::dim_expr::DimExpr;

let exprs = vec![
    DimExpr::InputDim { input_idx: 0, axis: 0 },
    DimExpr::InputDim { input_idx: 2, axis: 1 },
];
assert_eq!(DimExpr::max_input_idx_all(&exprs), Some(2));

Trait Implementations

impl Clone for DimExpr

fn clone(&self) -> DimExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DimExpr

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

Formats the value using the given formatter.

impl From<&DimExpr> for DimExpr

fn from(value: &DimExpr) -> Self

Converts to this type from the input type.

impl From<usize> for DimExpr

fn from(v: usize) -> Self

Converts to this type from the input type.

impl Hash for DimExpr

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for DimExpr

fn eq(&self, other: &DimExpr) -> 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 Eq for DimExpr

impl StructuralPartialEq for DimExpr