[−][src]Trait tract_hir::infer::rules::InferenceRulesOp

pub trait InferenceRulesOp {
    fn rules<'r, 'p: 'r, 's: 'r>(
        &'s self, 
        solver: &mut Solver<'r>, 
        inputs: &'p [TensorProxy], 
        outputs: &'p [TensorProxy]
    ) -> InferenceResult;
    fn as_op(&self) -> &dyn Op;
    fn as_op_mut(&mut self) -> &mut dyn Op;

    fn to_typed(
        &self, 
        source: &InferenceModel, 
        node: &InferenceNode, 
        target: &mut TypedModel, 
        mapping: &HashMap<OutletId, OutletId>
    ) -> TractResult<TVec<OutletId>> { ... }
    fn nboutputs(&self) -> TractResult<usize> { ... }
    fn incorporate(
        &self, 
        model: &InferenceModel, 
        node: &InferenceNode
    ) -> TractResult<Option<InferenceModelPatch>> { ... }
}

Required methods

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, solver: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`

Registers the inference rules of the operator.

`fn as_op(&self) -> &dyn Op`

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

Loading content...

Provided methods

`fn to_typed( &self, source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`

`fn nboutputs(&self) -> TractResult<usize>`

`fn incorporate( &self, model: &InferenceModel, node: &InferenceNode ) -> TractResult<Option<InferenceModelPatch>>`

Loading content...

Implementors

`impl InferenceRulesOp for Box<dyn Expansion>`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`[src]

`fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn nboutputs(&self) -> TractResult<usize>`[src]

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`impl InferenceRulesOp for ConstantLike`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`[src]

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`impl InferenceRulesOp for EyeLike`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`[src]

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`impl InferenceRulesOp for Gather`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`[src]

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`impl InferenceRulesOp for Pad`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`[src]

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`impl InferenceRulesOp for Nary`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`[src]

`fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`impl InferenceRulesOp for MaxPool`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`[src]

`fn nboutputs(&self) -> TractResult<usize>`[src]

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`impl InferenceRulesOp for SumPool`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`[src]

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`impl InferenceRulesOp for Downsample`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`[src]

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`impl InferenceRulesOp for Dummy`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, _s: &mut Solver<'r>, _inputs: &'p [TensorProxy], _outputs: &'p [TensorProxy] ) -> InferenceResult`[src]

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`impl InferenceRulesOp for ElementWiseOp`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`[src]

`fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`impl InferenceRulesOp for Identity`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`[src]

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`impl InferenceRulesOp for Const`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`[src]

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`impl InferenceRulesOp for Iff`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`[src]

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`impl InferenceRulesOp for MatMul`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`[src]

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`impl InferenceRulesOp for LayerHardmax`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, solver: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`[src]

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`impl InferenceRulesOp for Source`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, _s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`[src]

Registers the inference rules of the operator.

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`impl InferenceRulesOp for UnimplementedOp`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, _: &mut Solver<'r>, _: &'p [TensorProxy], _: &'p [TensorProxy] ) -> InferenceResult`[src]

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`fn to_typed( &self, _source: &InferenceModel, _node: &InferenceNode, _target: &mut TypedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`impl<D: DimLike + ToDim> InferenceRulesOp for Slice<D>`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`[src]

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

Loading content...

[−][src]Trait tract_hir::infer::rules::InferenceRulesOp

Required methods

fn rules<'r, 'p: 'r, 's: 'r>( &'s self, solver: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy]) -> InferenceResult

fn as_op(&self) -> &dyn Op

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

Provided methods

fn to_typed( &self, source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId>) -> TractResult<TVec<OutletId>>

fn nboutputs(&self) -> TractResult<usize>

fn incorporate( &self, model: &InferenceModel, node: &InferenceNode) -> TractResult<Option<InferenceModelPatch>>

Implementors

impl InferenceRulesOp for Box<dyn Expansion>[src]

fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy]) -> InferenceResult[src]

fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId>) -> TractResult<TVec<OutletId>>[src]

fn nboutputs(&self) -> TractResult<usize>[src]

fn as_op(&self) -> &dyn Op[src]

fn as_op_mut(&mut self) -> &mut dyn Op[src]

impl InferenceRulesOp for ConstantLike[src]

fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy]) -> InferenceResult[src]

fn as_op(&self) -> &dyn Op[src]

fn as_op_mut(&mut self) -> &mut dyn Op[src]

fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId>) -> TractResult<TVec<OutletId>>[src]

impl InferenceRulesOp for EyeLike[src]

fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy]) -> InferenceResult[src]

fn as_op(&self) -> &dyn Op[src]

fn as_op_mut(&mut self) -> &mut dyn Op[src]

fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId>) -> TractResult<TVec<OutletId>>[src]

impl InferenceRulesOp for Gather[src]

fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy]) -> InferenceResult[src]

fn as_op(&self) -> &dyn Op[src]

fn as_op_mut(&mut self) -> &mut dyn Op[src]

fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId>) -> TractResult<TVec<OutletId>>[src]

impl InferenceRulesOp for Pad[src]

fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy]) -> InferenceResult[src]

fn as_op(&self) -> &dyn Op[src]

fn as_op_mut(&mut self) -> &mut dyn Op[src]

fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId>) -> TractResult<TVec<OutletId>>[src]

impl InferenceRulesOp for Nary[src]

fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy]) -> InferenceResult[src]

fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId>) -> TractResult<TVec<OutletId>>[src]

fn as_op(&self) -> &dyn Op[src]

fn as_op_mut(&mut self) -> &mut dyn Op[src]

impl InferenceRulesOp for MaxPool[src]

fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy]) -> InferenceResult[src]

fn nboutputs(&self) -> TractResult<usize>[src]

fn as_op(&self) -> &dyn Op[src]

fn as_op_mut(&mut self) -> &mut dyn Op[src]

fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId>) -> TractResult<TVec<OutletId>>[src]

impl InferenceRulesOp for SumPool[src]

fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy]) -> InferenceResult[src]

fn as_op(&self) -> &dyn Op[src]

fn as_op_mut(&mut self) -> &mut dyn Op[src]

fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId>) -> TractResult<TVec<OutletId>>[src]

impl InferenceRulesOp for Downsample[src]

fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy]) -> InferenceResult[src]

fn as_op(&self) -> &dyn Op[src]

fn as_op_mut(&mut self) -> &mut dyn Op[src]

fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId>) -> TractResult<TVec<OutletId>>[src]

impl InferenceRulesOp for Dummy[src]

fn rules<'r, 'p: 'r, 's: 'r>( &'s self, _s: &mut Solver<'r>, _inputs: &'p [TensorProxy], _outputs: &'p [TensorProxy]) -> InferenceResult[src]

fn as_op(&self) -> &dyn Op[src]

fn as_op_mut(&mut self) -> &mut dyn Op[src]

fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId>) -> TractResult<TVec<OutletId>>[src]

impl InferenceRulesOp for ElementWiseOp[src]

fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy]) -> InferenceResult[src]

fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId>) -> TractResult<TVec<OutletId>>[src]

fn as_op(&self) -> &dyn Op[src]

fn as_op_mut(&mut self) -> &mut dyn Op[src]

impl InferenceRulesOp for Identity[src]

fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy]) -> InferenceResult[src]

fn as_op(&self) -> &dyn Op[src]

fn as_op_mut(&mut self) -> &mut dyn Op[src]

fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId>) -> TractResult<TVec<OutletId>>[src]

impl InferenceRulesOp for Const[src]

fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy]) -> InferenceResult[src]

fn as_op(&self) -> &dyn Op[src]

fn as_op_mut(&mut self) -> &mut dyn Op[src]

fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId>) -> TractResult<TVec<OutletId>>[src]

impl InferenceRulesOp for Iff[src]

fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy]) -> InferenceResult[src]

fn as_op(&self) -> &dyn Op[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, solver: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`

`fn as_op(&self) -> &dyn Op`

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

`fn to_typed( &self, source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`

`fn nboutputs(&self) -> TractResult<usize>`

`fn incorporate( &self, model: &InferenceModel, node: &InferenceNode ) -> TractResult<Option<InferenceModelPatch>>`

`impl InferenceRulesOp for Box<dyn Expansion>`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`[src]

`fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn nboutputs(&self) -> TractResult<usize>`[src]

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`impl InferenceRulesOp for ConstantLike`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`[src]

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`impl InferenceRulesOp for EyeLike`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`[src]

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`impl InferenceRulesOp for Gather`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`[src]

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`impl InferenceRulesOp for Pad`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`[src]

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`impl InferenceRulesOp for Nary`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`[src]

`fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`impl InferenceRulesOp for MaxPool`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`[src]

`fn nboutputs(&self) -> TractResult<usize>`[src]

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`impl InferenceRulesOp for SumPool`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`[src]

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`impl InferenceRulesOp for Downsample`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`[src]

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`impl InferenceRulesOp for Dummy`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, _s: &mut Solver<'r>, _inputs: &'p [TensorProxy], _outputs: &'p [TensorProxy] ) -> InferenceResult`[src]

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`impl InferenceRulesOp for ElementWiseOp`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`[src]

`fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`impl InferenceRulesOp for Identity`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`[src]

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`impl InferenceRulesOp for Const`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`[src]

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`impl InferenceRulesOp for Iff`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`[src]

`fn as_op(&self) -> &dyn Op`[src]

`fn as_op_mut(&mut self) -> &mut dyn Op`[src]

`fn to_typed( &self, _source: &InferenceModel, node: &InferenceNode, target: &mut TypedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`impl InferenceRulesOp for MatMul`[src]

`fn rules<'r, 'p: 'r, 's: 'r>( &'s self, s: &mut Solver<'r>, inputs: &'p [TensorProxy], outputs: &'p [TensorProxy] ) -> InferenceResult`[src]