[−]Trait tract_onnx::prelude::TypedOp
Required methods
fn as_op(&self) -> &(dyn Op + 'static)
Reinterpret the TypedOp as an Op.
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
Reinterpret the TypedOp as an Op, mutably.
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
Deduce output facts from input facts.
Provided methods
fn invariants(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>
fn fuse(
&self,
_model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
_node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
&self,
_model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
_node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
Fuse op after codegen to deal with local optimisations.
fn declutter(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
Declutter the op to the tract_core operator set as much as possible.
fn cost(
&self,
_inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>
&self,
_inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>
Computes a cost hint of the operation.
Each pair is a type of operation and a number per call on eval.
fn suggested_axis_changes(
&self
) -> Result<SmallVec<[(InOut, AxisOp); 4]>, TractError>
&self
) -> Result<SmallVec<[(InOut, AxisOp); 4]>, TractError>
fn change_axes(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
io: InOut,
change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
io: InOut,
change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>
fn slice_output(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
patch: &mut ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>,
output_slot: usize,
axis: usize,
start: usize,
end: usize
) -> Result<Option<OutletId>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
patch: &mut ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>,
output_slot: usize,
axis: usize,
start: usize,
end: usize
) -> Result<Option<OutletId>, TractError>
fn quantize(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
dt: DatumType,
scale: f32,
zero_point: i32
) -> Result<Option<Box<dyn TypedOp + 'static>>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
dt: DatumType,
scale: f32,
zero_point: i32
) -> Result<Option<Box<dyn TypedOp + 'static>>, TractError>
Transforms the op in an equivalent one, operating on dt (i8 or u8).
Returns None if the op can not be translated.
fn pulsify(
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
_target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
_mapping: &HashMap<OutletId, OutletId, RandomState>,
_pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
_target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
_mapping: &HashMap<OutletId, OutletId, RandomState>,
_pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
Translate an op from a typed network to a pulsing equivalent form, if possible.
fn concretize_stream_dim(
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<TypedFact, Box<dyn TypedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
_stream_dim: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<TypedFact, Box<dyn TypedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
_stream_dim: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
Transform the op into by making the S dimension concrete.
fn codegen(
&self,
_model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
_node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
&self,
_model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
_node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
Translate the op into the most efficient form possible for execution.
This transformation is supposed to be final, no more pass are expected to be run on the codegen networks.
fn nested_model_multipliers(
&self,
inputs: &[&TypedFact]
) -> Vec<(Cow<'_, str>, f64)>
&self,
inputs: &[&TypedFact]
) -> Vec<(Cow<'_, str>, f64)>
Nested model multipliers, with label (for profiling).
Trait Implementations
impl AsMut<dyn Op + 'static> for dyn TypedOp + 'static
impl AsRef<dyn Op + 'static> for dyn TypedOp + 'static
Implementations on Foreign Types
impl TypedOp for EyeLike
[src]
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
[src]
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
impl TypedOp for LayerHardmax
[src]
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
[src]
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
impl TypedOp for ConstantLike
[src]
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
[src]
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
impl TypedOp for SumPool
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
fn pulsify(
&self,
source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
_pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
&self,
source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
_pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
fn codegen(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
impl TypedOp for MatMul
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
fn declutter(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
fn cost(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
impl TypedOp for Gather
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
impl TypedOp for TypedConcat
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
fn invariants(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>
fn change_axes(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
_io: InOut,
change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
_io: InOut,
change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>
fn slice_output(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
patch: &mut ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>,
_output_slot: usize,
axis: usize,
start: usize,
end: usize
) -> Result<Option<OutletId>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
patch: &mut ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>,
_output_slot: usize,
axis: usize,
start: usize,
end: usize
) -> Result<Option<OutletId>, TractError>
fn pulsify(
&self,
source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
_pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
&self,
source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
_pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
impl TypedOp for TypedBinOp
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
fn change_axes(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
_io: InOut,
change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
_io: InOut,
change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>
fn invariants(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>
fn cost(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>
fn slice_output(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
patch: &mut ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>,
_output_slot: usize,
axis: usize,
start: usize,
end: usize
) -> Result<Option<OutletId>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
patch: &mut ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>,
_output_slot: usize,
axis: usize,
start: usize,
end: usize
) -> Result<Option<OutletId>, TractError>
fn declutter(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
fn codegen(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
fn pulsify(
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
_pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
_pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
impl TypedOp for Downsample
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
fn declutter(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
fn pulsify(
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
_pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
_pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
impl TypedOp for PulsePad
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
impl TypedOp for Dummy
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
fn output_facts(
&self,
_inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
&self,
_inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
impl TypedOp for TypedSource
fn output_facts(
&self,
_inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
&self,
_inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
fn change_axes(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
_io: InOut,
change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
_io: InOut,
change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>
fn pulsify(
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
_mapping: &HashMap<OutletId, OutletId, RandomState>,
pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
_mapping: &HashMap<OutletId, OutletId, RandomState>,
pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
fn concretize_stream_dim(
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<TypedFact, Box<dyn TypedOp + 'static>>,
_mapping: &HashMap<OutletId, OutletId, RandomState>,
stream_dim: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<TypedFact, Box<dyn TypedOp + 'static>>,
_mapping: &HashMap<OutletId, OutletId, RandomState>,
stream_dim: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
impl TypedOp for MergeOpUnicast
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
fn cost(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
impl TypedOp for UnaryOp
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
fn invariants(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>
fn slice_output(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
patch: &mut ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>,
_output_slot: usize,
axis: usize,
start: usize,
end: usize
) -> Result<Option<OutletId>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
patch: &mut ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>,
_output_slot: usize,
axis: usize,
start: usize,
end: usize
) -> Result<Option<OutletId>, TractError>
fn cost(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>
fn declutter(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
fn change_axes(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
_io: InOut,
change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
_io: InOut,
change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>
fn pulsify(
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
_pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
_pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
impl TypedOp for Pad
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
fn declutter(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
fn pulsify(
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
_pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
_pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
impl TypedOp for ConvUnary
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
fn invariants(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>
fn declutter(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
fn cost(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>
fn change_axes(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
_io: InOut,
change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
_io: InOut,
change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>
fn pulsify(
&self,
source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
_pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
&self,
source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
_pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
fn codegen(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
impl TypedOp for Scan
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
fn invariants(
&self,
_model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
_node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>
&self,
_model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
_node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>
fn change_axes(
&self,
_model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
_node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
io: InOut,
change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>
&self,
_model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
_node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
io: InOut,
change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>
fn declutter(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
fn pulsify(
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
_pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
_pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
fn concretize_stream_dim(
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<TypedFact, Box<dyn TypedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
stream_dim: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<TypedFact, Box<dyn TypedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
stream_dim: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
fn codegen(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
impl<D> TypedOp for Slice<D> where
D: DimLike + ToDim + Hash,
D: DimLike + ToDim + Hash,
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
fn invariants(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>
fn change_axes(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
_io: InOut,
change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
_io: InOut,
change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>
fn declutter(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
fn pulsify(
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
_pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
_pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
fn slice_output(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
patch: &mut ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>,
_output_slot: usize,
axis: usize,
start: usize,
end: usize
) -> Result<Option<OutletId>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
patch: &mut ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>,
_output_slot: usize,
axis: usize,
start: usize,
end: usize
) -> Result<Option<OutletId>, TractError>
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
impl TypedOp for Const
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
fn output_facts(
&self,
_inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
&self,
_inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
impl TypedOp for AxisOp
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
fn invariants(
&self,
_model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>
&self,
_model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>
fn suggested_axis_changes(
&self
) -> Result<SmallVec<[(InOut, AxisOp); 4]>, TractError>
&self
) -> Result<SmallVec<[(InOut, AxisOp); 4]>, TractError>
fn change_axes(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
io: InOut,
change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
io: InOut,
change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>
fn pulsify(
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
_pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
_pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
impl TypedOp for ElementWiseOp
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
fn change_axes(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
_io: InOut,
change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
_io: InOut,
change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>
fn declutter(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
fn invariants(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>
fn cost(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>
fn quantize(
&self,
_model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
_node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
dt: DatumType,
scale: f32,
zero_point: i32
) -> Result<Option<Box<dyn TypedOp + 'static>>, TractError>
&self,
_model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
_node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
dt: DatumType,
scale: f32,
zero_point: i32
) -> Result<Option<Box<dyn TypedOp + 'static>>, TractError>
fn pulsify(
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
_pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
_pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
impl TypedOp for DequantizeLinearF32
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
fn invariants(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>
fn change_axes(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
_io: InOut,
change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
_io: InOut,
change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>
fn declutter(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
dequant: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
dequant: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
fn pulsify(
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
_pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
_pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
impl TypedOp for MaxPool
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
fn declutter(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
fn pulsify(
&self,
source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
_pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
&self,
source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
_pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
fn codegen(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
impl TypedOp for Identity
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
fn declutter(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
fn fuse(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
impl<T> TypedOp for Im2Col<T> where
T: Datum + Copy + Zero,
T: Datum + Copy + Zero,
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
fn output_facts(
&self,
_inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
&self,
_inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
impl<T> TypedOp for MatMatMulPackB<T> where
T: Copy + Datum + Zero,
T: Copy + Datum + Zero,
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
impl TypedOp for Reduce
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
fn invariants(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>
fn change_axes(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
_io: InOut,
change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
_io: InOut,
change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>
fn pulsify(
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
_pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
_pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
impl TypedOp for LirScan
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
impl TypedOp for MatMulUnary
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
fn invariants(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Invariants, TractError>
fn change_axes(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
_io: InOut,
change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
_io: InOut,
change: &AxisOp
) -> Result<Option<AxisChangeConsequence>, TractError>
fn declutter(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
fn slice_output(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
patch: &mut ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>,
_output_slot: usize,
axis: usize,
start: usize,
end: usize
) -> Result<Option<OutletId>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
patch: &mut ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>,
_output_slot: usize,
axis: usize,
start: usize,
end: usize
) -> Result<Option<OutletId>, TractError>
fn cost(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>
fn pulsify(
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
_pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<PulsedFact, Box<dyn PulsedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
_pulse: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
fn codegen(
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
&self,
model: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>
) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static>>>, TractError>
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
impl TypedOp for Delay
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
fn cost(
&self,
_inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>
&self,
_inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>
impl TypedOp for Iff
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
impl TypedOp for Tile
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
impl TypedOp for MultiBroadcastTo
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
fn concretize_stream_dim(
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<TypedFact, Box<dyn TypedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
stream_dim: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
&self,
_source: &Graph<TypedFact, Box<dyn TypedOp + 'static>>,
node: &BaseNode<TypedFact, Box<dyn TypedOp + 'static>>,
target: &mut Graph<TypedFact, Box<dyn TypedOp + 'static>>,
mapping: &HashMap<OutletId, OutletId, RandomState>,
stream_dim: usize
) -> Result<SmallVec<[OutletId; 4]>, TractError>
fn as_op(&self) -> &(dyn Op + 'static)
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
impl TypedOp for FiniteReshape
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>