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) -> StackHeightStats

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 = (I, usize)> + '_

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 = (I, usize)> + '_

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 = (I, usize)> + '_

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 = (I, usize)> + '_

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 = (I, usize)> + '_

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 = (I, usize)> + '_

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())

Trait Implementations

impl<I> Clone for IntCOStack<I>

where I: IntCO + Clone, I::CoordType: Clone,

fn clone(&self) -> IntCOStack<I>

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 + Eq, I::CoordType: Eq,

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 then projected from the final change points instead of being built from a second raw interval collection. This keeps the stack and its covered view derived from the same canonical height function and avoids retaining all input intervals during reduction.

impl<I> PartialEq for IntCOStack<I>

where I: IntCO + PartialEq, I::CoordType: PartialEq,

fn eq(&self, other: &IntCOStack<I>) -> 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<I> StructuralPartialEq for IntCOStack<I>

where I: IntCO,