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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use super::*;
#[cfg(feature = "rolling_window")]
use crate::prelude::*;

#[cfg(feature = "rolling_window")]
macro_rules! invalid_operation {
    ($s:expr) => {
        Err(PolarsError::InvalidOperation(
            format!(
                "this operation is not implemented/valid for this dtype: {:?}",
                $s.ops_time_dtype()
            )
            .into(),
        ))
    };
}

pub trait SeriesOpsTime {
    fn ops_time_dtype(&self) -> &DataType;

    /// Apply a rolling mean to a Series. See:
    /// [ChunkedArray::rolling_mean](crate::prelude::ChunkWindow::rolling_mean).
    #[cfg(feature = "rolling_window")]
    fn rolling_mean(&self, _options: RollingOptionsImpl) -> PolarsResult<Series> {
        invalid_operation!(self)
    }
    /// Apply a rolling sum to a Series.
    #[cfg(feature = "rolling_window")]
    fn rolling_sum(&self, _options: RollingOptionsImpl) -> PolarsResult<Series> {
        invalid_operation!(self)
    }
    /// Apply a rolling median to a Series.
    #[cfg(feature = "rolling_window")]
    fn rolling_median(&self, _options: RollingOptionsImpl) -> PolarsResult<Series> {
        invalid_operation!(self)
    }
    /// Apply a rolling quantile to a Series.
    #[cfg(feature = "rolling_window")]
    fn rolling_quantile(
        &self,
        _quantile: f64,
        _interpolation: QuantileInterpolOptions,
        _options: RollingOptionsImpl,
    ) -> PolarsResult<Series> {
        invalid_operation!(self)
    }

    /// Apply a rolling min to a Series.
    #[cfg(feature = "rolling_window")]
    fn rolling_min(&self, _options: RollingOptionsImpl) -> PolarsResult<Series> {
        invalid_operation!(self)
    }
    /// Apply a rolling max to a Series.
    #[cfg(feature = "rolling_window")]
    fn rolling_max(&self, _options: RollingOptionsImpl) -> PolarsResult<Series> {
        invalid_operation!(self)
    }

    /// Apply a rolling variance to a Series.
    #[cfg(feature = "rolling_window")]
    fn rolling_var(&self, _options: RollingOptionsImpl) -> PolarsResult<Series> {
        invalid_operation!(self)
    }

    /// Apply a rolling std_dev to a Series.
    #[cfg(feature = "rolling_window")]
    fn rolling_std(&self, _options: RollingOptionsImpl) -> PolarsResult<Series> {
        invalid_operation!(self)
    }
}

impl SeriesOpsTime for Series {
    fn ops_time_dtype(&self) -> &DataType {
        self.deref().dtype()
    }
    #[cfg(feature = "rolling_window")]
    fn rolling_mean(&self, _options: RollingOptionsImpl) -> PolarsResult<Series> {
        self.to_ops().rolling_mean(_options)
    }
    #[cfg(feature = "rolling_window")]
    fn rolling_sum(&self, _options: RollingOptionsImpl) -> PolarsResult<Series> {
        self.to_ops().rolling_sum(_options)
    }
    #[cfg(feature = "rolling_window")]
    fn rolling_median(&self, _options: RollingOptionsImpl) -> PolarsResult<Series> {
        self.to_ops().rolling_median(_options)
    }
    /// Apply a rolling quantile to a Series.
    #[cfg(feature = "rolling_window")]
    fn rolling_quantile(
        &self,
        quantile: f64,
        interpolation: QuantileInterpolOptions,
        options: RollingOptionsImpl,
    ) -> PolarsResult<Series> {
        self.to_ops()
            .rolling_quantile(quantile, interpolation, options)
    }

    #[cfg(feature = "rolling_window")]
    fn rolling_min(&self, options: RollingOptionsImpl) -> PolarsResult<Series> {
        self.to_ops().rolling_min(options)
    }
    /// Apply a rolling max to a Series.
    #[cfg(feature = "rolling_window")]
    fn rolling_max(&self, options: RollingOptionsImpl) -> PolarsResult<Series> {
        self.to_ops().rolling_max(options)
    }

    /// Apply a rolling variance to a Series.
    #[cfg(feature = "rolling_window")]
    fn rolling_var(&self, options: RollingOptionsImpl) -> PolarsResult<Series> {
        self.to_ops().rolling_var(options)
    }

    /// Apply a rolling std_dev to a Series.
    #[cfg(feature = "rolling_window")]
    fn rolling_std(&self, options: RollingOptionsImpl) -> PolarsResult<Series> {
        self.to_ops().rolling_std(options)
    }
}