Struct StaticDataSeries 

pub struct StaticDataSeries<T, const N: usize>
where
    T: DataPoint,
{ /* private fields */ }

A static data series with compile-time capacity bounds

Implementations

impl<T, const N: usize> StaticDataSeries<T, N>

where T: DataPoint,

pub fn new() -> Self

Create a new empty static data series

pub fn with_label(label: &str) -> Self

Create a new static data series with a label

pub fn set_label(&mut self, label: &str)

Set the label for this series

pub fn label(&self) -> Option<&str>

Get the label for this series

pub fn push(&mut self, point: T) -> DataResult<()>

Add a data point to the series

pub fn extend<I>(&mut self, points: I) -> DataResult<()>

where I: IntoIterator<Item = T>,

Add multiple data points from an iterator

pub fn from_tuples(tuples: &[(T::X, T::Y)]) -> DataResult<Self>

where T: DataPoint,

Add data points from a slice of tuples

pub fn clear(&mut self)

Clear all data points

pub fn capacity(&self) -> usize

Get the capacity of this series

pub fn remaining_capacity(&self) -> usize

Get the remaining capacity

pub fn is_full(&self) -> bool

Check if the series is at capacity

pub fn as_slice(&self) -> &[T]

Get a slice of all data points

pub fn sort_by_x(&mut self)

where T::X: Ord, T: Clone,

Sort the data points by X coordinate

pub fn sort_by_y(&mut self)

where T::Y: Ord, T: Clone,

Sort the data points by Y coordinate

impl<T, const N: usize> StaticDataSeries<T, N>

where T: DataPoint + Clone,

pub fn iter_ref(&self) -> StaticDataSeriesRefIter<'_, T>

Get a zero-copy reference iterator (recommended for performance)

pub fn data(&self) -> &[T]

Get the underlying data as a slice (zero-copy access)

impl<T, const N: usize> StaticDataSeries<T, N>

where T: DataPoint + Clone, T::X: PartialOrd + Copy, T::Y: PartialOrd + Copy,

pub fn bounds(&self) -> DataResult<DataBounds<T::X, T::Y>>

Get the bounds of this data series

Trait Implementations

impl<T, const N: usize> Clone for StaticDataSeries<T, N>

where T: DataPoint + Clone,

fn clone(&self) -> StaticDataSeries<T, N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, const M: usize> DataAggregation for StaticDataSeries<T, M>

where T: DataPoint + Clone + Copy, T::X: PartialOrd + Copy + Add<Output = T::X> + Div<f32, Output = T::X> + Into<f32> + From<f32>, T::Y: PartialOrd + Copy + Add<Output = T::Y> + Div<f32, Output = T::Y> + Into<f32> + From<f32>,

Implementation of aggregation for StaticDataSeries

fn aggregate<const N: usize>( &self, config: &AggregationConfig, ) -> DataResult<StaticDataSeries<T, N>>

Aggregate data points using the specified strategy

fn downsample_lttb<const N: usize>( &self, config: &DownsamplingConfig, ) -> DataResult<StaticDataSeries<T, N>>

Downsample data using Largest Triangle Three Buckets algorithm

fn downsample_uniform<const N: usize>( &self, config: &DownsamplingConfig, ) -> DataResult<StaticDataSeries<T, N>>

Downsample data using uniform sampling (every Nth point)

fn calculate_group_stats(&self, points: &[T]) -> DataResult<GroupStats<T>>

Calculate statistics for a group of data points

impl<T, const N: usize> DataSeries for StaticDataSeries<T, N>

where T: DataPoint + Clone,

type Item = T

The type of data points in this series

type Iter = StaticDataSeriesIter<T, N>

Iterator type for iterating over data points (cloning)

fn iter(&self) -> Self::Iter

Get an iterator over the data points (clones items)

fn len(&self) -> usize

Get the number of data points in the series

fn get(&self, index: usize) -> Option<Self::Item>

Get a specific data point by index

fn is_empty(&self) -> bool

Check if the series is empty

fn calculate_bounds(&self) -> DataResult<()>

Calculate the bounds of this data series

impl<T, const N: usize> Debug for StaticDataSeries<T, N>

where T: DataPoint + Debug,

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

Formats the value using the given formatter.

impl<T, const N: usize> Default for StaticDataSeries<T, N>

where T: DataPoint,

fn default() -> Self

Returns the “default value” for a type.

impl Interpolatable for StaticDataSeries<Point2D, 256>

fn interpolate(self, other: Self, progress: f32) -> Option<Self>

Interpolate between two values with the given progress (0.0 to 1.0).