Struct DeconvolvedSolutionFeature 

pub struct DeconvolvedSolutionFeature<Y: Clone> {
    pub score: ScoreType,
    pub scores: Vec<ScoreType>,
    /* private fields */
}

Fields

score: ScoreType

scores: Vec<ScoreType>

Implementations

impl<Y: Clone> DeconvolvedSolutionFeature<Y>

pub fn new( inner: ChargedFeature<Mass, Y>, score: ScoreType, scores: Vec<ScoreType>, envelope: Box<[MZPointSeries]>, ) -> Self

pub fn as_inner(&self) -> &ChargedFeature<Mass, Y>

pub fn into_inner( self, ) -> (ChargedFeature<Mass, Y>, Vec<ScoreType>, Box<[MZPointSeries]>)

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn iter(&self) -> Iter<'_, Mass, Y>

pub fn iter_mut(&mut self) -> IterMut<'_, Mass, Y>

pub fn iter_peaks(&self) -> PeakIter<'_, Y>

pub fn iter_envelope(&self) -> EnvelopeIter<'_, Y>

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

pub fn push_peak(&mut self, peak: &DeconvolvedSolutionPeak, time: f64)

pub fn envelope(&self) -> Vec<FeatureView<'_, MZ, Y>>

Trait Implementations

impl<Y0: Clone> AsMut<ChargedFeature<Mass, Y0>> for DeconvolvedSolutionFeature<Y0>

fn as_mut(&mut self) -> &mut ChargedFeature<Mass, Y0>

Converts this type into a mutable reference of the (usually inferred) input type.

impl<Y: Clone> AsPeakIter for DeconvolvedSolutionFeature<Y>

type Peak = DeconvolvedSolutionPeak

type Iter<'a> = PeakIter<'a, Y> where Self: 'a

fn iter_peaks(&self) -> Self::Iter<'_>

impl<Y0: Clone> AsRef<ChargedFeature<Mass, Y0>> for DeconvolvedSolutionFeature<Y0>

fn as_ref(&self) -> &ChargedFeature<Mass, Y0>

Converts this type into a shared reference of the (usually inferred) input type.

impl BuildArrayMap3DFrom for DeconvolvedSolutionFeature<IonMobility>

fn as_arrays_3d(source: &[Self]) -> BinaryArrayMap3D

impl BuildArrayMapFrom for DeconvolvedSolutionFeature<IonMobility>

fn arrays_included(&self) -> Option<Vec<ArrayType>>

fn as_arrays(source: &[Self]) -> BinaryArrayMap

impl BuildFromArrayMap for DeconvolvedSolutionFeature<IonMobility>

fn arrays_required() -> Option<Vec<ArrayType>>

fn try_from_arrays( arrays: &BinaryArrayMap, ) -> Result<Vec<Self>, ArrayRetrievalError>

fn from_arrays(arrays: &BinaryArrayMap) -> Vec<Self>

fn has_arrays_for(arrays: &BinaryArrayMap) -> ArraysAvailable

A pre-emptive check for the presence of the required arrays.

impl BuildFromArrayMap3D for DeconvolvedSolutionFeature<IonMobility>

fn try_from_arrays_3d( arrays: &BinaryArrayMap3D, ) -> Result<Vec<Self>, ArrayRetrievalError>

fn from_arrays_3d(arrays: &BinaryArrayMap3D) -> Vec<Self>

fn has_arrays_3d_for(arrays: &BinaryArrayMap3D) -> ArraysAvailable

impl<Y: Clone> BuildFromPeak<DeconvolvedSolutionPeak> for DeconvolvedSolutionFeature<Y>

fn push_peak(&mut self, value: &DeconvolvedSolutionPeak, time: f64)

Like FeatureLikeMut::push but permitting specialized behavior

fn extend_from_peaks<I>(&mut self, iter: I)

where I: IntoIterator<Item = (T, f64)>,

Like Extend but uses BuildFromPeak::push_peak

impl<Y: Clone + Clone> Clone for DeconvolvedSolutionFeature<Y>

fn clone(&self) -> DeconvolvedSolutionFeature<Y>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Y0: Clone> CoordinateLike<MZ> for DeconvolvedSolutionFeature<Y0>

fn coordinate(&self) -> f64

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

impl<Y0: Clone> CoordinateLike<Mass> for DeconvolvedSolutionFeature<Y0>

fn coordinate(&self) -> f64

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

impl<Y: Debug + Clone> Debug for DeconvolvedSolutionFeature<Y>

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

Formats the value using the given formatter.

impl<Y: Clone> Default for DeconvolvedSolutionFeature<Y>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, Y> Deserialize<'de> for DeconvolvedSolutionFeature<Y>

where Y: Deserialize<'de> + Clone,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Y0: Clone> FeatureLike<Mass, Y0> for DeconvolvedSolutionFeature<Y0>

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<Y0: Clone> FeatureLikeMut<Mass, Y0> for DeconvolvedSolutionFeature<Y0>

fn clear(&mut self)

Clear all the series dimensions.

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<Mass> + 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 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<'a, Y: Clone + 'a> FitPeaksOn<'a> for DeconvolvedSolutionFeature<Y>

fn as_peak_shape_args(&'a self) -> PeakFitArgs<'a, 'a>

fn fit_peaks_with( &'a self, config: FitConfig, ) -> SplittingPeakShapeFitter<'a, 'a>

Fit multiple peak models on this signal.

impl<'a, Y: Clone + 'a> From<&'a DeconvolvedSolutionFeature<Y>> for PeakFitArgs<'a, 'a>

fn from(value: &'a DeconvolvedSolutionFeature<Y>) -> Self

Converts to this type from the input type.

impl<Y0: Clone> IntensityMeasurement for DeconvolvedSolutionFeature<Y0>

fn intensity(&self) -> f32

impl<Y0: Clone> KnownCharge for DeconvolvedSolutionFeature<Y0>

fn charge(&self) -> i32

impl<Y: Clone> KnownChargeMut for DeconvolvedSolutionFeature<Y>

fn charge_mut(&mut self) -> &mut i32

impl<Y: Clone> PartialEq for DeconvolvedSolutionFeature<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<Y: Clone> PartialOrd for DeconvolvedSolutionFeature<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<Y> Serialize for DeconvolvedSolutionFeature<Y>

where Y: Serialize + Clone,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<Y: Clone> SplittableFeatureLike<'_, Mass, Y> for DeconvolvedSolutionFeature<Y>

type ViewType = DeconvolvedSolutionFeature<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_time(&self, point: f64) -> (Self::ViewType, Self::ViewType)

Split the feature at time.

fn split_at(&self, point: 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 slice<I: RangeBounds<usize> + Clone>(&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<Y0: Clone> TimeArray<Y0> for DeconvolvedSolutionFeature<Y0>

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<Y0: Clone> TimeInterval<Y0> for DeconvolvedSolutionFeature<Y0>

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 end_time(&self) -> Option<f64>

The latest time point recorded

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

The earliest time point recorded

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