torsh-sparse 0.1.2

Sparse tensor operations for ToRSh with SciRS2 integration
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

//! Data structures for plotting and visualization

use std::time::SystemTime;

/// Data structure for plotting and visualization
#[derive(Debug, Clone)]
pub struct PlotData {
    /// Operation names for x-axis labels
    pub operation_names: Vec<String>,
    /// Average execution times in milliseconds
    pub avg_times: Vec<f64>,
    /// Throughput values (operations per second)
    pub throughputs: Vec<f64>,
    /// Memory usage values in bytes
    pub memory_usage: Vec<f64>,
    /// Timestamps for time-series data
    pub timestamps: Vec<SystemTime>,
}

impl PlotData {
    /// Create empty plot data
    pub fn new() -> Self {
        Self {
            operation_names: Vec::new(),
            avg_times: Vec::new(),
            throughputs: Vec::new(),
            memory_usage: Vec::new(),
            timestamps: Vec::new(),
        }
    }

    /// Add a data point
    pub fn add_point(&mut self, operation: String, time_ms: f64, throughput: f64, memory: f64) {
        self.operation_names.push(operation);
        self.avg_times.push(time_ms);
        self.throughputs.push(throughput);
        self.memory_usage.push(memory);
        self.timestamps.push(SystemTime::now());
    }

    /// Get data for time-series plotting
    pub fn time_series_data(&self) -> Vec<(SystemTime, f64, f64, f64)> {
        self.timestamps
            .iter()
            .zip(&self.avg_times)
            .zip(&self.throughputs)
            .zip(&self.memory_usage)
            .map(|(((time, avg_time), throughput), memory)| {
                (*time, *avg_time, *throughput, *memory)
            })
            .collect()
    }
}

impl Default for PlotData {
    fn default() -> Self {
        Self::new()
    }
}