Struct tract_hir::prelude::SimpleState

pub struct SimpleState<F, O, M, P>
where
    F: Fact + Clone + 'static,
    O: Debug + Display + AsRef<dyn Op> + AsMut<dyn Op> + Clone + 'static,
    M: Borrow<Graph<F, O>>,
    P: Borrow<SimplePlan<F, O, M>>,
{
    pub states: Vec<Option<Box<dyn OpState>>>,
    pub session_state: SessionState,
    pub values: Vec<Option<SmallVec<[TValue; 4]>>>,
    /* private fields */
}

Fields

states: Vec<Option<Box<dyn OpState>>>

session_state: SessionState

values: Vec<Option<SmallVec<[TValue; 4]>>>

Implementations

impl<F, O, M, P> SimpleState<F, O, M, P>

where F: Fact + Clone + 'static, O: Debug + Display + AsRef<dyn Op> + AsMut<dyn Op> + Clone + 'static, M: Borrow<Graph<F, O>>, P: Borrow<SimplePlan<F, O, M>> + Clone,

pub fn new(plan: P) -> Result<SimpleState<F, O, M, P>, Error>

pub fn reset_turn(&mut self) -> Result<(), Error>

Reset wires state.

pub fn reset_op_states(&mut self) -> Result<(), Error>

Reset op inner state.

pub fn run( &mut self, inputs: SmallVec<[TValue; 4]> ) -> Result<SmallVec<[TValue; 4]>, Error>

pub fn exec(&mut self) -> Result<(), Error>

pub fn run_plan_with_eval<Eval, E>( &mut self, inputs: SmallVec<[TValue; 4]>, eval: Eval ) -> Result<SmallVec<[TValue; 4]>, Error>

where Eval: for<'a, 'b, 'c> FnMut(&'a mut SessionState, Option<&'b mut (dyn OpState + 'static)>, &'c Node<F, O>, SmallVec<[TValue; 4]>) -> Result<SmallVec<[TValue; 4]>, E>, E: Into<Error> + Send + Sync + 'static,

pub fn exec_plan_with_eval<Eval, E>(&mut self, eval: Eval) -> Result<(), Error>

where Eval: for<'a, 'b, 'c> FnMut(&'a mut SessionState, Option<&'b mut (dyn OpState + 'static)>, &'c Node<F, O>, SmallVec<[TValue; 4]>) -> Result<SmallVec<[TValue; 4]>, E>, E: Into<Error> + Send + Sync + 'static,

pub fn set_inputs(&mut self, inputs: SmallVec<[TValue; 4]>) -> Result<(), Error>

pub fn set_input(&mut self, input: usize, t: TValue) -> Result<(), Error>

pub fn output(&self, id: usize) -> Result<&TValue, Error>

pub fn outputs(&mut self) -> Result<SmallVec<[TValue; 4]>, Error>

pub fn set_values( &mut self, id: usize, values: SmallVec<[TValue; 4]> ) -> Result<(), Error>

pub fn set_value(&mut self, id: usize, value: TValue) -> Result<(), Error>

pub fn prepare_inputs( &self, node: usize ) -> Result<SmallVec<[TValue; 4]>, Error>

pub fn compute_one(&mut self, node: usize) -> Result<(), Error>

pub fn compute_one_with_inputs( &mut self, node: usize, inputs: SmallVec<[TValue; 4]> ) -> Result<(), Error>

pub fn compute_recursively(&mut self, node: usize) -> Result<&[TValue], Error>

pub fn take_by_name( &mut self, name: &str ) -> Result<SmallVec<[Tensor; 4]>, Error>

pub fn take(&mut self, id: usize) -> Result<SmallVec<[Tensor; 4]>, Error>

pub fn plan(&self) -> &SimplePlan<F, O, M>

pub fn model(&self) -> &Graph<F, O>

pub fn freeze(&self) -> FrozenSimpleState<F, O, M, P>

Trait Implementations

impl<F, O, M, P> Clone for SimpleState<F, O, M, P>

where F: Clone + Fact + 'static, O: Clone + Debug + Display + AsRef<dyn Op> + AsMut<dyn Op> + 'static, M: Clone + Borrow<Graph<F, O>>, P: Clone + Borrow<SimplePlan<F, O, M>>,

fn clone(&self) -> SimpleState<F, O, M, P>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F, O, M, P> Debug for SimpleState<F, O, M, P>

where F: Debug + Fact + Clone + 'static, O: Debug + Display + AsRef<dyn Op> + AsMut<dyn Op> + Clone + 'static, M: Debug + Borrow<Graph<F, O>>, P: Debug + Borrow<SimplePlan<F, O, M>>,

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

Formats the value using the given formatter.

impl OpState for SimpleState<TypedFact, Box<dyn TypedOp>, Graph<TypedFact, Box<dyn TypedOp>>, Arc<SimplePlan<TypedFact, Box<dyn TypedOp>, Graph<TypedFact, Box<dyn TypedOp>>>>>

fn eval( &mut self, _session: &mut SessionState, _op: &(dyn Op + 'static), inputs: SmallVec<[TValue; 4]> ) -> Result<SmallVec<[TValue; 4]>, Error>

impl OpStateFreeze for SimpleState<TypedFact, Box<dyn TypedOp>, Graph<TypedFact, Box<dyn TypedOp>>, Arc<SimplePlan<TypedFact, Box<dyn TypedOp>, Graph<TypedFact, Box<dyn TypedOp>>>>>

fn freeze(&self) -> Box<dyn FrozenOpState>

impl State for SimpleState<TypedFact, Box<dyn TypedOp>, Graph<TypedFact, Box<dyn TypedOp>>, Arc<SimplePlan<TypedFact, Box<dyn TypedOp>, Graph<TypedFact, Box<dyn TypedOp>>>>>

fn run( &mut self, inputs: SmallVec<[TValue; 4]> ) -> Result<SmallVec<[TValue; 4]>, Error>