Struct IntCOStack 

pub struct IntCOStack<I>
where
    I: IntCO,
{ /* private fields */ }

Implementations

impl<I> IntCOStack<I>

where I: IntCO,

pub fn change_points(&self) -> &[ChangePoint<I::CoordType>]

pub fn covered(&self) -> &IntCOSet<I>

pub fn height_stats(&self) -> HeightStats

pub fn height_at(&self, x: I::CoordType) -> usize

impl<I> IntCOStack<I>

where I: IntCO,

pub fn iter_height_segments( &self, ) -> impl Iterator<Item = HeightSegment<I>> + '_

Iterates over positive-height stack segments.

Each item is a closed-open interval together with the stack height that applies throughout that interval.

If all positive-height regions have the same height, the segment intervals are exactly the covered set intervals and the shared height is supplied from height_stats. Otherwise, the height-preserving segmentation is reconstructed from change points.

pub fn iter_height_segments_at_least( &self, min_height: usize, ) -> impl Iterator<Item = HeightSegment<I>> + '_

Iterates over positive-height stack segments whose height is at least min_height.

Each item is a closed-open interval together with the stack height that applies throughout that interval.

This method uses height_stats for cheap fast paths:

• if min_height is greater than the observed maximum height, the iterator is empty;
• if min_height is less than or equal to the observed minimum positive height, every positive-height segment matches and iter_height_segments is reused;
• otherwise, canonical change points are scanned and filtered.

A min_height of zero is treated the same as requesting all positive-height segments, because zero-height gaps are never yielded.

pub fn iter_height_segments_at_most( &self, max_height: usize, ) -> impl Iterator<Item = HeightSegment<I>> + '_

Iterates over positive-height stack segments whose height is at most max_height.

Each item is a closed-open interval together with the stack height that applies throughout that interval.

This method uses height_stats for cheap fast paths:

• if max_height is zero, the iterator is empty because zero-height gaps are never yielded;
• if max_height is smaller than the observed minimum positive height, the iterator is empty;
• if max_height is greater than or equal to the observed maximum height, every positive-height segment matches and iter_height_segments is reused;
• otherwise, canonical change points are scanned and filtered.

pub fn iter_height_segments_exactly( &self, target_height: usize, ) -> impl Iterator<Item = HeightSegment<I>> + '_

Iterates over positive-height stack segments whose height is exactly target_height.

Each item is a closed-open interval together with the stack height that applies throughout that interval.

This method uses height_stats for cheap fast paths:

• if target_height is zero, the iterator is empty because zero-height gaps are never yielded;
• if target_height is outside the observed positive-height range, the iterator is empty;
• if all positive-height regions share the same height and target_height equals that height, the intervals are exactly the covered set intervals;
• otherwise, canonical change points are scanned and filtered.

pub fn iter_height_segments_between( &self, min_height: usize, max_height: usize, ) -> impl Iterator<Item = HeightSegment<I>> + '_

Iterates over positive-height stack segments whose height is within min_height..=max_height.

Each item is a closed-open interval together with the stack height that applies throughout that interval.

Zero-height gaps are never yielded. Therefore, a min_height of zero is treated as if it included all positive heights.

This method uses height_stats for cheap fast paths:

• if min_height > max_height, the iterator is empty;
• if the stack has no positive-height segments, the iterator is empty;
• if the requested range does not overlap the observed positive-height range, the iterator is empty;
• if the requested range covers the full observed positive-height range, every segment matches and iter_height_segments is reused;
• otherwise, canonical change points are scanned and filtered.

pub fn iter_peak_height_segments( &self, ) -> impl Iterator<Item = HeightSegment<I>> + '_

Iterates over positive-height stack segments whose height is the observed maximum stack height.

Each item is a closed-open interval together with the peak height that applies throughout that interval.

If the stack has no positive-height segments, the iterator is empty.

This is equivalent to:

iter_height_segments_exactly(height_stats.max_height())

impl<I> IntCOStack<I>

where I: IntCO + COStartLenConstruct + Copy, I::MeasureType: TryInto<usize>,

pub fn iter_windows( &self, from: I::CoordType, to: I::CoordType, len: I::MeasureType, ) -> impl DoubleEndedIterator<Item = StackWindow<'_, I>> + ExactSizeIterator

Iterates over all fixed-length windows fully contained in [from, to).

Window starts advance by one coordinate unit:

[from,     from + len)
[from + 1, from + 1 + len)
...

Returns an empty iterator when:

• from >= to;
• len == 0;
• len is greater than the measure of [from, to);
• the window count cannot be represented as usize.

pub fn par_iter_windows( &self, from: I::CoordType, to: I::CoordType, len: I::MeasureType, ) -> impl IndexedParallelIterator<Item = StackWindow<'_, I>>

where I: Send + Sync,

Iterates in parallel over all fixed-length windows fully contained in [from, to).

The valid window-start range is represented as an indexed integer range, allowing Rayon to split the work directly without a serial producer or par_bridge.

Trait Implementations

impl<I> Clone for IntCOStack<I>

where I: IntCO,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I> Debug for IntCOStack<I>

where I: IntCO + Debug, I::CoordType: Debug,

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

Formats the value using the given formatter.

impl<I> Default for IntCOStack<I>

where I: IntCO,

fn default() -> Self

Returns the “default value” for a type.

impl<I> Eq for IntCOStack<I>

where I: IntCO,

impl<I> FromIterator<I> for IntCOStack<I>

where I: IntCO + Copy,

fn from_iter<T>(iter: T) -> Self

where T: IntoIterator<Item = I>,

Creates a value from an iterator.

impl<I> FromParallelIterator<I> for IntCOStack<I>

where I: IntCO + Copy + Send,

fn from_par_iter<T>(par_iter: T) -> Self

where T: IntoParallelIterator<Item = I>,

Builds a stack from intervals in parallel.

Each worker accumulates endpoint-derived stack parts locally. The final reduction merges those parts into one canonical height function.

The covered set is not built during construction. It is a derived cache and is initialized lazily when the covered view is first requested.

impl<I> PartialEq for IntCOStack<I>

where I: IntCO,

fn eq(&self, other: &Self) -> 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.