Struct SimpleFeature 

pub struct SimpleFeature<X, Y> {
    pub label: f64,
    /* private fields */
}

A feature-like type that doesn’t have a variable first dimension, instead using a constant value

Fields

label: f64

A constant value for the first dimension

Implementations

impl<X, Y> SimpleFeature<X, Y>

pub fn new(label: f64, y: Vec<f64>, z: Vec<f32>) -> Self

pub fn as_view(&self) -> SimpleFeatureView<'_, X, Y>

pub fn into_inner(self) -> (f64, Vec<f64>, Vec<f32>)

pub fn empty(label: f64) -> Self

Create an empty SimpleFeature

pub fn with_capacity(capacity: usize, label: f64) -> Self

Createa a new empty SimpleFeature with pre-allocated capacity

pub fn push<T: CoordinateLike<X> + IntensityMeasurement>( &mut self, pt: &T, time: f64, )

Push a new data point onto the feature and ensure the time ordering invariant is satisfied.

pub fn push_raw(&mut self, _x: f64, y: f64, z: f32)

Push a new data point onto the feature and ensure the time ordering invariant is satisfied.

Trait Implementations

impl<X: Clone, Y: Clone> Clone for SimpleFeature<X, Y>

fn clone(&self) -> SimpleFeature<X, Y>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<X, Y> CoordinateLike<X> for SimpleFeature<X, Y>

fn coordinate(&self) -> f64

The trait method for accessing the coordinate of the object on coordinate system T

impl<X: Debug, Y: Debug> Debug for SimpleFeature<X, Y>

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

Formats the value using the given formatter.

impl<X: Default, Y: Default> Default for SimpleFeature<X, Y>

fn default() -> SimpleFeature<X, Y>

Returns the “default value” for a type.

impl<X, Y, P: CoordinateLike<X> + IntensityMeasurement> Extend<(P, f64)> for SimpleFeature<X, Y>

fn extend<T: IntoIterator<Item = (P, f64)>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<X, Y> Extend<(f64, f64, f32)> for SimpleFeature<X, Y>

fn extend<T: IntoIterator<Item = (f64, f64, f32)>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<X, Y> FeatureLike<X, Y> for SimpleFeature<X, Y>

fn len(&self) -> usize

The number of points in the feature

fn iter(&self) -> impl Iterator<Item = (f64, f64, f32)>

Create an iterator that yields (x, y, intensity) references

fn is_empty(&self) -> bool

Check if the feature has any points in it

fn at(&self, index: usize) -> Option<(f64, f64, f32)>

Get an immutable reference to feature data at a specified index

fn first(&self) -> Option<(f64, f64, f32)>

Retrieve the first time point, if it exists

fn last(&self) -> Option<(f64, f64, f32)>

Retrieve the last time point, if it exists

fn at_time(&self, time: f64) -> Option<(f64, f64, f32)>

Get an immutable reference to feature data at a specified time.Analogous to combining TimeInterval::find_time with FeatureLike::at

impl<X, Y> FeatureLikeMut<X, Y> for SimpleFeature<X, Y>

fn iter_mut(&mut self) -> impl Iterator<Item = (&mut f64, &mut f64, &mut f32)>

Create an iterator that yields (x, y, intensity) mutable references

fn push<T: CoordinateLike<X> + IntensityMeasurement>( &mut self, pt: &T, time: f64, )

Add a new peak-like reference to the feature at a given y “time” coordinate. If the “time” is not in sorted order, it should automatically re-sort.

fn push_raw(&mut self, x: f64, y: f64, z: f32)

As FeatureLikeMut::push, but instead add raw values instead of deriving them from a peak-like reference.

fn clear(&mut self)

Clear all the series dimensions.

fn reserve(&mut self, capacity: usize)

Optimistically reserve additional space for capacity entries in the underlying storage.

fn at_mut(&mut self, index: usize) -> Option<(&mut f64, f64, &mut f32)>

Get a mutable reference to feature data at a specified index

fn first_mut(&mut self) -> Option<(&mut f64, f64, &mut f32)>

Get a mutable reference to feature data at the first index, if it exists

fn last_mut(&mut self) -> Option<(&mut f64, f64, &mut f32)>

Get a mutable reference to feature data at the last index, if it exists

fn at_time_mut(&mut self, time: f64) -> Option<(&mut f64, f64, &mut f32)>

Get a mutable reference to feature data at a specified time. Analogous to combining TimeInterval::find_time with FeatureLikeMut::at_mut

impl<X, Y, P: CoordinateLike<X> + IntensityMeasurement> FromIterator<(P, f64)> for SimpleFeature<X, Y>

fn from_iter<T: IntoIterator<Item = (P, f64)>>(iter: T) -> Self

Creates a value from an iterator.

impl<X, Y> FromIterator<(f64, f64, f32)> for SimpleFeature<X, Y>

fn from_iter<T: IntoIterator<Item = (f64, f64, f32)>>(iter: T) -> Self

Creates a value from an iterator.

impl<X, Y> IntensityMeasurement for SimpleFeature<X, Y>

fn intensity(&self) -> f32

impl<X, Y> IntoIterator for SimpleFeature<X, Y>

type Item = (f64, f64, f32)

The type of the elements being iterated over.

type IntoIter = IntoIter<X, Y>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<X, Y> PartialEq for SimpleFeature<X, Y>

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.

impl<X, Y> PartialOrd for SimpleFeature<X, Y>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a, X, Y> SplittableFeatureLike<'a, X, Y> for SimpleFeature<X, Y>

type ViewType = SimpleFeatureView<'a, X, Y>

The type that will hold the split feature parts. They could be borrowed or own a copy of their original data.

fn split_at(&'a self, index: usize) -> (Self::ViewType, Self::ViewType)

Split the feature at index, segmenting before and after it. The position at index should be retained in the second segment.

fn split_at_time(&'a self, point: f64) -> (Self::ViewType, Self::ViewType)

Split the feature at time.

fn slice<I: RangeBounds<usize> + Clone>(&'a self, bounds: I) -> Self::ViewType

Select the positions given by the range of positions in bounds

fn split_mask(&'a self, mask: &[bool]) -> Vec<Self::ViewType>

Retain all positions where mask is true, keeping contiguous positions part of the same feature segments.

fn split_when<F>(&'a self, f: F) -> Vec<Self::ViewType>

where F: FnMut((f64, f64, f32), (f64, f64, f32)) -> bool,

Given a function f that takes successive pairs of points of (dim1, dim2, intensity) and returns a bool, mask all out all positions where f returns true.

fn split_sparse(&'a self, max_gap_size: f64) -> Vec<Self::ViewType>

Split the feature when there is a gap of size max_gap_size or more in the time dimension

impl<X, Y> TimeArray<Y> for SimpleFeature<X, Y>

fn time_view(&self) -> &[f64]

A slice over the complete time dimension

fn intensity_view(&self) -> &[f32]

A slice over the complete intensity dimension

impl<X, Y> TimeInterval<Y> for SimpleFeature<X, Y>

fn start_time(&self) -> Option<f64>

The earliest time point recorded

fn end_time(&self) -> Option<f64>

The latest time point recorded

fn apex_time(&self) -> Option<f64>

The time point where the feature reaches its greatest intensity

fn area(&self) -> f32

Integrate the feature in the time dimension

fn iter_time(&self) -> impl Iterator<Item = f64>

Return an iterator over the time dimension

fn find_time(&self, time: f64) -> (Option<usize>, f64)

Find the position in the interval closest to the requested time and the magnitude of the error

fn as_range(&self) -> CoordinateRange<T>

Represent the TimeInterval into a CoordinateRange

fn spans(&self, time: f64) -> bool

Check if a time point is spanned by TimeInterval