Module data 

Data management module for chart data structures and operations.

This module provides efficient data structures for storing and managing chart data with static allocation and predictable memory usage. All data structures are designed for embedded systems with limited memory.

Data Processing Features

Aggregation and Downsampling

Efficient algorithms for reducing data density while preserving important characteristics:

use embedded_charts::prelude::*;
use embedded_charts::data::aggregation::*;

let mut large_dataset: StaticDataSeries<Point2D, 10000> = StaticDataSeries::new();
// ... populate with data ...

// Aggregate using different strategies
let config = AggregationConfig {
    strategy: AggregationStrategy::Mean,
    target_points: 100,
    preserve_endpoints: true,
    ..Default::default()
};
let aggregated: StaticDataSeries<Point2D, 256> = large_dataset.aggregate(&config)?;

// Downsample using LTTB algorithm
let downsample_config = DownsamplingConfig {
    max_points: 50,
    ..Default::default()
};
let downsampled: StaticDataSeries<Point2D, 256> = large_dataset.downsample_lttb(&downsample_config)?;

Core Data Types

Point2D

Basic 2D point representation for chart data:

use embedded_charts::prelude::*;

let point = Point2D::new(1.0, 25.5);
println!("X: {}, Y: {}", point.x(), point.y());

StaticDataSeries

Fixed-capacity data series with compile-time bounds:

use embedded_charts::prelude::*;

// Create a series with capacity for 256 points
let mut series: StaticDataSeries<Point2D, 256> = StaticDataSeries::new();

// Add data points
series.push(Point2D::new(0.0, 10.0))?;
series.push(Point2D::new(1.0, 20.0))?;
series.push(Point2D::new(2.0, 15.0))?;

// Create from tuples
let series: StaticDataSeries<Point2D, 256> = StaticDataSeries::from_tuples(&[
    (0.0, 10.0),
    (1.0, 20.0),
    (2.0, 15.0),
])?;

println!("Series has {} points", series.len());

MultiSeries

Container for multiple data series with automatic color assignment:

use embedded_charts::prelude::*;

// Container for 8 series, 256 points each
let mut multi_series: MultiSeries<Point2D, 8, 256> = MultiSeries::new();

let temp_data = data_points![(0.0, 22.5), (1.0, 23.1), (2.0, 24.2)];
let humidity_data = data_points![(0.0, 65.0), (1.0, 68.0), (2.0, 72.0)];

multi_series.add_series(temp_data)?;
multi_series.add_series(humidity_data)?;

println!("Multi-series has {} series", multi_series.series_count());

Data Bounds

Automatic calculation of data bounds for optimal chart scaling:

use embedded_charts::prelude::*;

let data = data_points![(0.0, 10.0), (5.0, 30.0), (10.0, 15.0)];

// Calculate bounds for single series
let bounds = data.bounds()?;
println!("X: {} to {}, Y: {} to {}",
         bounds.min_x, bounds.max_x, bounds.min_y, bounds.max_y);

// For multi-series, bounds are calculated per chart implementation

Streaming Data (feature: “animations”)

Real-time data management with sliding windows:

use embedded_charts::prelude::*;

// Sliding window for real-time data (100 points)
let mut streaming_data: SlidingWindowSeries<Point2D, 100> =
    SlidingWindowSeries::new();

// Add data points (automatically removes old ones when full)
for i in 0..150 {
    let timestamp = i as f32 * 0.1;
    let value = (timestamp * 2.0).sin() * 10.0 + 50.0;
    let _ = streaming_data.push(Point2D::new(timestamp, value));
}

println!("Streaming data has {} points", streaming_data.len());

Memory Efficiency

All data structures use static allocation for predictable memory usage:

• No heap allocation: All data is stored in fixed-size arrays
• Compile-time bounds: Memory usage is known at compile time
• Zero-cost abstractions: High-level API with no runtime overhead
• Configurable capacity: Adjust memory usage per application needs

Data Point Types

Basic Points

• Point2D - Standard 2D floating-point coordinates
• IntPoint - Integer coordinates for memory-constrained systems
• TimestampedPoint - Points with timestamp information

Specialized Points

Different point types for specific use cases:

use embedded_charts::prelude::*;

// Integer points for memory efficiency
let int_point = IntPoint::new(10, 25);

// Timestamped points for time-series data
let timestamped = TimestampedPoint::new(1234567890.0, 25.5);

Data Series Trait

All data containers implement the DataSeries trait:

use embedded_charts::data::DataSeries;

fn process_data<T: DataSeries>(data: &T) {
    println!("Processing {} data points", data.len());
    if data.is_empty() {
        println!("No data available");
    }
}

Utility Macros

Convenient macros for creating data:

use embedded_charts::prelude::*;

// Create data points from tuples
let data = data_points![
    (0.0, 10.0),
    (1.0, 20.0),
    (2.0, 15.0),
    (3.0, 25.0),
];

assert_eq!(data.len(), 4);

Re-exports

pub use aggregation::*;

pub use bounds::*;

pub use point::*;

pub use ring_buffer::*;

pub use series::*;

pub use streaming::*;

Modules

aggregation

Data aggregation and downsampling for efficient chart rendering.

bounds

Data bounds calculation and management for chart scaling.

point

Data point types and traits for chart data.

ring_buffer

High-performance ring buffer implementation for real-time data streaming.

series

Data series implementations for chart data management.

streaming

Unified streaming data functionality for real-time chart updates.