[−][src]Trait tract_core::ops::Op

pub trait Op: Debug + Clone + Send + Sync + 'static + InferenceOp + Downcast + StatefullOp {
    fn name(&self) -> Cow<str>;

    fn infer(
        &self, 
        inputs: TVec<&TensorFact>, 
        outputs: TVec<&TensorFact>
    ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)> { ... }
    fn declutter(
        &self, 
        _model: &TypedModel, 
        _node: &TypedNode
    ) -> TractResult<Option<TypedModelPatch>> { ... }
    fn pulsify(
        &self, 
        _source: &NormalizedModel, 
        _node: &NormalizedNode, 
        _target: &mut PulsedModel, 
        _mapping: &HashMap<OutletId, OutletId>
    ) -> TractResult<TVec<OutletId>> { ... }
    fn codegen(
        &self, 
        _model: &TypedModel, 
        _node: &TypedNode
    ) -> TractResult<Option<TypedModelPatch>> { ... }
    fn cost(
        &self, 
        _inputs: &[&TypedTensorInfo]
    ) -> TractResult<TVec<(Cost, TDim)>> { ... }
    fn rounding_errors(&self) -> bool { ... }
    fn same_as(&self, _other: &dyn Op) -> bool { ... }
    fn info(&self) -> TractResult<Option<String>> { ... }
}

Required methods

`fn name(&self) -> Cow<str>`

Loading content...

Provided methods

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`

Infers properties about the input and output tensors.

The inputs and outputs arguments correspond to properties about the input and output tensors that are already known.

Returns Err in case of an unrecoverable error during the inference, and the refined properties about the inputs and outputs otherwise.

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`

`fn rounding_errors(&self) -> bool`

`fn same_as(&self, _other: &dyn Op) -> bool`

`fn info(&self) -> TractResult<Option<String>>`

Loading content...

Methods

`impl dyn Op`

`pub fn is<__T: Op>(&self) -> bool`

Returns true if the trait object wraps an object of type __T.

`pub fn downcast<T: Op>(self: Box<Self>) -> Result<Box<T>, Box<Self>>`

Returns a boxed object from a boxed trait object if the underlying object is of type __T. Returns the original boxed trait if it isn't.

`pub fn downcast_ref<T: Op>(&self) -> Option<&T>`

Returns a reference to the object within the trait object if it is of type __T, or None if it isn't.

`pub fn downcast_mut<T: Op>(&mut self) -> Option<&mut T>`

Returns a mutable reference to the object within the trait object if it is of type __T, or None if it isn't.

Implementors

`impl Op for AddDims`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Concat`[src]

`fn name(&self) -> Cow<str>`[src]

`fn declutter( &self, model: &TypedModel, node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for ConstantLike`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for ConstantOfShape`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for EyeLike`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Flatten`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Gather`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for MultiBroadcastTo`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Pad`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for PermuteAxes`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Reshape`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for RmDims`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Shape`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Size`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Slice`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Split`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Squeeze`[src]

`fn name(&self) -> Cow<str>`[src]

`fn declutter( &self, model: &TypedModel, node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Tile`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Cast`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Direct`[src]

`fn name(&self) -> Cow<str>`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`fn cost(&self, inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`impl Op for AvgPool`[src]

`fn name(&self) -> Cow<str>`[src]

`fn codegen( &self, model: &TypedModel, node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Conv`[src]

`fn name(&self) -> Cow<str>`[src]

`fn cost(&self, inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn declutter( &self, model: &TypedModel, node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for ConvUnary`[src]

`fn name(&self) -> Cow<str>`[src]

`fn cost(&self, inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn declutter( &self, model: &TypedModel, node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, model: &TypedModel, node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for MaxPool`[src]

`fn name(&self) -> Cow<str>`[src]

`fn codegen( &self, model: &TypedModel, node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Identity`[src]

`fn name(&self) -> Cow<str>`[src]

`fn declutter( &self, model: &TypedModel, node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Const`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for tract_core::ops::logic::And::Bin`[src]

`fn name(&self) -> Cow<str>`[src]

`fn declutter( &self, model: &TypedModel, node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for tract_core::ops::logic::And::UnaryA`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for tract_core::ops::logic::Equals::Bin`[src]

`fn name(&self) -> Cow<str>`[src]

`fn declutter( &self, model: &TypedModel, node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for tract_core::ops::logic::Equals::UnaryA`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for tract_core::ops::logic::Greater::Bin`[src]

`fn name(&self) -> Cow<str>`[src]

`fn declutter( &self, model: &TypedModel, node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for tract_core::ops::logic::Greater::UnaryA`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for tract_core::ops::logic::Lesser::Bin`[src]

`fn name(&self) -> Cow<str>`[src]

`fn declutter( &self, model: &TypedModel, node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for tract_core::ops::logic::Lesser::UnaryA`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for tract_core::ops::logic::Or::Bin`[src]

`fn name(&self) -> Cow<str>`[src]

`fn declutter( &self, model: &TypedModel, node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for tract_core::ops::logic::Or::UnaryA`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for tract_core::ops::logic::Xor::Bin`[src]

`fn name(&self) -> Cow<str>`[src]

`fn declutter( &self, model: &TypedModel, node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for tract_core::ops::logic::Xor::UnaryA`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Not`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for tract_core::ops::math::Add::Bin`[src]

`fn name(&self) -> Cow<str>`[src]

`fn declutter( &self, model: &TypedModel, node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for tract_core::ops::math::Add::UnaryA`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for tract_core::ops::math::Div::Bin`[src]

`fn name(&self) -> Cow<str>`[src]

`fn declutter( &self, model: &TypedModel, node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for tract_core::ops::math::Div::UnaryA`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for tract_core::ops::math::Max::Bin`[src]

`fn name(&self) -> Cow<str>`[src]

`fn declutter( &self, model: &TypedModel, node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for tract_core::ops::math::Max::UnaryA`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for tract_core::ops::math::Min::Bin`[src]

`fn name(&self) -> Cow<str>`[src]

`fn declutter( &self, model: &TypedModel, node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for tract_core::ops::math::Min::UnaryA`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for tract_core::ops::math::Mul::Bin`[src]

`fn name(&self) -> Cow<str>`[src]

`fn declutter( &self, model: &TypedModel, node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for tract_core::ops::math::Mul::UnaryA`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for tract_core::ops::math::Pow::Bin`[src]

`fn name(&self) -> Cow<str>`[src]

`fn declutter( &self, model: &TypedModel, node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for tract_core::ops::math::Pow::UnaryA`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for tract_core::ops::math::Rem::Bin`[src]

`fn name(&self) -> Cow<str>`[src]

`fn declutter( &self, model: &TypedModel, node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for tract_core::ops::math::Rem::UnaryA`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for tract_core::ops::math::Sub::Bin`[src]

`fn name(&self) -> Cow<str>`[src]

`fn declutter( &self, model: &TypedModel, node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for tract_core::ops::math::Sub::UnaryA`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Gemm`[src]

`fn name(&self) -> Cow<str>`[src]

`fn declutter( &self, model: &TypedModel, node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for GemmUnaryA`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for GemmUnaryB`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for MatMul`[src]

`fn name(&self) -> Cow<str>`[src]

`fn cost(&self, inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for MatMulUnaryA`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, model: &TypedModel, node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for MatMulUnaryB`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Abs`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Acos`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Acosh`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for AddN`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Asin`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Asinh`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Atan`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Atanh`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Ceil`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Clip`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Cos`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Cosh`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Exp`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Floor`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for IsNan`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Ln`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for MaxN`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for MeanN`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for MinN`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Neg`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Recip`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Rsqrt`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Sign`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Sin`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Sinh`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Sqrt`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Tan`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for tract_core::ops::math::Tanh`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Sigmoid`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for ArgMaxMin`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for BatchNorm`[src]

`fn name(&self) -> Cow<str>`[src]

`fn declutter( &self, model: &TypedModel, node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Elu`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for GlobalAvgPool`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for GlobalLpPool`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for GlobalMaxPool`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Hardsigmoid`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for LayerHardmax`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for LayerLogSoftmax`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for LayerSoftmax`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for LeakyRelu`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Lrn`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for ParametricSoftplus`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Reduce`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Relu`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for ScaledTanh`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Selu`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Softplus`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Softsign`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for ThresholdedRelu`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for tract_core::ops::nn::tanh::Tanh`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Source`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for UnimplementedOp`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Delay`[src]

`fn name(&self) -> Cow<str>`[src]

`fn same_as(&self, other: &dyn Op) -> bool`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl<T: Copy + Datum + Add + Mul + Zero + FloatLike> Op for MatMulUnaryImplASimpleB<T>`[src]

`fn name(&self) -> Cow<str>`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`impl<T: Copy + Datum + Add + Mul + Zero + FloatLike> Op for MatMulUnaryImplA<T>`[src]

`fn name(&self) -> Cow<str>`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

Loading content...

[−][src]Trait tract_core::ops::Op

Required methods

fn name(&self) -> Cow<str>

Provided methods

fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact>) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>

fn declutter( &self, _model: &TypedModel, _node: &TypedNode) -> TractResult<Option<TypedModelPatch>>

fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId>) -> TractResult<TVec<OutletId>>

fn codegen( &self, _model: &TypedModel, _node: &TypedNode) -> TractResult<Option<TypedModelPatch>>

fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>

fn rounding_errors(&self) -> bool

fn same_as(&self, _other: &dyn Op) -> bool

fn info(&self) -> TractResult<Option<String>>

Methods

impl dyn Op

pub fn is<__T: Op>(&self) -> bool

pub fn downcast<__T: Op>(self: Box<Self>) -> Result<Box<__T>, Box<Self>>

pub fn downcast_ref<__T: Op>(&self) -> Option<&__T>

pub fn downcast_mut<__T: Op>(&mut self) -> Option<&mut __T>

Implementors

impl Op for AddDims[src]

fn name(&self) -> Cow<str>[src]

fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId>) -> TractResult<TVec<OutletId>>[src]

fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact>) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>[src]

fn declutter( &self, _model: &TypedModel, _node: &TypedNode) -> TractResult<Option<TypedModelPatch>>[src]

fn codegen( &self, _model: &TypedModel, _node: &TypedNode) -> TractResult<Option<TypedModelPatch>>[src]

fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>[src]

fn rounding_errors(&self) -> bool[src]

fn same_as(&self, _other: &dyn Op) -> bool[src]

fn info(&self) -> TractResult<Option<String>>[src]

impl Op for Concat[src]

fn name(&self) -> Cow<str>[src]

fn declutter( &self, model: &TypedModel, node: &TypedNode) -> TractResult<Option<TypedModelPatch>>[src]

fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact>) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>[src]

fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId>) -> TractResult<TVec<OutletId>>[src]

fn codegen( &self, _model: &TypedModel, _node: &TypedNode) -> TractResult<Option<TypedModelPatch>>[src]

fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>[src]

fn rounding_errors(&self) -> bool[src]

fn same_as(&self, _other: &dyn Op) -> bool[src]

fn info(&self) -> TractResult<Option<String>>[src]

impl Op for ConstantLike[src]

fn name(&self) -> Cow<str>[src]

fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact>) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>[src]

fn declutter( &self, _model: &TypedModel, _node: &TypedNode) -> TractResult<Option<TypedModelPatch>>[src]

fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId>) -> TractResult<TVec<OutletId>>[src]

fn codegen( &self, _model: &TypedModel, _node: &TypedNode) -> TractResult<Option<TypedModelPatch>>[src]

fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>[src]

fn rounding_errors(&self) -> bool[src]

fn same_as(&self, _other: &dyn Op) -> bool[src]

fn info(&self) -> TractResult<Option<String>>[src]

impl Op for ConstantOfShape[src]

fn name(&self) -> Cow<str>[src]

fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact>) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>[src]

fn declutter( &self, _model: &TypedModel, _node: &TypedNode) -> TractResult<Option<TypedModelPatch>>[src]

fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId>) -> TractResult<TVec<OutletId>>[src]

fn codegen( &self, _model: &TypedModel, _node: &TypedNode) -> TractResult<Option<TypedModelPatch>>[src]

fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>[src]

fn rounding_errors(&self) -> bool[src]

fn same_as(&self, _other: &dyn Op) -> bool[src]

fn info(&self) -> TractResult<Option<String>>[src]

impl Op for EyeLike[src]

fn name(&self) -> Cow<str>[src]

fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact>) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>[src]

fn declutter( &self, _model: &TypedModel, _node: &TypedNode) -> TractResult<Option<TypedModelPatch>>[src]

fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId>) -> TractResult<TVec<OutletId>>[src]

fn codegen( &self, _model: &TypedModel, _node: &TypedNode) -> TractResult<Option<TypedModelPatch>>[src]

fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>[src]

fn rounding_errors(&self) -> bool[src]

fn same_as(&self, _other: &dyn Op) -> bool[src]

fn info(&self) -> TractResult<Option<String>>[src]

impl Op for Flatten[src]

fn name(&self) -> Cow<str>[src]

fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact>) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>[src]

fn declutter( &self, _model: &TypedModel, _node: &TypedNode) -> TractResult<Option<TypedModelPatch>>[src]

fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId>) -> TractResult<TVec<OutletId>>[src]

fn codegen( &self, _model: &TypedModel, _node: &TypedNode) -> TractResult<Option<TypedModelPatch>>[src]

fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>[src]

fn rounding_errors(&self) -> bool[src]

fn same_as(&self, _other: &dyn Op) -> bool[src]

fn info(&self) -> TractResult<Option<String>>[src]

impl Op for Gather[src]

`fn name(&self) -> Cow<str>`

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`

`fn rounding_errors(&self) -> bool`

`fn same_as(&self, _other: &dyn Op) -> bool`

`fn info(&self) -> TractResult<Option<String>>`

`impl dyn Op`

`pub fn is<__T: Op>(&self) -> bool`

`pub fn downcast<T: Op>(self: Box<Self>) -> Result<Box<T>, Box<Self>>`

`pub fn downcast_ref<T: Op>(&self) -> Option<&T>`

`pub fn downcast_mut<T: Op>(&mut self) -> Option<&mut T>`

`impl Op for AddDims`[src]

`fn name(&self) -> Cow<str>`[src]

`fn pulsify( &self, _source: &NormalizedModel, node: &NormalizedNode, target: &mut PulsedModel, mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Concat`[src]

`fn name(&self) -> Cow<str>`[src]

`fn declutter( &self, model: &TypedModel, node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for ConstantLike`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for ConstantOfShape`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for EyeLike`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Flatten`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn cost(&self, _inputs: &[&TypedTensorInfo]) -> TractResult<TVec<(Cost, TDim)>>`[src]

`fn rounding_errors(&self) -> bool`[src]

`fn same_as(&self, _other: &dyn Op) -> bool`[src]

`fn info(&self) -> TractResult<Option<String>>`[src]

`impl Op for Gather`[src]

`fn name(&self) -> Cow<str>`[src]

`fn infer( &self, inputs: TVec<&TensorFact>, outputs: TVec<&TensorFact> ) -> TractResult<(TVec<TensorFact>, TVec<TensorFact>)>`[src]

`fn declutter( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]

`fn pulsify( &self, _source: &NormalizedModel, _node: &NormalizedNode, _target: &mut PulsedModel, _mapping: &HashMap<OutletId, OutletId> ) -> TractResult<TVec<OutletId>>`[src]

`fn codegen( &self, _model: &TypedModel, _node: &TypedNode ) -> TractResult<Option<TypedModelPatch>>`[src]