aggregation.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2019-2022, NVIDIA CORPORATION.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
 
#include <cudf/types.hpp>
 
#include <functional>
#include <memory>
#include <vector>
 
namespace cudf {
// forward declaration
namespace detail {
class simple_aggregations_collector;
class aggregation_finalizer;
}  // namespace detail
 
enum class rank_method : int32_t {
  FIRST,    
  AVERAGE,  
  MIN,      
  MAX,      
  DENSE     
};
 
enum class rank_percentage : int32_t {
  NONE,             
  ZERO_NORMALIZED,  
  ONE_NORMALIZED    
};
 
class aggregation {
 public:
  enum Kind {
    SUM,             
    PRODUCT,         
    MIN,             
    MAX,             
    COUNT_VALID,     
    COUNT_ALL,       
    ANY,             
    ALL,             
    SUM_OF_SQUARES,  
    MEAN,            
    M2,              
    VARIANCE,        
    STD,             
    MEDIAN,          
    QUANTILE,        
    ARGMAX,          
    ARGMIN,          
    NUNIQUE,         
    NTH_ELEMENT,     
    ROW_NUMBER,      
    RANK,            
    COLLECT_LIST,    
    COLLECT_SET,     
    LEAD,            
    LAG,             
    PTX,             
    CUDA,            
    MERGE_LISTS,     
    MERGE_SETS,      
    MERGE_M2,        
    COVARIANCE,      
    CORRELATION,     
    TDIGEST,         
    MERGE_TDIGEST    
  };
 
  aggregation() = delete;
 
  aggregation(aggregation::Kind a) : kind{a} {}
  Kind kind;  
  virtual ~aggregation() = default;
 
  [[nodiscard]] virtual bool is_equal(aggregation const& other) const { return kind == other.kind; }
 
  [[nodiscard]] virtual size_t do_hash() const { return std::hash<int>{}(kind); }
 
  [[nodiscard]] virtual std::unique_ptr<aggregation> clone() const = 0;
 
  // override functions for compound aggregations
  virtual std::vector<std::unique_ptr<aggregation>> get_simple_aggregations(
    data_type col_type, cudf::detail::simple_aggregations_collector& collector) const = 0;
 
  virtual void finalize(cudf::detail::aggregation_finalizer& finalizer) const = 0;
};
 
class rolling_aggregation : public virtual aggregation {
 public:
  ~rolling_aggregation() override = default;
 
 protected:
  rolling_aggregation() {}
  using aggregation::aggregation;
};
 
class groupby_aggregation : public virtual aggregation {
 public:
  ~groupby_aggregation() override = default;
 
 protected:
  groupby_aggregation() {}
};
 
class groupby_scan_aggregation : public virtual aggregation {
 public:
  ~groupby_scan_aggregation() override = default;
 
 protected:
  groupby_scan_aggregation() {}
};
 
class reduce_aggregation : public virtual aggregation {
 public:
  ~reduce_aggregation() override = default;
 
 protected:
  reduce_aggregation() {}
};
 
class scan_aggregation : public virtual aggregation {
 public:
  ~scan_aggregation() override = default;
 
 protected:
  scan_aggregation() {}
};
 
class segmented_reduce_aggregation : public virtual aggregation {
 public:
  ~segmented_reduce_aggregation() override = default;
 
 protected:
  segmented_reduce_aggregation() {}
};
 
enum class udf_type : bool { CUDA, PTX };
enum class correlation_type : int32_t { PEARSON, KENDALL, SPEARMAN };
 
template <typename Base = aggregation>
std::unique_ptr<Base> make_sum_aggregation();
 
template <typename Base = aggregation>
std::unique_ptr<Base> make_product_aggregation();
 
template <typename Base = aggregation>
std::unique_ptr<Base> make_min_aggregation();
 
template <typename Base = aggregation>
std::unique_ptr<Base> make_max_aggregation();
 
template <typename Base = aggregation>
std::unique_ptr<Base> make_count_aggregation(null_policy null_handling = null_policy::EXCLUDE);
 
template <typename Base = aggregation>
std::unique_ptr<Base> make_any_aggregation();
 
template <typename Base = aggregation>
std::unique_ptr<Base> make_all_aggregation();
 
template <typename Base = aggregation>
std::unique_ptr<Base> make_sum_of_squares_aggregation();
 
template <typename Base = aggregation>
std::unique_ptr<Base> make_mean_aggregation();
 
template <typename Base = aggregation>
std::unique_ptr<Base> make_m2_aggregation();
 
template <typename Base = aggregation>
std::unique_ptr<Base> make_variance_aggregation(size_type ddof = 1);
 
template <typename Base = aggregation>
std::unique_ptr<Base> make_std_aggregation(size_type ddof = 1);
 
template <typename Base = aggregation>
std::unique_ptr<Base> make_median_aggregation();
 
template <typename Base = aggregation>
std::unique_ptr<Base> make_quantile_aggregation(std::vector<double> const& quantiles,
                                                interpolation interp = interpolation::LINEAR);
 
template <typename Base = aggregation>
std::unique_ptr<Base> make_argmax_aggregation();
 
template <typename Base = aggregation>
std::unique_ptr<Base> make_argmin_aggregation();
 
template <typename Base = aggregation>
std::unique_ptr<Base> make_nunique_aggregation(null_policy null_handling = null_policy::EXCLUDE);
 
template <typename Base = aggregation>
std::unique_ptr<Base> make_nth_element_aggregation(
  size_type n, null_policy null_handling = null_policy::INCLUDE);
 
template <typename Base = aggregation>
std::unique_ptr<Base> make_row_number_aggregation();
 
template <typename Base = aggregation>
std::unique_ptr<Base> make_rank_aggregation(rank_method method,
                                            order column_order         = order::ASCENDING,
                                            null_policy null_handling  = null_policy::EXCLUDE,
                                            null_order null_precedence = null_order::AFTER,
                                            rank_percentage percentage = rank_percentage::NONE);
 
template <typename Base = aggregation>
std::unique_ptr<Base> make_collect_list_aggregation(
  null_policy null_handling = null_policy::INCLUDE);
 
template <typename Base = aggregation>
std::unique_ptr<Base> make_collect_set_aggregation(
  null_policy null_handling = null_policy::INCLUDE,
  null_equality nulls_equal = null_equality::EQUAL,
  nan_equality nans_equal   = nan_equality::ALL_EQUAL);
 
template <typename Base = aggregation>
std::unique_ptr<Base> make_lag_aggregation(size_type offset);
 
template <typename Base = aggregation>
std::unique_ptr<Base> make_lead_aggregation(size_type offset);
 
template <typename Base = aggregation>
std::unique_ptr<Base> make_udf_aggregation(udf_type type,
                                           std::string const& user_defined_aggregator,
                                           data_type output_type);
 
template <typename Base = aggregation>
std::unique_ptr<Base> make_merge_lists_aggregation();
 
template <typename Base = aggregation>
std::unique_ptr<Base> make_merge_sets_aggregation(
  null_equality nulls_equal = null_equality::EQUAL,
  nan_equality nans_equal   = nan_equality::ALL_EQUAL);
 
template <typename Base = aggregation>
std::unique_ptr<Base> make_merge_m2_aggregation();
 
template <typename Base = aggregation>
std::unique_ptr<Base> make_covariance_aggregation(size_type min_periods = 1, size_type ddof = 1);
 
template <typename Base = aggregation>
std::unique_ptr<Base> make_correlation_aggregation(correlation_type type,
                                                   size_type min_periods = 1);
 
template <typename Base>
std::unique_ptr<Base> make_tdigest_aggregation(int max_centroids = 1000);
 
template <typename Base>
std::unique_ptr<Base> make_merge_tdigest_aggregation(int max_centroids = 1000);
  // end of group
}  // namespace cudf