[−][src]Trait tract_hir::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
[src]
impl AsRef<dyn Op + 'static> for dyn TypedOp + 'static
[src]
Implementations on Foreign Types
impl TypedOp for Tile
[src]
fn as_op(&self) -> &(dyn Op + 'static)
[src]
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
[src]
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
[src]
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
impl TypedOp for Reduce
[src]
fn as_op(&self) -> &(dyn Op + 'static)
[src]
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
[src]
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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 MultiBroadcastTo
[src]
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
[src]
&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>
[src]
&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)
[src]
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
[src]
impl<T> TypedOp for MatMatMulPackB<T> where
T: Copy + Datum + Zero,
[src]
T: Copy + Datum + Zero,
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)
[src]
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
[src]
impl TypedOp for MatMulUnary
[src]
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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)
[src]
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
[src]
impl TypedOp for UnaryOp
[src]
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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)
[src]
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
[src]
impl TypedOp for TypedSource
[src]
fn output_facts(
&self,
_inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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)
[src]
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
[src]
impl TypedOp for TypedBinOp
[src]
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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)
[src]
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
[src]
impl TypedOp for LirScan
[src]
fn as_op(&self) -> &(dyn Op + 'static)
[src]
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
[src]
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
[src]
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
impl TypedOp for Delay
[src]
fn as_op(&self) -> &(dyn Op + 'static)
[src]
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
[src]
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
[src]
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
fn cost(
&self,
_inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>
[src]
&self,
_inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>
impl TypedOp for FiniteReshape
[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)
[src]
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
[src]
impl TypedOp for PulsePad
[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)
[src]
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
[src]
impl<T> TypedOp for Im2Col<T> where
T: Datum + Copy + Zero,
[src]
T: Datum + Copy + Zero,
fn as_op(&self) -> &(dyn Op + 'static)
[src]
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
[src]
fn output_facts(
&self,
_inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
[src]
&self,
_inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
impl TypedOp for MergeOpUnicast
[src]
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
[src]
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
fn cost(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>
[src]
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>
fn as_op(&self) -> &(dyn Op + 'static)
[src]
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
[src]
Implementors
impl TypedOp for AxisOp
[src]
fn as_op(&self) -> &(dyn Op + 'static)
[src]
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
[src]
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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 ConstantLike
[src]
fn as_op(&self) -> &dyn Op
[src]
fn as_op_mut(&mut self) -> &mut dyn Op
[src]
fn output_facts(&self, inputs: &[&TypedFact]) -> TractResult<TVec<TypedFact>>
[src]
impl TypedOp for EyeLike
[src]
fn as_op(&self) -> &dyn Op
[src]
fn as_op_mut(&mut self) -> &mut dyn Op
[src]
fn output_facts(&self, inputs: &[&TypedFact]) -> TractResult<TVec<TypedFact>>
[src]
impl TypedOp for Gather
[src]
fn as_op(&self) -> &(dyn Op + 'static)
[src]
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
[src]
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
[src]
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
impl TypedOp for Pad
[src]
fn as_op(&self) -> &(dyn Op + 'static)
[src]
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
[src]
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
[src]
&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>
[src]
&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>
[src]
&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 TypedConcat
[src]
fn as_op(&self) -> &(dyn Op + 'static)
[src]
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
[src]
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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
[src]
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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)
[src]
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
[src]
impl TypedOp for MaxPool
[src]
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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)
[src]
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
[src]
impl TypedOp for SumPool
[src]
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
[src]
&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>
[src]
&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>
[src]
&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)
[src]
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
[src]
impl TypedOp for Downsample
[src]
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
[src]
&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>
[src]
&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>
[src]
&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)
[src]
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
[src]
impl TypedOp for Dummy
[src]
fn as_op(&self) -> &(dyn Op + 'static)
[src]
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
[src]
fn output_facts(
&self,
_inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
[src]
&self,
_inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
impl TypedOp for ElementWiseOp
[src]
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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)
[src]
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
[src]
impl TypedOp for Identity
[src]
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
[src]
&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>
[src]
&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>
[src]
&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)
[src]
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
[src]
impl TypedOp for Const
[src]
fn as_op(&self) -> &(dyn Op + 'static)
[src]
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
[src]
fn output_facts(
&self,
_inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
[src]
&self,
_inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
impl TypedOp for Iff
[src]
fn as_op(&self) -> &(dyn Op + 'static)
[src]
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
[src]
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
[src]
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
impl TypedOp for MatMul
[src]
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
[src]
&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>
[src]
&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>
[src]
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[(Cost, TDim); 4]>, TractError>
fn as_op(&self) -> &(dyn Op + 'static)
[src]
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
[src]
impl TypedOp for LayerHardmax
[src]
fn output_facts(&self, inputs: &[&TypedFact]) -> TractResult<TVec<TypedFact>>
[src]
fn as_op(&self) -> &dyn Op
[src]
fn as_op_mut(&mut self) -> &mut dyn Op
[src]
impl TypedOp for DequantizeLinearF32
[src]
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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)
[src]
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
[src]
impl TypedOp for Scan
[src]
fn as_op(&self) -> &(dyn Op + 'static)
[src]
fn as_op_mut(&mut self) -> &mut (dyn Op + 'static)
[src]
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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,
[src]
D: DimLike + ToDim + Hash,
fn output_facts(
&self,
inputs: &[&TypedFact]
) -> Result<SmallVec<[TypedFact; 4]>, TractError>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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>
[src]
&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>