cudf 0.3.1

Safe Rust bindings for NVIDIA libcudf -- GPU-accelerated DataFrame operations
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
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

//! GPU-accelerated datetime extraction operations.
//!
//! Provides extraction of date/time components from timestamp [`Column`]s.
//!
//! # Examples
//!
//! ```rust,no_run
//! use cudf::Column;
//!
//! // Assuming `ts_col` is a timestamp column:
//! // let years = ts_col.extract_year().unwrap();
//! ```

use crate::column::Column;
use crate::error::{CudfError, Result};
use crate::scalar::Scalar;

impl Column {
    /// Extract year component from a timestamp column.
    pub fn extract_year(&self) -> Result<Column> {
        let raw =
            cudf_cxx::datetime::ffi::extract_year(&self.inner).map_err(CudfError::from_cxx)?;
        Ok(Column { inner: raw })
    }

    /// Extract month component (1-12) from a timestamp column.
    pub fn extract_month(&self) -> Result<Column> {
        let raw =
            cudf_cxx::datetime::ffi::extract_month(&self.inner).map_err(CudfError::from_cxx)?;
        Ok(Column { inner: raw })
    }

    /// Extract day component (1-31) from a timestamp column.
    pub fn extract_day(&self) -> Result<Column> {
        let raw = cudf_cxx::datetime::ffi::extract_day(&self.inner).map_err(CudfError::from_cxx)?;
        Ok(Column { inner: raw })
    }

    /// Extract hour component (0-23) from a timestamp column.
    pub fn extract_hour(&self) -> Result<Column> {
        let raw =
            cudf_cxx::datetime::ffi::extract_hour(&self.inner).map_err(CudfError::from_cxx)?;
        Ok(Column { inner: raw })
    }

    /// Extract minute component (0-59) from a timestamp column.
    pub fn extract_minute(&self) -> Result<Column> {
        let raw =
            cudf_cxx::datetime::ffi::extract_minute(&self.inner).map_err(CudfError::from_cxx)?;
        Ok(Column { inner: raw })
    }

    /// Extract second component (0-59) from a timestamp column.
    pub fn extract_second(&self) -> Result<Column> {
        let raw =
            cudf_cxx::datetime::ffi::extract_second(&self.inner).map_err(CudfError::from_cxx)?;
        Ok(Column { inner: raw })
    }

    /// Extract weekday (0=Monday, 6=Sunday) from a timestamp column.
    pub fn extract_weekday(&self) -> Result<Column> {
        let raw =
            cudf_cxx::datetime::ffi::extract_weekday(&self.inner).map_err(CudfError::from_cxx)?;
        Ok(Column { inner: raw })
    }

    /// Extract day-of-year (1-366) from a timestamp column.
    pub fn extract_day_of_year(&self) -> Result<Column> {
        let raw = cudf_cxx::datetime::ffi::extract_day_of_year(&self.inner)
            .map_err(CudfError::from_cxx)?;
        Ok(Column { inner: raw })
    }

    /// Get the last day of the month for each timestamp.
    pub fn last_day_of_month(&self) -> Result<Column> {
        let raw =
            cudf_cxx::datetime::ffi::last_day_of_month(&self.inner).map_err(CudfError::from_cxx)?;
        Ok(Column { inner: raw })
    }

    /// Add months (scalar) to each timestamp.
    pub fn add_calendrical_months_scalar(&self, months: &Scalar) -> Result<Column> {
        let raw =
            cudf_cxx::datetime::ffi::add_calendrical_months_scalar(&self.inner, &months.inner)
                .map_err(CudfError::from_cxx)?;
        Ok(Column { inner: raw })
    }

    /// Add months (per-row column) to each timestamp.
    pub fn add_calendrical_months_column(&self, months: &Column) -> Result<Column> {
        let raw =
            cudf_cxx::datetime::ffi::add_calendrical_months_column(&self.inner, &months.inner)
                .map_err(CudfError::from_cxx)?;
        Ok(Column { inner: raw })
    }

    /// Check if the year of each date is a leap year.
    pub fn is_leap_year(&self) -> Result<Column> {
        let raw =
            cudf_cxx::datetime::ffi::is_leap_year(&self.inner).map_err(CudfError::from_cxx)?;
        Ok(Column { inner: raw })
    }

    /// Get the number of days in the month for each date.
    pub fn days_in_month(&self) -> Result<Column> {
        let raw =
            cudf_cxx::datetime::ffi::days_in_month(&self.inner).map_err(CudfError::from_cxx)?;
        Ok(Column { inner: raw })
    }

    /// Extract the quarter (1-4) from each timestamp.
    pub fn extract_quarter(&self) -> Result<Column> {
        let raw =
            cudf_cxx::datetime::ffi::extract_quarter(&self.inner).map_err(CudfError::from_cxx)?;
        Ok(Column { inner: raw })
    }

    /// Ceil datetimes to the given frequency.
    ///
    /// `freq`: 0=DAY, 1=HOUR, 2=MINUTE, 3=SECOND, 4=MILLISECOND, 5=MICROSECOND, 6=NANOSECOND.
    pub fn ceil_datetimes(&self, freq: i32) -> Result<Column> {
        let raw = cudf_cxx::datetime::ffi::ceil_datetimes(&self.inner, freq)
            .map_err(CudfError::from_cxx)?;
        Ok(Column { inner: raw })
    }

    /// Floor datetimes to the given frequency.
    ///
    /// `freq`: 0=DAY, 1=HOUR, 2=MINUTE, 3=SECOND, 4=MILLISECOND, 5=MICROSECOND, 6=NANOSECOND.
    pub fn floor_datetimes(&self, freq: i32) -> Result<Column> {
        let raw = cudf_cxx::datetime::ffi::floor_datetimes(&self.inner, freq)
            .map_err(CudfError::from_cxx)?;
        Ok(Column { inner: raw })
    }

    /// Round datetimes to the nearest multiple of the given frequency.
    ///
    /// `freq`: 0=DAY, 1=HOUR, 2=MINUTE, 3=SECOND, 4=MILLISECOND, 5=MICROSECOND, 6=NANOSECOND.
    pub fn round_datetimes(&self, freq: i32) -> Result<Column> {
        let raw = cudf_cxx::datetime::ffi::round_datetimes(&self.inner, freq)
            .map_err(CudfError::from_cxx)?;
        Ok(Column { inner: raw })
    }
}