Trait tract_hir::internal::TypedOp

pub trait TypedOp: 'static + StatefullOp + Op + Send + Sync + Debug + Downcast + DynHash + DynClone {
    fn as_op(&self) -> &(dyn Op + 'static);
    fn as_op_mut(&mut self) -> &mut (dyn Op + 'static);
    fn output_facts(
        &self, 
        inputs: &[&TypedFact]
    ) -> Result<SmallVec<[TypedFact; 4]>, TractError>;

    fn invariants(
        &self, 
        model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>, 
        node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
    ) -> Result<Invariants, TractError> { ... }
    fn fuse(
        &self, 
        _model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>, 
        _node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
    ) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError> { ... }
    fn declutter(
        &self, 
        model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>, 
        node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
    ) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError> { ... }
    fn cost(
        &self, 
        _inputs: &[&TypedFact]
    ) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError> { ... }
    fn suggested_axis_changes(
        &self
    ) -> Result<SmallVec<[(InOut, AxisOp); 4]>, TractError> { ... }
    fn change_axes(
        &self, 
        model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>, 
        node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>, 
        io: InOut, 
        change: &AxisOp
    ) -> Result<Option<AxisChangeConsequence>, TractError> { ... }
    fn slice_output(
        &self, 
        model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>, 
        node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>, 
        patch: &mut ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>, 
        output_slot: usize, 
        axis: usize, 
        start: usize, 
        end: usize
    ) -> Result<Option<OutletId>, TractError> { ... }
    fn quantize(
        &self, 
        model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>, 
        node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>, 
        dt: DatumType, 
        scale: f32, 
        zero_point: i32
    ) -> Result<Option<Box<dyn TypedOp + 'static>>, TractError> { ... }
    fn pulsify(
        &self, 
        _source: &ModelImpl<NormalizedFact, Box<dyn TypedOp + 'static>>, 
        node: &BaseNode<NormalizedFact, Box<dyn TypedOp + 'static>>, 
        _target: &mut ModelImpl<PulsedFact, Box<dyn PulsedOp + 'static>>, 
        _mapping: &HashMap<OutletId, OutletId, RandomState>, 
        _pulse: usize
    ) -> Result<SmallVec<[OutletId; 4]>, TractError> { ... }
    fn codegen(
        &self, 
        _model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>, 
        _node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
    ) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError> { ... }
    fn nested_model_multipliers(
        &self, 
        inputs: &[&TypedFact]
    ) -> Vec<(Cow<str>, f64)> { ... }
}

Required methods

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

Reinterpret the TypedOp as an Op.

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

Reinterpret the TypedOp as an Op, mutably.

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

Deduce output facts from input facts.

Loading content...

Provided methods

fn invariants(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>

fn fuse(
    &self,
    _model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    _node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>

Fuse op after codegen to deal with local optimisations.

fn declutter(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>

Declutter the op to the tract_core operator set as much as possible.

fn cost(
    &self,
    _inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>

Computes a cost hint of the operation.

Each pair is a type of operation and a number per call on eval.

fn suggested_axis_changes(
    &self
) -> Result<SmallVec<[(InOut, AxisOp); 4]>, TractError>

fn change_axes(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
    io: InOut,
    change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>

fn slice_output(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
    patch: &mut ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>,
    output_slot: usize,
    axis: usize,
    start: usize,
    end: usize
) -> Result<Option<OutletId>, TractError>

fn quantize(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
    dt: DatumType,
    scale: f32,
    zero_point: i32
) -> Result<Option<Box<dyn TypedOp + 'static>>, TractError>

Transforms the op in an equivalent one, operating on dt (i8 or u8).

Returns None if the op can not be translated.

fn pulsify(
    &self,
    _source: &ModelImpl<NormalizedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<NormalizedFact, Box<dyn TypedOp + 'static>>,
    _target: &mut ModelImpl<PulsedFact, Box<dyn PulsedOp + 'static>>,
    _mapping: &HashMap<OutletId, OutletId, RandomState>,
    _pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>

Translate an op in a normalized network (no constants) to a pulsing form, if possible.

fn codegen(
    &self,
    _model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    _node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>

Translate the op into the most efficient form possible for execution.

This transformation is supposed to be final, no more pass are expected to be run on the codegen networks.

fn nested_model_multipliers(
    &self,
    inputs: &[&TypedFact]
) -> Vec<(Cow<str>, f64)>

Nested model multipliers, with label (for profiling).

Loading content...

Trait Implementations

impl AsMut<dyn Op + 'static> for dyn TypedOp + 'static

fn as_mut(&mut self) -> &mut (dyn Op + 'static)

Performs the conversion.

impl AsRef<dyn Op + 'static> for dyn TypedOp + 'static

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

Performs the conversion.

Implementations on Foreign Types

impl TypedOp for MergeOp

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

fn invariants(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>

fn change_axes(
    &self,
    _model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    _node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
    _io: InOut,
    change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>

fn cost(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>

fn slice_output(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
    patch: &mut ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>,
    _output_slot: usize,
    axis: usize,
    start: usize,
    end: usize
) -> Result<Option<OutletId>, TractError>

fn codegen(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>

fn pulsify(
    &self,
    _source: &ModelImpl<NormalizedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<NormalizedFact, Box<dyn TypedOp + 'static>>,
    target: &mut ModelImpl<PulsedFact, Box<dyn PulsedOp + 'static>>,
    mapping: &HashMap<OutletId, OutletId, RandomState>,
    _pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

impl<T> TypedOp for Im2Col<T> where
    T: Datum + Copy + Zero, 

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

fn output_facts(
    &self,
    _inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

impl TypedOp for TypedSource

fn output_facts(
    &self,
    _inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

fn change_axes(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
    _io: InOut,
    change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>

fn pulsify(
    &self,
    _source: &ModelImpl<NormalizedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<NormalizedFact, Box<dyn TypedOp + 'static>>,
    target: &mut ModelImpl<PulsedFact, Box<dyn PulsedOp + 'static>>,
    _mapping: &HashMap<OutletId, OutletId, RandomState>,
    pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

impl TypedOp for Delay

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

fn cost(
    &self,
    _inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>

impl TypedOp for TypedBinOp

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

fn change_axes(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
    _io: InOut,
    change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>

fn invariants(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>

fn cost(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>

fn declutter(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>

fn pulsify(
    &self,
    _source: &ModelImpl<NormalizedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<NormalizedFact, Box<dyn TypedOp + 'static>>,
    target: &mut ModelImpl<PulsedFact, Box<dyn PulsedOp + 'static>>,
    mapping: &HashMap<OutletId, OutletId, RandomState>,
    _pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

impl TypedOp for ElementWiseOp

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

fn change_axes(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
    _io: InOut,
    change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>

fn declutter(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>

fn invariants(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>

fn cost(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>

fn quantize(
    &self,
    _model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    _node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
    dt: DatumType,
    scale: f32,
    zero_point: i32
) -> Result<Option<Box<dyn TypedOp + 'static>>, TractError>

fn pulsify(
    &self,
    _source: &ModelImpl<NormalizedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<NormalizedFact, Box<dyn TypedOp + 'static>>,
    target: &mut ModelImpl<PulsedFact, Box<dyn PulsedOp + 'static>>,
    mapping: &HashMap<OutletId, OutletId, RandomState>,
    _pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

impl TypedOp for FiniteReshape

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

impl TypedOp for MultiBroadcastTo

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

impl TypedOp for MergeOpUnicast

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

fn cost(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

impl TypedOp for Tile

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

impl TypedOp for MatMulUnary

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

fn invariants(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>

fn change_axes(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
    _io: InOut,
    change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>

fn declutter(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>

fn slice_output(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
    patch: &mut ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>,
    _output_slot: usize,
    axis: usize,
    start: usize,
    end: usize
) -> Result<Option<OutletId>, TractError>

fn cost(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>

fn pulsify(
    &self,
    _source: &ModelImpl<NormalizedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<NormalizedFact, Box<dyn TypedOp + 'static>>,
    target: &mut ModelImpl<PulsedFact, Box<dyn PulsedOp + 'static>>,
    mapping: &HashMap<OutletId, OutletId, RandomState>,
    _pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>

fn codegen(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

impl<T> TypedOp for MatMatMulPackB<T> where
    T: Copy + Datum + Zero, 

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

impl TypedOp for Reduce

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

fn invariants(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>

fn change_axes(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
    _io: InOut,
    change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>

fn pulsify(
    &self,
    _source: &ModelImpl<NormalizedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<NormalizedFact, Box<dyn TypedOp + 'static>>,
    target: &mut ModelImpl<PulsedFact, Box<dyn PulsedOp + 'static>>,
    mapping: &HashMap<OutletId, OutletId, RandomState>,
    _pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>

impl TypedOp for TypedReshape

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

fn codegen(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>

impl TypedOp for UnaryOp

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

fn invariants(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>

fn slice_output(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
    patch: &mut ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>,
    _output_slot: usize,
    axis: usize,
    start: usize,
    end: usize
) -> Result<Option<OutletId>, TractError>

fn cost(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>

fn declutter(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>

fn change_axes(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
    _io: InOut,
    change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>

fn pulsify(
    &self,
    _source: &ModelImpl<NormalizedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<NormalizedFact, Box<dyn TypedOp + 'static>>,
    target: &mut ModelImpl<PulsedFact, Box<dyn PulsedOp + 'static>>,
    mapping: &HashMap<OutletId, OutletId, RandomState>,
    _pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

Loading content...

Implementors

impl TypedOp for AxisOp

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

fn invariants(
    &self,
    _model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>

fn suggested_axis_changes(
    &self
) -> Result<SmallVec<[(InOut, AxisOp); 4]>, TractError>

fn change_axes(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
    io: InOut,
    change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>

fn pulsify(
    &self,
    _source: &ModelImpl<NormalizedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<NormalizedFact, Box<dyn TypedOp + 'static>>,
    target: &mut ModelImpl<PulsedFact, Box<dyn PulsedOp + 'static>>,
    mapping: &HashMap<OutletId, OutletId, RandomState>,
    _pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>

impl TypedOp for ConstantLike

fn as_op(&self) -> &dyn Op

fn as_op_mut(&mut self) -> &mut dyn Op

fn output_facts(&self, inputs: &[&TypedFact]) -> TractResult<TVec<TypedFact>>

impl TypedOp for EyeLike

fn as_op(&self) -> &dyn Op

fn as_op_mut(&mut self) -> &mut dyn Op

fn output_facts(&self, inputs: &[&TypedFact]) -> TractResult<TVec<TypedFact>>

impl TypedOp for Flatten

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

impl TypedOp for Gather

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

impl TypedOp for Pad

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

fn declutter(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>

fn pulsify(
    &self,
    _source: &ModelImpl<NormalizedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<NormalizedFact, Box<dyn TypedOp + 'static>>,
    target: &mut ModelImpl<PulsedFact, Box<dyn PulsedOp + 'static>>,
    mapping: &HashMap<OutletId, OutletId, RandomState>,
    _pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>

impl TypedOp for Shape

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

impl TypedOp for Size

fn output_facts(
    &self,
    _inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

impl TypedOp for TypedConcat

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

fn invariants(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>

fn change_axes(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
    _io: InOut,
    change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>

fn slice_output(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
    patch: &mut ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>,
    _output_slot: usize,
    axis: usize,
    start: usize,
    end: usize
) -> Result<Option<OutletId>, TractError>

fn pulsify(
    &self,
    source: &ModelImpl<NormalizedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<NormalizedFact, Box<dyn TypedOp + 'static>>,
    target: &mut ModelImpl<PulsedFact, Box<dyn PulsedOp + 'static>>,
    mapping: &HashMap<OutletId, OutletId, RandomState>,
    _pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>

impl TypedOp for AvgPool

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

fn pulsify(
    &self,
    source: &ModelImpl<NormalizedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<NormalizedFact, Box<dyn TypedOp + 'static>>,
    target: &mut ModelImpl<PulsedFact, Box<dyn PulsedOp + 'static>>,
    mapping: &HashMap<OutletId, OutletId, RandomState>,
    _pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>

fn codegen(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

impl TypedOp for ConvUnary

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

fn invariants(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>

fn declutter(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>

fn cost(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>

fn change_axes(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
    _io: InOut,
    change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>

fn pulsify(
    &self,
    source: &ModelImpl<NormalizedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<NormalizedFact, Box<dyn TypedOp + 'static>>,
    target: &mut ModelImpl<PulsedFact, Box<dyn PulsedOp + 'static>>,
    mapping: &HashMap<OutletId, OutletId, RandomState>,
    _pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>

fn codegen(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

impl TypedOp for MaxPool

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

fn pulsify(
    &self,
    source: &ModelImpl<NormalizedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<NormalizedFact, Box<dyn TypedOp + 'static>>,
    target: &mut ModelImpl<PulsedFact, Box<dyn PulsedOp + 'static>>,
    mapping: &HashMap<OutletId, OutletId, RandomState>,
    _pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>

fn codegen(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

impl TypedOp for Downsample

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

fn declutter(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>

fn pulsify(
    &self,
    _source: &ModelImpl<NormalizedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<NormalizedFact, Box<dyn TypedOp + 'static>>,
    target: &mut ModelImpl<PulsedFact, Box<dyn PulsedOp + 'static>>,
    mapping: &HashMap<OutletId, OutletId, RandomState>,
    _pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

impl TypedOp for Dummy

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

fn output_facts(
    &self,
    _inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

impl TypedOp for Identity

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

fn declutter(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>

fn fuse(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

impl TypedOp for Const

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

fn output_facts(
    &self,
    _inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

impl TypedOp for Iff

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

impl TypedOp for MatMul

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

fn declutter(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>

fn cost(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

impl TypedOp for ArgMaxMin

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

impl TypedOp for GlobalAvgPool

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

impl TypedOp for GlobalLpPool

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

impl TypedOp for GlobalMaxPool

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

impl TypedOp for LayerHardmax

fn output_facts(&self, inputs: &[&TypedFact]) -> TractResult<TVec<TypedFact>>

fn as_op(&self) -> &dyn Op

fn as_op_mut(&mut self) -> &mut dyn Op

impl TypedOp for DequantizeLinearF32

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

fn invariants(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>

fn change_axes(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
    _io: InOut,
    change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>

fn declutter(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    dequant: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>

fn pulsify(
    &self,
    _source: &ModelImpl<NormalizedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<NormalizedFact, Box<dyn TypedOp + 'static>>,
    target: &mut ModelImpl<PulsedFact, Box<dyn PulsedOp + 'static>>,
    mapping: &HashMap<OutletId, OutletId, RandomState>,
    _pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

impl TypedOp for Scan

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

fn invariants(
    &self,
    _model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    _node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>

fn change_axes(
    &self,
    _model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    _node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
    io: InOut,
    change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>

fn declutter(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>

fn pulsify(
    &self,
    _source: &ModelImpl<NormalizedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<NormalizedFact, Box<dyn TypedOp + 'static>>,
    target: &mut ModelImpl<PulsedFact, Box<dyn PulsedOp + 'static>>,
    mapping: &HashMap<OutletId, OutletId, RandomState>,
    _pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>

fn nested_model_multipliers(
    &self,
    inputs: &[&TypedFact]
) -> Vec<(Cow<str>, f64)>

fn codegen(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>

impl<D> TypedOp for Slice<D> where
    D: DimLike + ToDim + Hash, 

fn output_facts(
    &self,
    inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>

fn invariants(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>

fn change_axes(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
    _io: InOut,
    change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>

fn declutter(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>

fn pulsify(
    &self,
    _source: &ModelImpl<NormalizedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<NormalizedFact, Box<dyn TypedOp + 'static>>,
    target: &mut ModelImpl<PulsedFact, Box<dyn PulsedOp + 'static>>,
    mapping: &HashMap<OutletId, OutletId, RandomState>,
    _pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>

fn slice_output(
    &self,
    model: &ModelImpl<TypedFact, Box<dyn TypedOp + 'static>>,
    node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
    patch: &mut ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>,
    _output_slot: usize,
    axis: usize,
    start: usize,
    end: usize
) -> Result<Option<OutletId>, TractError>

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

fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)

Loading content...