Struct tract_hir::infer::rules::Solver

pub struct Solver<'rules> {
    pub rules: Vec<Box<dyn Rule<'rules> + 'rules>>,
}

A declarative constraint solver for tensors.

Fields

rules: Vec<Box<dyn Rule<'rules> + 'rules>>

Implementations

impl<'rules> Solver<'rules>

pub fn take_rules(self) -> Vec<Box<dyn Rule<'rules> + 'rules>>

Consumes the solver and returns the rules that it uses.

pub fn infer_facts( self, facts: (TVec<&InferenceFact>, TVec<&InferenceFact>) ) -> TractResult<(TVec<InferenceFact>, TVec<InferenceFact>)>

Runs the solver on a set of InferenceFacts.

This method returns:

• Err(_) if a constraint couldn’t be satisfied.
• Ok(None) if no more information about tensors could be deduced.
• Ok(Some(facts)) otherwise, with facts the new InferenceFacts.

pub fn equals<T, A, B>(&mut self, left: A, right: B) -> InferenceResult

where T: Output + Factoid + 'static, A: IntoExp<T>, B: IntoExp<T>,

Ensures that two expressions are equal.

For instance, one could write:

solver.equals(outputs[0].rank, inputs[1].shape[0]);
solver.equals(outputs[1].rank, 3);

pub fn equals_all<T>(&mut self, items: Vec<Exp<T>>) -> InferenceResult

where T: Output + Factoid + 'static,

Ensures that several expressions are equal.

For instance, one could write:

solver.equals_all(vec![
    outputs[0].rank.into(),
    inputs[1].shape[0].into(),
    3.into(),
]);

pub fn equals_zero<F>(&mut self, items: Exp<F>) -> InferenceResult

where F: Factoid + Zero + Add<F, Output = F> + Neg<Output = F> + Clone + Debug + Output + 'rules,

Ensures that the sum of several expressions equals zero.

For instance, one could write:

solver.equals_zero(vec![
    outputs[0].rank.into(),
    outputs[1].rank.into(),
    (-1, inputs[1].shape[0]).into(),
]);

pub fn with<T, A, F>(&mut self, item: A, closure: F) -> InferenceResult

where T: Factoid + Output + 'static, A: IntoExp<T>, F: Fn(&mut Solver<'rules>, T) -> InferenceResult + 'rules,

Adds rules to the solver with a partial value.

For instance, one could write:

solver.given(input.rank, |solver, ir|
    (0..ir).map(|i| solver.equals(input.shape[ir], 0))
);

pub fn given<T, A, F>(&mut self, item: A, closure: F) -> InferenceResult

where T: Factoid + Output + 'static, A: IntoExp<T>, F: Fn(&mut Solver<'rules>, T::Concrete) -> InferenceResult + 'rules,

Adds rules to the solver once the value of an expression is known.

For instance, one could write:

solver.given(input.rank, |solver, ir|
    (0..ir).map(|i| solver.equals(input.shape[ir], 0))
);

pub fn given_all<T, I, A, F>(&mut self, items: I, closure: F) -> InferenceResult

where T: Factoid + Output + 'static, A: IntoExp<T>, I: IntoIterator<Item = A>, F: Fn(&mut Solver<'rules>, Vec<T::Concrete>) -> InferenceResult + 'rules,

Adds rules to the solver once the value of all expressions are known.

For instance, one could write:

solver.given(input.rank, |solver, ir|
    (0..ir).map(|i| solver.equals(input.shape[ir], 0))
);

impl<'rules> Solver<'rules>

pub fn given_2<T1, T2, A1, A2, F>( &mut self, item_1: A1, item_2: A2, closure: F ) -> InferenceResult

where A1: IntoExp<T1>, T1: Factoid + Output + 'static, A2: IntoExp<T2>, T2: Factoid + Output + 'static, F: Fn(&mut Solver<'rules>, T1::Concrete, T2::Concrete) -> InferenceResult + 'rules,

impl<'rules> Solver<'rules>

pub fn given_3<T1, T2, T3, A1, A2, A3, F>( &mut self, item_1: A1, item_2: A2, item_3: A3, closure: F ) -> InferenceResult

where A1: IntoExp<T1>, T1: Factoid + Output + 'static, A2: IntoExp<T2>, T2: Factoid + Output + 'static, A3: IntoExp<T3>, T3: Factoid + Output + 'static, F: Fn(&mut Solver<'rules>, T1::Concrete, T2::Concrete, T3::Concrete) -> InferenceResult + 'rules,

impl<'rules> Solver<'rules>

pub fn given_4<T1, T2, T3, T4, A1, A2, A3, A4, F>( &mut self, item_1: A1, item_2: A2, item_3: A3, item_4: A4, closure: F ) -> InferenceResult

where A1: IntoExp<T1>, T1: Factoid + Output + 'static, A2: IntoExp<T2>, T2: Factoid + Output + 'static, A3: IntoExp<T3>, T3: Factoid + Output + 'static, A4: IntoExp<T4>, T4: Factoid + Output + 'static, F: Fn(&mut Solver<'rules>, T1::Concrete, T2::Concrete, T3::Concrete, T4::Concrete) -> InferenceResult + 'rules,

Trait Implementations

impl<'rules> Default for Solver<'rules>

fn default() -> Solver<'rules>

Returns the “default value” for a type.