cudf-cxx 0.2.0

cxx-based FFI bridge between Rust and NVIDIA libcudf C++ API
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

#include "aggregation_shim.h"
#include <cudf/aggregation.hpp>

namespace cudf_shims {

namespace {

/// Helper: downcast a generic aggregation unique_ptr to groupby_aggregation.
/// libcudf's make_*_aggregation<groupby_aggregation>() returns the correct type directly.
template <typename T>
std::unique_ptr<OwnedAggregation> wrap(std::unique_ptr<T> agg) {
    // The aggregation is already a groupby_aggregation due to the template parameter.
    return std::make_unique<OwnedAggregation>(std::move(agg));
}

cudf::null_policy to_null_policy(int32_t v) {
    return v == 0 ? cudf::null_policy::EXCLUDE : cudf::null_policy::INCLUDE;
}

} // anonymous namespace

std::unique_ptr<OwnedAggregation> agg_sum() {
    return wrap(cudf::make_sum_aggregation<cudf::groupby_aggregation>());
}

std::unique_ptr<OwnedAggregation> agg_product() {
    return wrap(cudf::make_product_aggregation<cudf::groupby_aggregation>());
}

std::unique_ptr<OwnedAggregation> agg_min() {
    return wrap(cudf::make_min_aggregation<cudf::groupby_aggregation>());
}

std::unique_ptr<OwnedAggregation> agg_max() {
    return wrap(cudf::make_max_aggregation<cudf::groupby_aggregation>());
}

std::unique_ptr<OwnedAggregation> agg_count(int32_t null_handling) {
    return wrap(cudf::make_count_aggregation<cudf::groupby_aggregation>(
        to_null_policy(null_handling)));
}

std::unique_ptr<OwnedAggregation> agg_any() {
    throw std::runtime_error(
        "any is not supported as a groupby aggregation in this libcudf version. "
        "Use reduce aggregation instead.");
}

std::unique_ptr<OwnedAggregation> agg_all() {
    throw std::runtime_error(
        "all is not supported as a groupby aggregation in this libcudf version. "
        "Use reduce aggregation instead.");
}

std::unique_ptr<OwnedAggregation> agg_sum_of_squares() {
    return wrap(cudf::make_sum_of_squares_aggregation<cudf::groupby_aggregation>());
}

std::unique_ptr<OwnedAggregation> agg_mean() {
    return wrap(cudf::make_mean_aggregation<cudf::groupby_aggregation>());
}

std::unique_ptr<OwnedAggregation> agg_median() {
    return wrap(cudf::make_median_aggregation<cudf::groupby_aggregation>());
}

std::unique_ptr<OwnedAggregation> agg_variance(int32_t ddof) {
    return wrap(cudf::make_variance_aggregation<cudf::groupby_aggregation>(
        static_cast<cudf::size_type>(ddof)));
}

std::unique_ptr<OwnedAggregation> agg_std(int32_t ddof) {
    return wrap(cudf::make_std_aggregation<cudf::groupby_aggregation>(
        static_cast<cudf::size_type>(ddof)));
}

std::unique_ptr<OwnedAggregation> agg_nunique(int32_t null_handling) {
    return wrap(cudf::make_nunique_aggregation<cudf::groupby_aggregation>(
        to_null_policy(null_handling)));
}

std::unique_ptr<OwnedAggregation> agg_nth_element(int32_t n, int32_t null_handling) {
    return wrap(cudf::make_nth_element_aggregation<cudf::groupby_aggregation>(
        static_cast<cudf::size_type>(n),
        to_null_policy(null_handling)));
}

std::unique_ptr<OwnedAggregation> agg_collect_list(int32_t null_handling) {
    return wrap(cudf::make_collect_list_aggregation<cudf::groupby_aggregation>(
        to_null_policy(null_handling)));
}

std::unique_ptr<OwnedAggregation> agg_collect_set(int32_t null_handling) {
    return wrap(cudf::make_collect_set_aggregation<cudf::groupby_aggregation>(
        to_null_policy(null_handling)));
}

std::unique_ptr<OwnedAggregation> agg_argmax() {
    return wrap(cudf::make_argmax_aggregation<cudf::groupby_aggregation>());
}

std::unique_ptr<OwnedAggregation> agg_argmin() {
    return wrap(cudf::make_argmin_aggregation<cudf::groupby_aggregation>());
}

std::unique_ptr<OwnedAggregation> agg_row_number() {
    throw std::runtime_error(
        "row_number is a scan-only aggregation and cannot be used with groupby aggregate. "
        "Use GroupByScan instead.");
}

std::unique_ptr<OwnedAggregation> agg_quantile(double q) {
    return wrap(cudf::make_quantile_aggregation<cudf::groupby_aggregation>(
        {q}, cudf::interpolation::LINEAR));
}

std::unique_ptr<OwnedAggregation> agg_lag(int32_t offset) {
    throw std::runtime_error(
        "lag is a scan-only aggregation and cannot be used with groupby aggregate. "
        "Use GroupByScan instead.");
}

std::unique_ptr<OwnedAggregation> agg_lead(int32_t offset) {
    throw std::runtime_error(
        "lead is a scan-only aggregation and cannot be used with groupby aggregate. "
        "Use GroupByScan instead.");
}

} // namespace cudf_shims