pandrs 0.3.0

A high-performance DataFrame library for Rust, providing pandas-like API with advanced features including SIMD optimization, parallel processing, and distributed computing capabilities
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

use pandrs::column::ColumnTrait;
use pandrs::error::Result;
use pandrs::{Column, Float64Column, OptimizedDataFrame, StringColumn};

// Helper function for string -> NaiveDate parsing
// Parsing helper function has been removed as it's not used

#[test]
#[allow(clippy::result_large_err)]
fn test_optimized_window_operations() -> Result<()> {
    // Create time series data for testing
    let mut df = OptimizedDataFrame::new();

    // Create date column
    let dates = [
        "2023-01-01",
        "2023-01-02",
        "2023-01-03",
        "2023-01-04",
        "2023-01-05",
        "2023-01-06",
        "2023-01-07",
    ]
    .iter()
    .map(|s| s.to_string())
    .collect::<Vec<String>>();

    let date_col = StringColumn::new(dates);
    df.add_column("date", Column::String(date_col))?;

    // Create value column
    let values = vec![10.0, 20.0, 15.0, 30.0, 25.0, 40.0, 35.0];
    let value_col = Float64Column::new(values);
    df.add_column("value", Column::Float64(value_col))?;

    // Validation
    assert_eq!(df.row_count(), 7);
    assert!(df.contains_column("date"));
    assert!(df.contains_column("value"));

    // Note: Actual window operations need to be implemented in OptimizedDataFrame
    // Here we're only checking that the data is correctly set up

    // Check column access
    let value_col_view = df.column("value")?;
    if let Some(float_col) = value_col_view.as_float64() {
        // Check sum
        let sum = float_col.sum();
        assert_eq!(sum, 175.0);

        // Check mean
        let mean = float_col.mean().unwrap_or(0.0);
        assert!((mean - 25.0).abs() < 0.001);
    } else {
        panic!("Could not get value column as float64");
    }

    Ok(())
}

#[test]
#[allow(clippy::result_large_err)]
fn test_optimized_cumulative_operations() -> Result<()> {
    // Test to simulate cumulative operations
    let mut df = OptimizedDataFrame::new();

    // Create value column
    let values = vec![10.0, 20.0, 15.0, 30.0, 25.0];
    let value_col = Float64Column::new(values);
    df.add_column("value", Column::Float64(value_col))?;

    // Simulate cumulative sum (in actual implementation would be calculated with window operation)
    let mut cumsum = Vec::new();
    let mut running_sum = 0.0;

    // Get value column
    let value_col_view = df.column("value")?;
    if let Some(float_col) = value_col_view.as_float64() {
        for i in 0..float_col.len() {
            if let Ok(Some(val)) = float_col.get(i) {
                running_sum += val;
                cumsum.push(running_sum);
            }
        }
    }

    // Check expected values
    assert_eq!(cumsum, [10.0, 30.0, 45.0, 75.0, 100.0]);

    Ok(())
}