Struct tract_hir::internal::BaseNode

pub struct BaseNode<F, O> where
    F: Fact + Hash,
    O: Hash,  {
    pub id: usize,
    pub name: String,
    pub inputs: Vec<OutletId>,
    pub op: O,
    pub outputs: SmallVec<[OutletFact<F>; 4]>,
}

A Node in an Model.

Parameterized by a Fact implementation matching the one used in the model.

Fields

id: usize

node id in the model

Caution: this id will not be persistent during networks transformation

name: String

name of the node

This will usually come from the importing framework. tract transformation try to maintain the names accross transformations.

inputs: Vec<OutletId>

A list of incoming tensors, identified by the node outlet that creates them.

op: O

The actual operation the node performs.

outputs: SmallVec<[OutletFact<F>; 4]>

List of ouputs, with their descendant and tensor type information.

Implementations

impl<F, NodeOp> BaseNode<F, NodeOp> where
    F: Fact + Hash,
    NodeOp: AsRef<dyn Op + 'static> + AsMut<dyn Op + 'static> + Debug + Display + Hash, 

pub fn op(&self) -> &(dyn Op + 'static)

Access the op of the node

pub fn op_as<O>(&self) -> Option<&O> where
    O: Op, 

Try to downcast the node operation to O.

pub fn op_as_mut<O>(&mut self) -> Option<&mut O> where
    O: Op, 

Try to downcast the node operation to O.

pub fn op_is<O>(&self) -> bool where
    O: Op, 

Check if the node operation is of type O.

pub fn same_as(&self, other: &BaseNode<F, NodeOp>) -> bool

Check that this node produce the same outputs as other.

Trait Implementations

impl<F, O> Clone for BaseNode<F, O> where
    F: Fact + Clone + Hash,
    O: Clone + Hash, 

fn clone(&self) -> BaseNode<F, O>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F, O> Debug for BaseNode<F, O> where
    F: Fact + Debug + Hash,
    O: Debug + Hash, 

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

Formats the value using the given formatter.

impl<F, O> Display for BaseNode<F, O> where
    F: Fact + Hash,
    O: Display + Hash, 

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

Formats the value using the given formatter.

impl<F, O> Hash for BaseNode<F, O> where
    F: Fact + Hash,
    O: Hash, 

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

Feeds this value into the given [Hasher].

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

Feeds a slice of this type into the given [Hasher].