Struct Patch

pub struct Patch {

    pub spec: PatchSpec,
    pub pad_before: TVec<usize>,
    pub pad_after: TVec<usize>,
    pub padded: bool,
    pub output_shape: TVec<usize>,
    pub data_field: Array2<isize>,
    pub data_field_min_max: TVec<(isize, isize)>,
    pub standard_layout_data_field: Vec<isize>,
    pub op_strides_times_input_storage_strides: TVec<isize>,
    pub valid_output_zone: TVec<Range<usize>>,
    pub invalid_output_zones: TVec<TVec<Range<usize>>>,
    pub zones: Vec<Zone>,
    pub valid_zone_id: Option<usize>,
    pub zone_strides: TVec<isize>,
    pub input_storage_strides: TVec<isize>,
    pub output_storage_strides: TVec<isize>,
}

Fields

spec: PatchSpec

pad_before: TVec<usize>

pad_after: TVec<usize>

padded: bool

output_shape: TVec<usize>

data_field: Array2<isize>

data_field_min_max: TVec<(isize, isize)>

standard_layout_data_field: Vec<isize>

op_strides_times_input_storage_strides: TVec<isize>

valid_output_zone: TVec<Range<usize>>

invalid_output_zones: TVec<TVec<Range<usize>>>

zones: Vec<Zone>

valid_zone_id: Option<usize>

zone_strides: TVec<isize>

input_storage_strides: TVec<isize>

output_storage_strides: TVec<isize>

Implementations

impl Patch

pub fn rank(&self) -> usize

pub fn valid_zone(&self) -> Option<&Zone>

pub fn visit_output(&self, acceptor: impl FnMut(&Scanner<'_>))

pub fn centers_offsets(&self) -> Vec<isize>

pub fn at<'p>(&'p self, coords: &[usize]) -> PatchIterator<'p>

pub fn at_hint<'p>( &'p self, coords: &[usize], hint: Option<bool>, ) -> PatchIterator<'p>

pub fn global_offset_for(&self, coords: &[usize], patch_index: usize) -> usize

Trait Implementations

impl Clone for Patch

fn clone(&self) -> Patch

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Patch

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for Patch

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Patch

fn eq(&self, other: &Patch) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Patch

impl StructuralPartialEq for Patch