From 6f6df6df85ca47da1f9fbc969d51f149d1640b44 Mon Sep 17 00:00:00 2001 From: Karthikeyan Natarajan Date: Thu, 19 May 2022 00:37:51 +0530 Subject: [PATCH 1/4] fix doxygen warnings in aggregation.hpp --- cpp/include/cudf/aggregation.hpp | 100 +++++++++++++++++++++++++++---- 1 file changed, 90 insertions(+), 10 deletions(-) diff --git a/cpp/include/cudf/aggregation.hpp b/cpp/include/cudf/aggregation.hpp index 5c7513a6c99..c3bd7932065 100644 --- a/cpp/include/cudf/aggregation.hpp +++ b/cpp/include/cudf/aggregation.hpp @@ -120,18 +120,56 @@ class aggregation { }; aggregation() = delete; + + /** + * @brief Construct a new aggregation object + * + * @param a aggregation::Kind enum value + */ aggregation(aggregation::Kind a) : kind{a} {} Kind kind; ///< The aggregation to perform virtual ~aggregation() = default; + /** + * @brief Compares two aggregation objects for equality + * + * @param other The other aggregation to compare with + * @return True if the two aggregations are equal + */ [[nodiscard]] virtual bool is_equal(aggregation const& other) const { return kind == other.kind; } + + /** + * @brief Computes the hash value of the aggregation + * + * @return The hash value of the aggregation + */ [[nodiscard]] virtual size_t do_hash() const { return std::hash{}(kind); } + + /** + * @pure @brief Clones the aggregation object + * + * @return A copy of the aggregation object + */ [[nodiscard]] virtual std::unique_ptr clone() const = 0; // override functions for compound aggregations + /** + * @pure @brief Get the simple aggregations that this aggregation requires to compute. + * + * @param col_type The type of the column to aggregate + * @param collector The collector visitor pattern to use to collect the simple aggregations + * @return Vector of pre-requisite simple aggregations + */ virtual std::vector> 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; + + /** + * @pure @brief Compute the aggregation after pre-requisite simple aggregations have been + * computed. + * + * @param finalizer The finalizer visitor pattern to use to compute the aggregation + */ + virtual void finalize(cudf::detail::aggregation_finalizer& finalizer) const = 0; }; /** @@ -147,7 +185,8 @@ class rolling_aggregation : public virtual aggregation { protected: rolling_aggregation() {} - rolling_aggregation(aggregation::Kind a) : aggregation{a} {} + /// constructor inherited from cudf::aggregation + using aggregation::aggregation; }; /** @@ -205,22 +244,28 @@ class segmented_reduce_aggregation : public virtual aggregation { segmented_reduce_aggregation() {} }; +/// Type of code in the user defined function string. enum class udf_type : bool { CUDA, PTX }; +/// Type of correlation method. enum class correlation_type : int32_t { PEARSON, KENDALL, SPEARMAN }; /// Factory to create a SUM aggregation +/// @return A pointer to a new SUM aggregation template std::unique_ptr make_sum_aggregation(); /// Factory to create a PRODUCT aggregation +/// @return A pointer to a new PRODUCT aggregation template std::unique_ptr make_product_aggregation(); /// Factory to create a MIN aggregation +/// @return A pointer to a new MIN aggregation template std::unique_ptr make_min_aggregation(); /// Factory to create a MAX aggregation +/// @return A pointer to a new MAX aggregation template std::unique_ptr make_max_aggregation(); @@ -228,23 +273,28 @@ std::unique_ptr make_max_aggregation(); * @brief Factory to create a COUNT aggregation * * @param null_handling Indicates if null values will be counted. + * @return A pointer to a new COUNT aggregation */ template std::unique_ptr make_count_aggregation(null_policy null_handling = null_policy::EXCLUDE); /// Factory to create an ANY aggregation +/// @return A pointer to a new ANY aggregation template std::unique_ptr make_any_aggregation(); /// Factory to create a ALL aggregation +/// @return A pointer to a new ALL aggregation template std::unique_ptr make_all_aggregation(); /// Factory to create a SUM_OF_SQUARES aggregation +/// @return A pointer to a new SUM_OF_SQUARES aggregation template std::unique_ptr make_sum_of_squares_aggregation(); /// Factory to create a MEAN aggregation +/// @return A pointer to a new MEAN aggregation template std::unique_ptr make_mean_aggregation(); @@ -258,6 +308,7 @@ std::unique_ptr make_mean_aggregation(); * deviation across multiple discrete sets. See * `https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Parallel_algorithm` for more * detail. + * @return A pointer to a new M2 aggregation */ template std::unique_ptr make_m2_aggregation(); @@ -269,6 +320,7 @@ std::unique_ptr make_m2_aggregation(); * `variance` is `N - ddof`, where `N` is the population size. * * @throw cudf::logic_error if input type is chrono or compound types. + * @return A pointer to a new VARIANCE aggregation */ template std::unique_ptr make_variance_aggregation(size_type ddof = 1); @@ -280,11 +332,13 @@ std::unique_ptr make_variance_aggregation(size_type ddof = 1); * `std` is `N - ddof`, where `N` is the population size. * * @throw cudf::logic_error if input type is chrono or compound types. + * @return A pointer to a new STD aggregation */ template std::unique_ptr make_std_aggregation(size_type ddof = 1); /// Factory to create a MEDIAN aggregation +/// @return A pointer to a new MEDIAN aggregation template std::unique_ptr make_median_aggregation(); @@ -293,23 +347,26 @@ std::unique_ptr make_median_aggregation(); * * @param quantiles The desired quantiles * @param interp The desired interpolation + * @return A pointer to a new QUANTILE aggregation */ template std::unique_ptr make_quantile_aggregation(std::vector const& quantiles, interpolation interp = interpolation::LINEAR); /** - * @brief Factory to create an `argmax` aggregation + * @brief Factory to create an ARGMAX aggregation * - * `argmax` returns the index of the maximum element. + * ARGMAX returns the index of the maximum element. + * @return A pointer to a new ARGMAX aggregation */ template std::unique_ptr make_argmax_aggregation(); /** - * @brief Factory to create an `argmin` aggregation + * @brief Factory to create an ARGMIN aggregation * * `argmin` returns the index of the minimum element. + * @return A pointer to a new ARGMIN aggregation */ template std::unique_ptr make_argmin_aggregation(); @@ -319,6 +376,7 @@ std::unique_ptr make_argmin_aggregation(); * * `nunique` returns the number of unique elements. * @param null_handling Indicates if null values will be counted. + * @return A pointer to a new `nunique` aggregation */ template std::unique_ptr make_nunique_aggregation(null_policy null_handling = null_policy::EXCLUDE); @@ -335,12 +393,14 @@ std::unique_ptr make_nunique_aggregation(null_policy null_handling = null_ * * @param n index of nth element in each group. * @param null_handling Indicates to include/exclude nulls during indexing. + * @return A pointer to a new `nth_element` aggregation */ template std::unique_ptr make_nth_element_aggregation( size_type n, null_policy null_handling = null_policy::INCLUDE); /// Factory to create a ROW_NUMBER aggregation +/// @return A pointer to a new ROW_NUMBER aggregation template std::unique_ptr make_row_number_aggregation(); @@ -414,6 +474,7 @@ std::unique_ptr make_row_number_aggregation(); * the corresponding rank will be null. * @param null_precedence The desired order of null compared to other elements for column * @param percentage enum to denote the type of conversion of ranks to percentage in range (0,1] + * @return A pointer to a new RANK aggregation */ template std::unique_ptr make_rank_aggregation(rank_method method, @@ -431,6 +492,7 @@ std::unique_ptr make_rank_aggregation(rank_method method, * of the list rows. * * @param null_handling Indicates whether to include/exclude nulls in list elements. + * @return A pointer to a new COLLECT_LIST aggregation */ template std::unique_ptr make_collect_list_aggregation( @@ -450,17 +512,28 @@ std::unique_ptr make_collect_list_aggregation( * equal. * @param nans_equal Flag to specify whether NaN values in floating point column should be * considered equal. + * @return A pointer to a new COLLECT_SET aggregation */ template std::unique_ptr make_collect_set_aggregation(null_policy null_handling = null_policy::INCLUDE, null_equality nulls_equal = null_equality::EQUAL, nan_equality nans_equal = nan_equality::UNEQUAL); -/// Factory to create a LAG aggregation +/** + * @brief Factory to create a LAG aggregation + * + * @param offset The number of rows to lag the input + * @return A pointer to a new LAG aggregation + */ template std::unique_ptr make_lag_aggregation(size_type offset); -/// Factory to create a LEAD aggregation +/** + * @brief Factory to create a LEAD aggregation + * + * @param offset The number of rows to lead the input + * @return A pointer to a new LEAD aggregation + */ template std::unique_ptr make_lead_aggregation(size_type offset); @@ -471,7 +544,7 @@ std::unique_ptr make_lead_aggregation(size_type offset); * @param[in] user_defined_aggregator A string containing the aggregator code * @param[in] output_type expected output type * - * @return aggregation unique pointer housing user_defined_aggregator string. + * @return Aggregation unique pointer housing user_defined_aggregator string. */ template std::unique_ptr make_udf_aggregation(udf_type type, @@ -486,6 +559,8 @@ std::unique_ptr make_udf_aggregation(udf_type type, * groupby `COLLECT_LIST` aggregations into a final `COLLECT_LIST` result. As such, it requires the * input lists column to be non-nullable (the child column containing list entries is not subjected * to this requirement). + * + * @return A pointer to a new MERGE_LISTS aggregation */ template std::unique_ptr make_merge_lists_aggregation(); @@ -510,6 +585,7 @@ std::unique_ptr make_merge_lists_aggregation(); * during dropping duplicate list entries. * @param nans_equal Flag to specify whether NaN values in floating point column should be * considered equal during dropping duplicate list entries. + * @return A pointer to a new MERGE_SETS aggregation */ template std::unique_ptr make_merge_sets_aggregation(null_equality nulls_equal = null_equality::EQUAL, @@ -526,6 +602,8 @@ std::unique_ptr make_merge_sets_aggregation(null_equality nulls_equal = nu * * The input `M2` aggregation values are expected to be all non-negative numbers, since they * were output from `M2` aggregation. + * + * @return A pointer to a new MERGE_M2 aggregation */ template std::unique_ptr make_merge_m2_aggregation(); @@ -538,6 +616,7 @@ std::unique_ptr make_merge_m2_aggregation(); * @param min_periods Minimum number of non-null observations required to produce a result. * @param ddof Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N is * the number of non-null observations. + * @return A pointer to a new COVARIANCE aggregation */ template std::unique_ptr make_covariance_aggregation(size_type min_periods = 1, size_type ddof = 1); @@ -550,6 +629,7 @@ std::unique_ptr make_covariance_aggregation(size_type min_periods = 1, siz * * @param type correlation_type * @param min_periods Minimum number of non-null observations required to produce a result. + * @return A pointer to a new CORRELATION aggregation */ template std::unique_ptr make_correlation_aggregation(correlation_type type, @@ -587,7 +667,7 @@ std::unique_ptr make_correlation_aggregation(correlation_type type, * the computed tdigests: A value of 1000 will result in a tdigest containing no * more than 1000 centroids (32 bytes each). Higher result in more accurate tdigest information. * - * @returns A TDIGEST aggregation object. + * @return A pointer to a new TDIGEST aggregation */ template std::unique_ptr make_tdigest_aggregation(int max_centroids = 1000); @@ -625,7 +705,7 @@ std::unique_ptr make_tdigest_aggregation(int max_centroids = 1000); * the computed tdigests: A value of 1000 will result in a tdigest containing no * more than 1000 centroids (32 bytes each). Higher result in more accurate tdigest information. * - * @returns A MERGE_TDIGEST aggregation object. + * @return A MERGE_TDIGEST aggregation object. */ template std::unique_ptr make_merge_tdigest_aggregation(int max_centroids = 1000); From 7554610f9389fb51f17bb8b547da7034022d5d6c Mon Sep 17 00:00:00 2001 From: Karthikeyan Natarajan Date: Sat, 21 May 2022 21:10:58 +0530 Subject: [PATCH 2/4] address review comments (davidwendt) --- cpp/include/cudf/aggregation.hpp | 72 ++++++++++++++++---------------- 1 file changed, 36 insertions(+), 36 deletions(-) diff --git a/cpp/include/cudf/aggregation.hpp b/cpp/include/cudf/aggregation.hpp index c3bd7932065..e004e4092e9 100644 --- a/cpp/include/cudf/aggregation.hpp +++ b/cpp/include/cudf/aggregation.hpp @@ -250,22 +250,22 @@ enum class udf_type : bool { CUDA, PTX }; enum class correlation_type : int32_t { PEARSON, KENDALL, SPEARMAN }; /// Factory to create a SUM aggregation -/// @return A pointer to a new SUM aggregation +/// @return A SUM aggregation object template std::unique_ptr make_sum_aggregation(); /// Factory to create a PRODUCT aggregation -/// @return A pointer to a new PRODUCT aggregation +/// @return A PRODUCT aggregation object template std::unique_ptr make_product_aggregation(); /// Factory to create a MIN aggregation -/// @return A pointer to a new MIN aggregation +/// @return A MIN aggregation object template std::unique_ptr make_min_aggregation(); /// Factory to create a MAX aggregation -/// @return A pointer to a new MAX aggregation +/// @return A MAX aggregation object template std::unique_ptr make_max_aggregation(); @@ -273,28 +273,28 @@ std::unique_ptr make_max_aggregation(); * @brief Factory to create a COUNT aggregation * * @param null_handling Indicates if null values will be counted. - * @return A pointer to a new COUNT aggregation + * @return A COUNT aggregation object */ template std::unique_ptr make_count_aggregation(null_policy null_handling = null_policy::EXCLUDE); /// Factory to create an ANY aggregation -/// @return A pointer to a new ANY aggregation +/// @return A ANY aggregation object template std::unique_ptr make_any_aggregation(); /// Factory to create a ALL aggregation -/// @return A pointer to a new ALL aggregation +/// @return A ALL aggregation object template std::unique_ptr make_all_aggregation(); /// Factory to create a SUM_OF_SQUARES aggregation -/// @return A pointer to a new SUM_OF_SQUARES aggregation +/// @return A SUM_OF_SQUARES aggregation object template std::unique_ptr make_sum_of_squares_aggregation(); /// Factory to create a MEAN aggregation -/// @return A pointer to a new MEAN aggregation +/// @return A MEAN aggregation object template std::unique_ptr make_mean_aggregation(); @@ -308,7 +308,7 @@ std::unique_ptr make_mean_aggregation(); * deviation across multiple discrete sets. See * `https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Parallel_algorithm` for more * detail. - * @return A pointer to a new M2 aggregation + * @return A M2 aggregation object */ template std::unique_ptr make_m2_aggregation(); @@ -320,7 +320,7 @@ std::unique_ptr make_m2_aggregation(); * `variance` is `N - ddof`, where `N` is the population size. * * @throw cudf::logic_error if input type is chrono or compound types. - * @return A pointer to a new VARIANCE aggregation + * @return A VARIANCE aggregation object */ template std::unique_ptr make_variance_aggregation(size_type ddof = 1); @@ -332,13 +332,13 @@ std::unique_ptr make_variance_aggregation(size_type ddof = 1); * `std` is `N - ddof`, where `N` is the population size. * * @throw cudf::logic_error if input type is chrono or compound types. - * @return A pointer to a new STD aggregation + * @return A STD aggregation object */ template std::unique_ptr make_std_aggregation(size_type ddof = 1); /// Factory to create a MEDIAN aggregation -/// @return A pointer to a new MEDIAN aggregation +/// @return A MEDIAN aggregation object template std::unique_ptr make_median_aggregation(); @@ -347,7 +347,7 @@ std::unique_ptr make_median_aggregation(); * * @param quantiles The desired quantiles * @param interp The desired interpolation - * @return A pointer to a new QUANTILE aggregation + * @return A QUANTILE aggregation object */ template std::unique_ptr make_quantile_aggregation(std::vector const& quantiles, @@ -357,7 +357,7 @@ std::unique_ptr make_quantile_aggregation(std::vector const& quant * @brief Factory to create an ARGMAX aggregation * * ARGMAX returns the index of the maximum element. - * @return A pointer to a new ARGMAX aggregation + * @return A ARGMAX aggregation object */ template std::unique_ptr make_argmax_aggregation(); @@ -366,25 +366,25 @@ std::unique_ptr make_argmax_aggregation(); * @brief Factory to create an ARGMIN aggregation * * `argmin` returns the index of the minimum element. - * @return A pointer to a new ARGMIN aggregation + * @return A ARGMIN aggregation object */ template std::unique_ptr make_argmin_aggregation(); /** - * @brief Factory to create a `nunique` aggregation + * @brief Factory to create a NUNIQUE aggregation * - * `nunique` returns the number of unique elements. + * NUNIQUE returns the number of unique elements. * @param null_handling Indicates if null values will be counted. - * @return A pointer to a new `nunique` aggregation + * @return A NUNIQUE aggregation object */ template std::unique_ptr make_nunique_aggregation(null_policy null_handling = null_policy::EXCLUDE); /** - * @brief Factory to create a `nth_element` aggregation + * @brief Factory to create a NTH_ELEMENT aggregation * - * `nth_element` returns the n'th element of the group/series. + * NTH_ELEMENT returns the n'th element of the group/series. * * If @p n is not within the range `[-group_size, group_size)`, the result of * the respective group will be null. Negative indices `[-group_size, -1]` @@ -393,14 +393,14 @@ std::unique_ptr make_nunique_aggregation(null_policy null_handling = null_ * * @param n index of nth element in each group. * @param null_handling Indicates to include/exclude nulls during indexing. - * @return A pointer to a new `nth_element` aggregation + * @return A NTH_ELEMENT aggregation object */ template std::unique_ptr make_nth_element_aggregation( size_type n, null_policy null_handling = null_policy::INCLUDE); /// Factory to create a ROW_NUMBER aggregation -/// @return A pointer to a new ROW_NUMBER aggregation +/// @return A ROW_NUMBER aggregation object template std::unique_ptr make_row_number_aggregation(); @@ -474,7 +474,7 @@ std::unique_ptr make_row_number_aggregation(); * the corresponding rank will be null. * @param null_precedence The desired order of null compared to other elements for column * @param percentage enum to denote the type of conversion of ranks to percentage in range (0,1] - * @return A pointer to a new RANK aggregation + * @return A RANK aggregation object */ template std::unique_ptr make_rank_aggregation(rank_method method, @@ -492,7 +492,7 @@ std::unique_ptr make_rank_aggregation(rank_method method, * of the list rows. * * @param null_handling Indicates whether to include/exclude nulls in list elements. - * @return A pointer to a new COLLECT_LIST aggregation + * @return A COLLECT_LIST aggregation object */ template std::unique_ptr make_collect_list_aggregation( @@ -512,7 +512,7 @@ std::unique_ptr make_collect_list_aggregation( * equal. * @param nans_equal Flag to specify whether NaN values in floating point column should be * considered equal. - * @return A pointer to a new COLLECT_SET aggregation + * @return A COLLECT_SET aggregation object */ template std::unique_ptr make_collect_set_aggregation(null_policy null_handling = null_policy::INCLUDE, @@ -523,7 +523,7 @@ std::unique_ptr make_collect_set_aggregation(null_policy null_handling = n * @brief Factory to create a LAG aggregation * * @param offset The number of rows to lag the input - * @return A pointer to a new LAG aggregation + * @return A LAG aggregation object */ template std::unique_ptr make_lag_aggregation(size_type offset); @@ -532,7 +532,7 @@ std::unique_ptr make_lag_aggregation(size_type offset); * @brief Factory to create a LEAD aggregation * * @param offset The number of rows to lead the input - * @return A pointer to a new LEAD aggregation + * @return A LEAD aggregation object */ template std::unique_ptr make_lead_aggregation(size_type offset); @@ -544,7 +544,7 @@ std::unique_ptr make_lead_aggregation(size_type offset); * @param[in] user_defined_aggregator A string containing the aggregator code * @param[in] output_type expected output type * - * @return Aggregation unique pointer housing user_defined_aggregator string. + * @return An aggregation containing a user-defined aggregator string */ template std::unique_ptr make_udf_aggregation(udf_type type, @@ -560,7 +560,7 @@ std::unique_ptr make_udf_aggregation(udf_type type, * input lists column to be non-nullable (the child column containing list entries is not subjected * to this requirement). * - * @return A pointer to a new MERGE_LISTS aggregation + * @return A MERGE_LISTS aggregation object */ template std::unique_ptr make_merge_lists_aggregation(); @@ -585,7 +585,7 @@ std::unique_ptr make_merge_lists_aggregation(); * during dropping duplicate list entries. * @param nans_equal Flag to specify whether NaN values in floating point column should be * considered equal during dropping duplicate list entries. - * @return A pointer to a new MERGE_SETS aggregation + * @return A MERGE_SETS aggregation object */ template std::unique_ptr make_merge_sets_aggregation(null_equality nulls_equal = null_equality::EQUAL, @@ -603,7 +603,7 @@ std::unique_ptr make_merge_sets_aggregation(null_equality nulls_equal = nu * The input `M2` aggregation values are expected to be all non-negative numbers, since they * were output from `M2` aggregation. * - * @return A pointer to a new MERGE_M2 aggregation + * @return A MERGE_M2 aggregation object */ template std::unique_ptr make_merge_m2_aggregation(); @@ -616,7 +616,7 @@ std::unique_ptr make_merge_m2_aggregation(); * @param min_periods Minimum number of non-null observations required to produce a result. * @param ddof Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N is * the number of non-null observations. - * @return A pointer to a new COVARIANCE aggregation + * @return A COVARIANCE aggregation object */ template std::unique_ptr make_covariance_aggregation(size_type min_periods = 1, size_type ddof = 1); @@ -629,7 +629,7 @@ std::unique_ptr make_covariance_aggregation(size_type min_periods = 1, siz * * @param type correlation_type * @param min_periods Minimum number of non-null observations required to produce a result. - * @return A pointer to a new CORRELATION aggregation + * @return A CORRELATION aggregation object */ template std::unique_ptr make_correlation_aggregation(correlation_type type, @@ -667,7 +667,7 @@ std::unique_ptr make_correlation_aggregation(correlation_type type, * the computed tdigests: A value of 1000 will result in a tdigest containing no * more than 1000 centroids (32 bytes each). Higher result in more accurate tdigest information. * - * @return A pointer to a new TDIGEST aggregation + * @return A TDIGEST aggregation object */ template std::unique_ptr make_tdigest_aggregation(int max_centroids = 1000); @@ -705,7 +705,7 @@ std::unique_ptr make_tdigest_aggregation(int max_centroids = 1000); * the computed tdigests: A value of 1000 will result in a tdigest containing no * more than 1000 centroids (32 bytes each). Higher result in more accurate tdigest information. * - * @return A MERGE_TDIGEST aggregation object. + * @return A MERGE_TDIGEST aggregation object */ template std::unique_ptr make_merge_tdigest_aggregation(int max_centroids = 1000); From 9c5aeba3ae3e870cbf56966856f8682cc90fd0a4 Mon Sep 17 00:00:00 2001 From: Karthikeyan Natarajan Date: Sat, 21 May 2022 21:13:37 +0530 Subject: [PATCH 3/4] remove "pointer to" for unique_ptr at few places --- cpp/include/cudf/concatenate.hpp | 10 +++++----- cpp/include/cudf/reduction.hpp | 2 +- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/cpp/include/cudf/concatenate.hpp b/cpp/include/cudf/concatenate.hpp index 182cbbdc3ec..a3d1b7b11fe 100644 --- a/cpp/include/cudf/concatenate.hpp +++ b/cpp/include/cudf/concatenate.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021, NVIDIA CORPORATION. + * Copyright (c) 2020-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. @@ -53,8 +53,8 @@ rmm::device_buffer concatenate_masks( * * @param columns_to_concat host_span of column views to be concatenated into a single column * @param mr Device memory resource used to allocate the returned column's device memory. - * @return Unique pointer to a single table having all the rows from the - * elements of `columns_to_concat` respectively in the same order. + * @return A single column having all the rows from the elements of `columns_to_concat` respectively + * in the same order. */ std::unique_ptr concatenate( host_span columns_to_concat, @@ -83,8 +83,8 @@ std::unique_ptr concatenate( * * @param tables_to_concat host_span of table views to be concatenated into a single table * @param mr Device memory resource used to allocate the returned table's device memory. - * @return Unique pointer to a single table having all the rows from the - * elements of `tables_to_concat` respectively in the same order. + * @return A single table having all the rows from the elements of `tables_to_concat` respectively + * in the same order. */ std::unique_ptr concatenate( host_span tables_to_concat, diff --git a/cpp/include/cudf/reduction.hpp b/cpp/include/cudf/reduction.hpp index f140ba7d4a9..36ae7b1668c 100644 --- a/cpp/include/cudf/reduction.hpp +++ b/cpp/include/cudf/reduction.hpp @@ -138,7 +138,7 @@ std::unique_ptr segmented_reduce( * null_policy::EXCLUDE. Include nulls if null_policy::INCLUDE. * Any operation with a null results in a null. * @param[in] mr Device memory resource used to allocate the returned scalar's device memory - * @returns unique pointer to new output column + * @returns Scanned output column */ std::unique_ptr scan( const column_view& input, From 6812959b4d6424f411512480d6b5f3d7b77a145f Mon Sep 17 00:00:00 2001 From: Karthikeyan Natarajan Date: Wed, 25 May 2022 01:37:00 +0530 Subject: [PATCH 4/4] remove dot at end of param, return --- cpp/include/cudf/aggregation.hpp | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/cpp/include/cudf/aggregation.hpp b/cpp/include/cudf/aggregation.hpp index e004e4092e9..a26a0c7947b 100644 --- a/cpp/include/cudf/aggregation.hpp +++ b/cpp/include/cudf/aggregation.hpp @@ -272,7 +272,7 @@ std::unique_ptr make_max_aggregation(); /** * @brief Factory to create a COUNT aggregation * - * @param null_handling Indicates if null values will be counted. + * @param null_handling Indicates if null values will be counted * @return A COUNT aggregation object */ template @@ -375,7 +375,7 @@ std::unique_ptr make_argmin_aggregation(); * @brief Factory to create a NUNIQUE aggregation * * NUNIQUE returns the number of unique elements. - * @param null_handling Indicates if null values will be counted. + * @param null_handling Indicates if null values will be counted * @return A NUNIQUE aggregation object */ template @@ -391,8 +391,8 @@ std::unique_ptr make_nunique_aggregation(null_policy null_handling = null_ * corresponds to `[0, group_size-1]` indices respectively where `group_size` is * the size of each group. * - * @param n index of nth element in each group. - * @param null_handling Indicates to include/exclude nulls during indexing. + * @param n index of nth element in each group + * @param null_handling Indicates to include/exclude nulls during indexing * @return A NTH_ELEMENT aggregation object */ template @@ -468,9 +468,9 @@ std::unique_ptr make_row_number_aggregation(); * * @endcode * - * @param method The ranking method used for tie breaking (same values). + * @param method The ranking method used for tie breaking (same values) * @param column_order The desired sort order for ranking - * @param null_handling flag to include nulls during ranking. If nulls are not included, + * @param null_handling flag to include nulls during ranking If nulls are not included, * the corresponding rank will be null. * @param null_precedence The desired order of null compared to other elements for column * @param percentage enum to denote the type of conversion of ranks to percentage in range (0,1] @@ -491,7 +491,7 @@ std::unique_ptr make_rank_aggregation(rank_method method, * If `null_handling` is set to `EXCLUDE`, null elements are dropped from each * of the list rows. * - * @param null_handling Indicates whether to include/exclude nulls in list elements. + * @param null_handling Indicates whether to include/exclude nulls in list elements * @return A COLLECT_LIST aggregation object */ template @@ -613,7 +613,7 @@ std::unique_ptr make_merge_m2_aggregation(); * * Compute covariance between two columns. * The input columns are child columns of a non-nullable struct columns. - * @param min_periods Minimum number of non-null observations required to produce a result. + * @param min_periods Minimum number of non-null observations required to produce a result * @param ddof Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N is * the number of non-null observations. * @return A COVARIANCE aggregation object @@ -628,7 +628,7 @@ std::unique_ptr make_covariance_aggregation(size_type min_periods = 1, siz * The input columns are child columns of a non-nullable struct columns. * * @param type correlation_type - * @param min_periods Minimum number of non-null observations required to produce a result. + * @param min_periods Minimum number of non-null observations required to produce a result * @return A CORRELATION aggregation object */ template