From aac867afe98adc58e2662ea2d3c395030b3d9aad Mon Sep 17 00:00:00 2001 From: jeanp413 Date: Tue, 18 Dec 2018 23:14:49 -0500 Subject: [PATCH 1/4] added documentation to functions in functions.h --- cpp/include/cudf/functions.h | 2225 +++++++++++++++++++++++++++++++--- cpp/src/join/joining.cu | 96 +- 2 files changed, 2135 insertions(+), 186 deletions(-) diff --git a/cpp/include/cudf/functions.h b/cpp/include/cudf/functions.h index a6a76befc1b3..58ef836b6d78 100644 --- a/cpp/include/cudf/functions.h +++ b/cpp/include/cudf/functions.h @@ -2,15 +2,15 @@ /* --------------------------------------------------------------------------*/ /** - * @Synopsis Start a NVTX range with predefined color. + * @brief Start a NVTX range with predefined color. * * This function is useful only for profiling with nvvp or Nsight Systems. It * demarcates the begining of a user-defined range with a specified name and * color that will show up in the timeline view of nvvp/Nsight Systems. Can be * nested within other ranges. * - * @Param name The name of the NVTX range - * @Param color The predefined gdf_color enum to use to color this range + * @Param[in] name The name of the NVTX range + * @Param[in] color The predefined gdf_color enum to use to color this range * * @Returns */ @@ -22,15 +22,15 @@ gdf_error gdf_nvtx_range_push(char const * const name, gdf_color color ); /* --------------------------------------------------------------------------*/ /** - * @Synopsis Start a NVTX range with a custom ARGB color code. + * @brief Start a NVTX range with a custom ARGB color code. * * This function is useful only for profiling with nvvp or Nsight Systems. It * demarcates the begining of a user-defined range with a specified name and * color that will show up in the timeline view of nvvp/Nsight Systems. Can be * nested within other ranges. * - * @Param name The name of the NVTX range - * @Param color The ARGB hex color code to use to color this range (e.g., 0xFF00FF00) + * @Param[in] name The name of the NVTX range + * @Param[in] color The ARGB hex color code to use to color this range (e.g., 0xFF00FF00) * * @Returns */ @@ -40,7 +40,7 @@ gdf_error gdf_nvtx_range_push_hex(char const * const name, unsigned int color ); /* --------------------------------------------------------------------------*/ /** - * @Synopsis Ends the inner-most NVTX range. + * @brief Ends the inner-most NVTX range. * * This function is useful only for profiling with nvvp or Nsight Systems. It * will demarcate the end of the inner-most range, i.e., the most recent call to @@ -48,12 +48,12 @@ gdf_error gdf_nvtx_range_push_hex(char const * const name, unsigned int color ); * * @Returns */ -/* ----------------------------------------------------------------------------*/ +/* --------------------------------------------------------------------------*/ gdf_error gdf_nvtx_range_pop(); /* --------------------------------------------------------------------------*/ /** - * @Synopsis Counts the number of valid bits in the mask that corresponds to + * @brief Counts the number of valid bits in the mask that corresponds to * the specified number of rows. * * @Param[in] masks Array of gdf_valid_types with enough bits to represent @@ -63,147 +63,582 @@ gdf_error gdf_nvtx_range_pop(); * * @Returns GDF_SUCCESS upon successful completion. */ -/* ----------------------------------------------------------------------------*/ +/* --------------------------------------------------------------------------*/ gdf_error gdf_count_nonzero_mask(gdf_valid_type const * masks, int num_rows, int * count); + /* column operations */ +/* --------------------------------------------------------------------------*/ +/** + * @brief Return the size of the gdf_column data type. + * + * @Returns gdf_size_type Size of the gdf_column data type. + */ +/* ----------------------------------------------------------------------------*/ gdf_size_type gdf_column_sizeof(); +/* --------------------------------------------------------------------------*/ +/** + * @brief Create a GDF column given data and validity bitmask pointers, size, and + * datatype + * + * @Param[out] column The output column. + * @Param[in] data Pointer to data. + * @Param[in] valid Pointer to validity bitmask for the data. + * @Param[in] size Number of rows in the column. + * @Param[in] dtype Data type of the column. + * + * @Returns gdf_error Returns GDF_SUCCESS upon successful creation. + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_column_view(gdf_column *column, void *data, gdf_valid_type *valid, gdf_size_type size, gdf_dtype dtype); +/* --------------------------------------------------------------------------*/ +/** + * @brief Create a GDF column given data and validity bitmask pointers, size, and + * datatype, and count of null (non-valid) elements + * + * @Param[out] column The output column. + * @Param[in] data Pointer to data. + * @Param[in] valid Pointer to validity bitmask for the data. + * @Param[in] size Number of rows in the column. + * @Param[in] dtype Data type of the column. + * @Param[in] null_count The number of non-valid elements in the validity bitmask + * + * @Returns gdf_error Returns GDF_SUCCESS upon successful creation. + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_column_view_augmented(gdf_column *column, void *data, gdf_valid_type *valid, gdf_size_type size, gdf_dtype dtype, gdf_size_type null_count); +/* --------------------------------------------------------------------------*/ +/** + * @brief Free the CUDA device memory of a gdf_column + * + * @param[in,out] column Data and validity bitmask pointers of this column will be freed + * + * @Returns gdf_error GDF_SUCCESS or GDF_ERROR if there is an error freeing the data + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_column_free(gdf_column *column); /* --------------------------------------------------------------------------*/ /** - * @Synopsis Concatenates the gdf_columns into a single, contiguous column, + * @brief Concatenates the gdf_columns into a single, contiguous column, * including the validity bitmasks * * @Param[out] output A column whose buffers are already allocated that will * @Param[in] columns_to_conat[] The columns to concatenate * @Param[in] num_columns The number of columns to concatenate - * contain the concatenation of the input columns + * contain the concatenation of the input columns * * @Returns GDF_SUCCESS upon successful completion */ /* ----------------------------------------------------------------------------*/ gdf_error gdf_column_concat(gdf_column *output, gdf_column *columns_to_concat[], int num_columns); + /* context operations */ +/* --------------------------------------------------------------------------*/ +/** + * @brief Constructor for the gdf_context struct + * + * @Param[out] gdf_context being constructed + * @Param[in] Indicates if the input data is sorted. 0 = No, 1 = yes + * @Param[in] the method to be used for the operation (e.g., sort vs hash) + * @Param[in] for COUNT: DISTINCT = 1, else = 0 + * + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_context_view(gdf_context *context, int flag_sorted, gdf_method flag_method, int flag_distinct, int flag_sort_result, int flag_sort_inplace); + /* error handling */ +/* --------------------------------------------------------------------------*/ +/** + * @brief Converts a gdf_error error code into a string + * + * @Param[in] gdf_error + * + * @Returns name of the error + */ +/* ----------------------------------------------------------------------------*/ const char * gdf_error_get_name(gdf_error errcode); +/* --------------------------------------------------------------------------*/ +/** + * @brief Returns the last error from a runtime call. + * + * @Returns last error from a runtime call. + */ +/* ----------------------------------------------------------------------------*/ int gdf_cuda_last_error(); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Returns the description string for an error code. + * + * @Param[in] cuda error code + * + * @Returns description string for an error code. + */ +/* ----------------------------------------------------------------------------*/ const char * gdf_cuda_error_string(int cuda_error); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Returns the string representation of an error code enum name. + * + * @Param[in] cuda error code + * + * @Returns string representation of an error code enum name. + */ +/* ----------------------------------------------------------------------------*/ const char * gdf_cuda_error_name(int cuda_error); + /* ipc */ +/* --------------------------------------------------------------------------*/ +/** + * @brief Opens a parser from a pyarrow RecordBatch schema + * + * @Param[in] Pointer to a byte array containing the pyarrow RecordBatch schema + * @Param[in] Size of the byte array + * + * @Returns Pointer to a parsing struct gdf_ipc_parser_type + */ +/* ----------------------------------------------------------------------------*/ gdf_ipc_parser_type* gdf_ipc_parser_open(const uint8_t *schema, size_t length); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Opens a pyarrow RecordBatch bytearray + * + * @Param[in] Pointer to a parsing struct gdf_ipc_parser_type + * @Param[in] Pointer to a pyarrow RecordBatch bytearray + * @Param[in] Size of the byte array + * + * @Returns + */ +/* ----------------------------------------------------------------------------*/ void gdf_ipc_parser_open_recordbatches(gdf_ipc_parser_type *handle, const uint8_t *recordbatches, size_t length); +/* --------------------------------------------------------------------------*/ +/** + * @brief Closes a parser from a pyarrow RecordBatch schema + * + * @Param[in] Pointer to a parsing struct gdf_ipc_parser_type + * + * @Returns void + */ +/* ----------------------------------------------------------------------------*/ void gdf_ipc_parser_close(gdf_ipc_parser_type *handle); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Checks for a failure in the parser + * + * @Param[in] Pointer to a parsing struct gdf_ipc_parser_type + * + * @Returns 1 if error + */ +/* ----------------------------------------------------------------------------*/ int gdf_ipc_parser_failed(gdf_ipc_parser_type *handle); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Returns parsed data as json + * + * @Param[in] Pointer to a parsing struct gdf_ipc_parser_type + * + * @Returns char* of parsed data as json + */ +/* ----------------------------------------------------------------------------*/ const char* gdf_ipc_parser_to_json(gdf_ipc_parser_type *handle); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Gets error from gdf_ipc_parser_type + * + * @Param[in] Pointer to a parsing struct gdf_ipc_parser_type + * + * @Returns Error message as char* + */ +/* ----------------------------------------------------------------------------*/ const char* gdf_ipc_parser_get_error(gdf_ipc_parser_type *handle); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Gets parsed data from gdf_ipc_parser_type + * + * @Param[in] Pointer to a parsing struct gdf_ipc_parser_type + * + * @Returns Pointer parsed data + */ +/* ----------------------------------------------------------------------------*/ const void* gdf_ipc_parser_get_data(gdf_ipc_parser_type *handle); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Gets data offset from gdf_ipc_parser_type + * + * @Param[in] Pointer to a parsing struct gdf_ipc_parser_type + * + * @Returns Data offset + */ +/* ----------------------------------------------------------------------------*/ int64_t gdf_ipc_parser_get_data_offset(gdf_ipc_parser_type *handle); -const char *gdf_ipc_parser_get_schema_json(gdf_ipc_parser_type *handle) ; -const char *gdf_ipc_parser_get_layout_json(gdf_ipc_parser_type *handle) ; +/* --------------------------------------------------------------------------*/ +/** + * @brief Returns parsed schema as json + * + * @Param[in] Pointer to a parsing struct gdf_ipc_parser_type + * + * @Returns char* of parsed schema as json + */ +/* ----------------------------------------------------------------------------*/ +const char *gdf_ipc_parser_get_schema_json(gdf_ipc_parser_type *handle); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Returns layout as json + * + * @Param[in] Pointer to a parsing struct gdf_ipc_parser_type + * + * @Returns char* of layout as json + */ +/* ----------------------------------------------------------------------------*/ +const char *gdf_ipc_parser_get_layout_json(gdf_ipc_parser_type *handle); /* sorting */ + +/* --------------------------------------------------------------------------*/ +/** + * @brief Constructor for the gdf_radixsort_plan_type object + * + * @Param[in] Number of items to sort + * @Param[in] Indicates if sort should be ascending or descending. 1 = Descending, 0 = Ascending + * @Param[in] The least-significant bit index (inclusive) needed for key comparison + * @Param[in] The most-significant bit index (exclusive) needed for key comparison (e.g., sizeof(unsigned int) * 8) + * + * @Returns gdf_radixsort_plan_type object pointer + */ +/* ----------------------------------------------------------------------------*/ gdf_radixsort_plan_type* gdf_radixsort_plan(size_t num_items, int descending, unsigned begin_bit, unsigned end_bit); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Allocates device memory for the radixsort + * + * @Param[in] Radix sort plan + * @Param[in] sizeof data type of key + * @Param[in] sizeof data type of val + * + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_radixsort_plan_setup(gdf_radixsort_plan_type *hdl, size_t sizeof_key, size_t sizeof_val); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Frees device memory used for the radixsort + * + * @Param[in] Radix sort plan + * + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_radixsort_plan_free(gdf_radixsort_plan_type *hdl); + /* * The following function performs a sort on the key and value columns. * The null_count of the keycol and valcol columns are expected to be 0 * otherwise a GDF_VALIDITY_UNSUPPORTED error is returned. */ + +/* --------------------------------------------------------------------------*/ +/** + * @brief Performs a radixsort on the key and value columns where the key is an int8 + * + * @Param[in] Radix sort plan + * @Param[in] key gdf_column + * @Param[in] value gdf_column + * + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_radixsort_i8(gdf_radixsort_plan_type *hdl, gdf_column *keycol, gdf_column *valcol); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Performs a radixsort on the key and value columns where the key is an int32 + * + * @Param[in] Radix sort plan + * @Param[in] key gdf_column + * @Param[in] value gdf_column + * + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_radixsort_i32(gdf_radixsort_plan_type *hdl, gdf_column *keycol, gdf_column *valcol); + +/* --------------------------------------------------------------------------*/ +/** + * @brief performs a radixsort on the key and value columns where the key is an int64 + * + * @Param[in] Radix sort plan + * @Param[in] key gdf_column + * @Param[in] value gdf_column + * + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_radixsort_i64(gdf_radixsort_plan_type *hdl, gdf_column *keycol, gdf_column *valcol); + +/* --------------------------------------------------------------------------*/ +/** + * @brief performs a radixsort on the key and value columns where the key is an float + * + * @Param[in] Radix sort plan + * @Param[in] key gdf_column + * @Param[in] value gdf_column + * + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_radixsort_f32(gdf_radixsort_plan_type *hdl, gdf_column *keycol, gdf_column *valcol); + +/* --------------------------------------------------------------------------*/ +/** + * @brief performs a radixsort on the key and value columns where the key is an double + * + * @Param[in] Radix sort plan + * @Param[in] key gdf_column + * @Param[in] value gdf_column + * + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_radixsort_f64(gdf_radixsort_plan_type *hdl, gdf_column *keycol, gdf_column *valcol); + +/* --------------------------------------------------------------------------*/ +/** + * @brief performs a radixsort on the key and value columns where the key is any type + * + * @Param[in] Radix sort plan + * @Param[in] key gdf_column + * @Param[in] value gdf_column + * + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_radixsort_generic(gdf_radixsort_plan_type *hdl, gdf_column *keycol, gdf_column *valcol); + /* segmented sorting */ -gdf_segmented_radixsort_plan_type* gdf_segmented_radixsort_plan(size_t num_items, int descending, - unsigned begin_bit, unsigned end_bit); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Constructor for the gdf_segmented_radixsort_plan_type object + * + * @Param[in] Number of items to sort + * @Param[in] Indicates if sort should be ascending or descending. 1 = Descending, 0 = Ascending + * @Param[in] The least-significant bit index (inclusive) needed for key comparison + * @Param[in] The most-significant bit index (exclusive) needed for key comparison (e.g., sizeof(unsigned int) * 8) + * + * @Returns gdf_segmented_radixsort_plan_type object pointer + */ +/* ----------------------------------------------------------------------------*/ +gdf_segmented_radixsort_plan_type* gdf_segmented_radixsort_plan(size_t num_items, + int descending, + unsigned begin_bit, + unsigned end_bit); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Allocates device memory for the segmented radixsort + * + * @Param[in] Segmented Radix sort plan + * @Param[in] sizeof data type of key + * @Param[in] sizeof data type of val + * + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_segmented_radixsort_plan_setup(gdf_segmented_radixsort_plan_type *hdl, -size_t sizeof_key, size_t sizeof_val); + size_t sizeof_key, + size_t sizeof_val); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Frees device memory used for the segmented radixsort + * + * @Param[in] Segmented Radix sort plan + * + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_segmented_radixsort_plan_free(gdf_segmented_radixsort_plan_type *hdl); + /* * The following function performs a sort on the key and value columns. * The null_count of the keycol and valcol columns are expected to be 0 * otherwise a GDF_VALIDITY_UNSUPPORTED error is returned. */ + +/* --------------------------------------------------------------------------*/ +/** + * @brief performs a segmented radixsort on the key and value columns where the key is an int8 + * + * @Param[in] Radix sort plan + * @Param[in] key gdf_column + * @Param[in] value gdf_column + * @Param[in] The number of segments that comprise the sorting data + * @Param[in] Pointer to the sequence of beginning offsets of length num_segments, such that d_begin_offsets[i] is the first element of the ith data segment in d_keys_* and d_values_* + * @Param[in] Pointer to the sequence of ending offsets of length num_segments, such that d_end_offsets[i]-1 is the last element of the ith data segment in d_keys_* and d_values_*. If d_end_offsets[i]-1 <= d_begin_offsets[i], the ith is considered empty. + * + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_segmented_radixsort_i8(gdf_segmented_radixsort_plan_type *hdl, gdf_column *keycol, gdf_column *valcol, unsigned num_segments, unsigned *d_begin_offsets, unsigned *d_end_offsets); + +/* --------------------------------------------------------------------------*/ +/** + * @brief performs a segmented radixsort on the key and value columns where the key is an int32 + * + * @Param[in] Radix sort plan + * @Param[in] key gdf_column + * @Param[in] value gdf_column + * @Param[in] The number of segments that comprise the sorting data + * @Param[in] Pointer to the sequence of beginning offsets of length num_segments, such that d_begin_offsets[i] is the first element of the ith data segment in d_keys_* and d_values_* + * @Param[in] Pointer to the sequence of ending offsets of length num_segments, such that d_end_offsets[i]-1 is the last element of the ith data segment in d_keys_* and d_values_*. If d_end_offsets[i]-1 <= d_begin_offsets[i], the ith is considered empty. + * + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_segmented_radixsort_i32(gdf_segmented_radixsort_plan_type *hdl, gdf_column *keycol, gdf_column *valcol, unsigned num_segments, unsigned *d_begin_offsets, unsigned *d_end_offsets); + +/* --------------------------------------------------------------------------*/ +/** + * @brief performs a segmented radixsort on the key and value columns where the key is an int64 + * + * @Param[in] Radix sort plan + * @Param[in] key gdf_column + * @Param[in] value gdf_column + * @Param[in] The number of segments that comprise the sorting data + * @Param[in] Pointer to the sequence of beginning offsets of length num_segments, such that d_begin_offsets[i] is the first element of the ith data segment in d_keys_* and d_values_* + * @Param[in] Pointer to the sequence of ending offsets of length num_segments, such that d_end_offsets[i]-1 is the last element of the ith data segment in d_keys_* and d_values_*. If d_end_offsets[i]-1 <= d_begin_offsets[i], the ith is considered empty. + * + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_segmented_radixsort_i64(gdf_segmented_radixsort_plan_type *hdl, gdf_column *keycol, gdf_column *valcol, unsigned num_segments, unsigned *d_begin_offsets, unsigned *d_end_offsets); + +/* --------------------------------------------------------------------------*/ +/** + * @brief performs a segmented radixsort on the key and value columns where the key is an float + * + * @Param[in] Radix sort plan + * @Param[in] key gdf_column + * @Param[in] value gdf_column + * @Param[in] The number of segments that comprise the sorting data + * @Param[in] Pointer to the sequence of beginning offsets of length num_segments, such that d_begin_offsets[i] is the first element of the ith data segment in d_keys_* and d_values_* + * @Param[in] Pointer to the sequence of ending offsets of length num_segments, such that d_end_offsets[i]-1 is the last element of the ith data segment in d_keys_* and d_values_*. If d_end_offsets[i]-1 <= d_begin_offsets[i], the ith is considered empty. + * + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_segmented_radixsort_f32(gdf_segmented_radixsort_plan_type *hdl, gdf_column *keycol, gdf_column *valcol, unsigned num_segments, unsigned *d_begin_offsets, unsigned *d_end_offsets); + +/* --------------------------------------------------------------------------*/ +/** + * @brief performs a segmented radixsort on the key and value columns where the key is an double + * + * @Param[in] Radix sort plan + * @Param[in] key gdf_column + * @Param[in] value gdf_column + * @Param[in] The number of segments that comprise the sorting data + * @Param[in] Pointer to the sequence of beginning offsets of length num_segments, such that d_begin_offsets[i] is the first element of the ith data segment in d_keys_* and d_values_* + * @Param[in] Pointer to the sequence of ending offsets of length num_segments, such that d_end_offsets[i]-1 is the last element of the ith data segment in d_keys_* and d_values_*. If d_end_offsets[i]-1 <= d_begin_offsets[i], the ith is considered empty. + * + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_segmented_radixsort_f64(gdf_segmented_radixsort_plan_type *hdl, gdf_column *keycol, gdf_column *valcol, unsigned num_segments, unsigned *d_begin_offsets, unsigned *d_end_offsets); + +/* --------------------------------------------------------------------------*/ +/** + * @brief performs a segmented radixsort on the key and value columns where the key is any type + * + * @Param[in] Radix sort plan + * @Param[in] key gdf_column + * @Param[in] value gdf_column + * @Param[in] The number of segments that comprise the sorting data + * @Param[in] Pointer to the sequence of beginning offsets of length num_segments, such that d_begin_offsets[i] is the first element of the ith data segment in d_keys_* and d_values_* + * @Param[in] Pointer to the sequence of ending offsets of length num_segments, such that d_end_offsets[i]-1 is the last element of the ith data segment in d_keys_* and d_values_*. If d_end_offsets[i]-1 <= d_begin_offsets[i], the ith is considered empty. + * + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_segmented_radixsort_generic(gdf_segmented_radixsort_plan_type *hdl, gdf_column *keycol, gdf_column *valcol, unsigned num_segments, unsigned *d_begin_offsets, unsigned *d_end_offsets); -// joins +// joins /* --------------------------------------------------------------------------*/ /** - * @Synopsis Performs an inner join on the specified columns of two + * @brief Performs an inner join on the specified columns of two * dataframes (left, right) * If join_context->flag_method is set to GDF_SORT then the null_count of the * columns must be set to 0 otherwise a GDF_VALIDITY_UNSUPPORTED error is @@ -246,7 +681,7 @@ gdf_error gdf_inner_join( /* --------------------------------------------------------------------------*/ /** - * @Synopsis Performs a left join (also known as left outer join) on the + * @brief Performs a left join (also known as left outer join) on the * specified columns of two dataframes (left, right) * If join_context->flag_method is set to GDF_SORT then the null_count of the * columns must be set to 0 otherwise a GDF_VALIDITY_UNSUPPORTED error is @@ -289,7 +724,7 @@ gdf_error gdf_left_join( /* --------------------------------------------------------------------------*/ /** - * @Synopsis Performs a full join (also known as full outer join) on the + * @brief Performs a full join (also known as full outer join) on the * specified columns of two dataframes (left, right) * If join_context->flag_method is set to GDF_SORT then the null_count of the * columns must be set to 0 otherwise a GDF_VALIDITY_UNSUPPORTED error is @@ -367,11 +802,11 @@ gdf_error gdf_hash_partition(int num_input_cols, /* --------------------------------------------------------------------------*/ /** - * @Synopsis Computes the prefix sum of a column + * @brief Computes the prefix sum of a column * - * @Param inp Input column for prefix sum with null_count = 0 - * @Param out The output column containing the prefix sum of the input - * @Param inclusive Flag for applying an inclusive prefix sum + * @Param[in] inp Input column for prefix sum with null_count = 0 + * @Param[out] out The output column containing the prefix sum of the input + * @Param[in] inclusive Flag for applying an inclusive prefix sum * * @Returns GDF_SUCCESS if the operation was successful, otherwise an appropriate * error code. If inp->null_count is not set to 0 GDF_VALIDITY_UNSUPPORTED is @@ -382,11 +817,11 @@ gdf_error gdf_prefixsum_generic(gdf_column *inp, gdf_column *out, int inclusive) /* --------------------------------------------------------------------------*/ /** - * @Synopsis Computes the prefix sum of a column + * @brief Computes the prefix sum of a column * - * @Param inp Input column for prefix sum with null_count = 0 - * @Param out The output column containing the prefix sum of the input - * @Param inclusive Flag for applying an inclusive prefix sum + * @Param[in] inp Input column for prefix sum with null_count = 0 + * @Param[out] out The output column containing the prefix sum of the input + * @Param[in] inclusive Flag for applying an inclusive prefix sum * * @Returns GDF_SUCCESS if the operation was successful, otherwise an appropriate * error code. If inp->null_count is not set to 0 GDF_VALIDITY_UNSUPPORTED is @@ -397,11 +832,11 @@ gdf_error gdf_prefixsum_i8(gdf_column *inp, gdf_column *out, int inclusive); /* --------------------------------------------------------------------------*/ /** - * @Synopsis Computes the prefix sum of a column + * @brief Computes the prefix sum of a column * - * @Param inp Input column for prefix sum with null_count = 0 - * @Param out The output column containing the prefix sum of the input - * @Param inclusive Flag for applying an inclusive prefix sum + * @Param[in] inp Input column for prefix sum with null_count = 0 + * @Param[out] out The output column containing the prefix sum of the input + * @Param[in] inclusive Flag for applying an inclusive prefix sum * * @Returns GDF_SUCCESS if the operation was successful, otherwise an appropriate * error code. If inp->null_count is not set to 0 GDF_VALIDITY_UNSUPPORTED is @@ -412,11 +847,11 @@ gdf_error gdf_prefixsum_i32(gdf_column *inp, gdf_column *out, int inclusive); /* --------------------------------------------------------------------------*/ /** - * @Synopsis Computes the prefix sum of a column + * @brief Computes the prefix sum of a column * - * @Param inp Input column for prefix sum with null_count = 0 - * @Param out The output column containing the prefix sum of the input - * @Param inclusive Flag for applying an inclusive prefix sum + * @Param[in] inp Input column for prefix sum with null_count = 0 + * @Param[out] out The output column containing the prefix sum of the input + * @Param[in] inclusive Flag for applying an inclusive prefix sum * * @Returns GDF_SUCCESS if the operation was successful, otherwise an appropriate * error code. If inp->null_count is not set to 0 GDF_VALIDITY_UNSUPPORTED is @@ -432,12 +867,12 @@ gdf_error gdf_prefixsum_i64(gdf_column *inp, gdf_column *out, int inclusive); /* --------------------------------------------------------------------------*/ /** - * @Synopsis Computes the hash value of each row in the input set of columns. + * @brief Computes the hash value of each row in the input set of columns. * - * @Param num_cols The number of columns in the input set - * @Param input The list of columns whose rows will be hashed - * @Param hash The hash function to use - * @Param output The hash value of each row of the input + * @Param[in] num_cols The number of columns in the input set + * @Param[in] input The list of columns whose rows will be hashed + * @Param[in] hash The hash function to use + * @Param[out] output The hash value of each row of the input * * @Returns GDF_SUCCESS if the operation was successful, otherwise an appropriate * error code @@ -447,145 +882,1423 @@ gdf_error gdf_hash(int num_cols, gdf_column **input, gdf_hash_func hash, gdf_col /* trig */ +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes trigonometric sine function for any floating point data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_sin_generic(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes trigonometric sine function for float data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_sin_f32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes trigonometric sine function for double data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_sin_f64(gdf_column *input, gdf_column *output); +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes trigonometric cosine function for any floating point data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cos_generic(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes trigonometric cosine function for float data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cos_f32(gdf_column *input, gdf_column *output); -gdf_error gdf_cos_f64(gdf_column *input, gdf_column *output); -gdf_error gdf_tan_generic(gdf_column *input, gdf_column *output); -gdf_error gdf_tan_f32(gdf_column *input, gdf_column *output); +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes trigonometric cosine function for double data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ +gdf_error gdf_cos_f64(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes trigonometric tangent function for any floating point data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ +gdf_error gdf_tan_generic(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes trigonometric tangent function for float data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ +gdf_error gdf_tan_f32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes trigonometric tangent function for double data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_tan_f64(gdf_column *input, gdf_column *output); +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes trigonometric arcsin function for any floating point data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_asin_generic(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes trigonometric arcsin function for float data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_asin_f32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes trigonometric arcsin function for double data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_asin_f64(gdf_column *input, gdf_column *output); +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes trigonometric arccos function for any floating point data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_acos_generic(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes trigonometric arccos function for float data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_acos_f32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes trigonometric arccos function for double data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_acos_f64(gdf_column *input, gdf_column *output); +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes trigonometric arctan function for any floating point data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_atan_generic(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes trigonometric arctan function for a float data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_atan_f32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes trigonometric arctan function for a double data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_atan_f64(gdf_column *input, gdf_column *output); + /* exponential */ +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes e (Euler's number, 2.7182818...) raised to the given power arg for any floating point data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_exp_generic(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes e (Euler's number, 2.7182818...) raised to the given power arg float data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_exp_f32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes e (Euler's number, 2.7182818...) raised to the given power arg for double data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_exp_f64(gdf_column *input, gdf_column *output); +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes the natural (base e) logarithm of arg for any floating point data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_log_generic(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes the natural (base e) logarithm of arg for float data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_log_f32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes the natural (base e) logarithm of arg for double data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_log_f64(gdf_column *input, gdf_column *output); + /* power */ +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes the square root for any floating point data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_sqrt_generic(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes the square root for float data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_sqrt_f32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes the square root for double data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_sqrt_f64(gdf_column *input, gdf_column *output); /* rounding */ +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes the smallest integer value not less than arg for any floating point data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_ceil_generic(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes the smallest integer value not less than arg for float data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_ceil_f32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes the smallest integer value not less than arg for double data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_ceil_f64(gdf_column *input, gdf_column *output); +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes the largest integer value not greater than arg for any floating point data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_floor_generic(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes the largest integer value not greater than arg for float data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_floor_f32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Computes the largest integer value not greater than arg for double data type + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_floor_f64(gdf_column *input, gdf_column *output); + /* casting */ +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column of any data type to a GDF_FLOAT32 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_generic_to_f32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column of type GDF_INT8 to a GDF_FLOAT32 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i8_to_f32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column of type GDF_INT32 to a GDF_FLOAT32 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i32_to_f32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column of type GDF_INT64 to a GDF_FLOAT32 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i64_to_f32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column of type GDF_FLOAT32 to a GDF_FLOAT32 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_f32_to_f32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column of type GDF_FLOAT64 to a GDF_FLOAT32 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_f64_to_f32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column of type GDF_DATE32 to a GDF_FLOAT32 + * + * This is effectively casting the underlying GDF_INT32 physical data type of GDF_DATE32 to GDF_FLOAT32 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_date32_to_f32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column of type GDF_DATE64 to a GDF_FLOAT32 + * + * This is effectively casting the underlying GDF_INT64 physical data type of GDF_DATE64 to GDF_FLOAT32 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_date64_to_f32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column of type GDF_TIMESTAMP to a GDF_FLOAT32 + * + * This is effectively casting the underlying GDF_INT64 physical data type of GDF_TIMESTAMP to GDF_FLOAT32 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_timestamp_to_f32(gdf_column *input, gdf_column *output); +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column of any data type to a GDF_FLOAT64 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_generic_to_f64(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_INT8 to a GDF_FLOAT64 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i8_to_f64(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_INT32 to a GDF_FLOAT64 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i32_to_f64(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_INT64 to a GDF_FLOAT64 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i64_to_f64(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_FLOAT32 to a GDF_FLOAT64 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_f32_to_f64(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_FLOAT64 to a GDF_FLOAT64 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_f64_to_f64(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_DATE32 to a GDF_FLOAT64 + * + * This is effectively casting the underlying GDF_INT32 physical data type of GDF_DATE32 to GDF_FLOAT64 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_date32_to_f64(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_DATE64 to a GDF_FLOAT64 + * + * This is effectively casting the underlying GDF_INT64 physical data type of GDF_DATE64 to GDF_FLOAT64 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_date64_to_f64(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_TIMESTAMP to a GDF_FLOAT64 + * + * This is effectively casting the underlying GDF_INT64 physical data type of GDF_TIMESTAMP to GDF_FLOAT64 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_timestamp_to_f64(gdf_column *input, gdf_column *output); +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column of any data type to a GDF_INT8 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_generic_to_i8(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_INT8 to a GDF_INT8 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i8_to_i8(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_INT32 to a GDF_INT8 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i32_to_i8(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_INT64 to a GDF_INT8 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i64_to_i8(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_FLOAT32 to a GDF_INT8 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_f32_to_i8(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_FLOAT64 to a GDF_INT8 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_f64_to_i8(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_DATE32 to a GDF_INT8 + * + * This is effectively casting the underlying GDF_INT32 physical data type of GDF_DATE32 to GDF_INT8 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_date32_to_i8(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_DATE64 to a GDF_INT8 + * + * This is effectively casting the underlying GDF_INT64 physical data type of GDF_DATE64 to GDF_INT8 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_date64_to_i8(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_TIMESTAMP to a GDF_INT8 + * + * This is effectively casting the underlying GDF_INT64 physical data type of GDF_TIMESTAMP to GDF_INT8 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_timestamp_to_i8(gdf_column *input, gdf_column *output); +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column of any data type to a GDF_INT32 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_generic_to_i32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_INT8 to a GDF_INT32 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i8_to_i32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_INT32 to a GDF_INT32 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i32_to_i32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_INT64 to a GDF_INT32 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i64_to_i32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_FLOAT32 to a GDF_INT32 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_f32_to_i32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_FLOAT64 to a GDF_INT32 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_f64_to_i32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_DATE32 to a GDF_INT32 + * + * This is effectively casting the underlying GDF_INT32 physical data type of GDF_DATE32 to GDF_INT32 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_date32_to_i32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_DATE64 to a GDF_INT32 + * + * This is effectively casting the underlying GDF_INT64 physical data type of GDF_DATE64 to GDF_INT32 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_date64_to_i32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_TIMESTAMP to a GDF_INT32 + * + * This is effectively casting the underlying GDF_INT64 physical data type of GDF_TIMESTAMP to GDF_INT32 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_timestamp_to_i32(gdf_column *input, gdf_column *output); +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column of any data type to a GDF_INT64 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_generic_to_i64(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_INT8 to a GDF_INT64 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i8_to_i64(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_INT32 to a GDF_INT64 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i32_to_i64(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_INT64 to a GDF_INT64 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i64_to_i64(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_FLOAT32 to a GDF_INT64 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_f32_to_i64(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_FLOAT64 to a GDF_INT64 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_f64_to_i64(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_DATE32 to a GDF_INT64 + * + * This is effectively casting the underlying GDF_INT32 physical data type of GDF_DATE32 to GDF_INT64 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_date32_to_i64(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_DATE64 to a GDF_INT64 + * + * This is effectively casting the underlying GDF_INT64 physical data type of GDF_DATE64 to GDF_INT64 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_date64_to_i64(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_TIMESTAMP to a GDF_INT64 + * + * This is effectively casting the underlying GDF_INT64 physical data type of GDF_TIMESTAMP to GDF_INT64 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_timestamp_to_i64(gdf_column *input, gdf_column *output); +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column of any data type to a GDF_DATE32 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_generic_to_date32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_INT8 to a GDF_DATE32 + * + * This is effectively casting the GDF_INT8 to the underlying GDF_INT32 physical data type of GDF_DATE32 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i8_to_date32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_INT32 to a GDF_DATE32 + * + * This is effectively casting the GDF_INT32 to the underlying GDF_INT32 physical data type of GDF_DATE32 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i32_to_date32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_INT64 to a GDF_DATE32 + * + * This is effectively casting the GDF_INT64 to the underlying GDF_INT32 physical data type of GDF_DATE32 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i64_to_date32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_FLOAT32 to a GDF_DATE32 + * + * This is effectively casting the GDF_FLOAT32 to the underlying GDF_INT32 physical data type of GDF_DATE32 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_f32_to_date32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_FLOAT64 to a GDF_DATE32 + * + * This is effectively casting the GDF_FLOAT64 to the underlying GDF_INT32 physical data type of GDF_DATE32 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_f64_to_date32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_DATE32 to a GDF_DATE32 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_date32_to_date32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_DATE64 to a GDF_DATE32 + * + * This casting converts from milliseconds since the UNIX epoch to days since the UNIX epoch + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_date64_to_date32(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_TIMESTAMP to a GDF_DATE32 + * + * This casting converts from gdf_time_unit since the UNIX epoch to days since the UNIX epoch + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_timestamp_to_date32(gdf_column *input, gdf_column *output); +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column of any data type to a GDF_FLOAT64 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_generic_to_date64(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_INT8 to a GDF_DATE64 + * + * This is effectively casting the GDF_INT8 to the underlying GDF_INT64 physical data type of GDF_DATE64 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i8_to_date64(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_INT32 to a GDF_DATE64 + * + * This is effectively casting the GDF_INT32 to the underlying GDF_INT64 physical data type of GDF_DATE64 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i32_to_date64(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_INT64 to a GDF_DATE64 + * + * This is effectively casting the GDF_INT64 to the underlying GDF_INT64 physical data type of GDF_DATE64 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i64_to_date64(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_FLOAT32 to a GDF_DATE64 + * + * This is effectively casting the GDF_FLOAT32 to the underlying GDF_INT64 physical data type of GDF_DATE64 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_f32_to_date64(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_FLOAT64 to a GDF_DATE64 + * + * This is effectively casting the GDF_FLOAT64 to the underlying GDF_INT64 physical data type of GDF_DATE64 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_f64_to_date64(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_DATE32 to a GDF_DATE64 + * + * This casting converts from days since the UNIX epoch to milliseconds since the UNIX epoch + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_date32_to_date64(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_DATE64 to a GDF_DATE64 + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_date64_to_date64(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_TIMESTAMP to a GDF_DATE32 + * + * This casting converts from gdf_time_unit since the UNIX epoch to milliseconds since the UNIX epoch + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_timestamp_to_date64(gdf_column *input, gdf_column *output); +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column of any data type to a GDF_TIMESTAMP + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_generic_to_timestamp(gdf_column *input, gdf_column *output, gdf_time_unit time_unit); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_INT8 to a GDF_TIMESTAMP + * + * This is effectively casting the GDF_INT8 to the underlying GDF_INT64 physical data type of GDF_TIMESTAMP + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i8_to_timestamp(gdf_column *input, gdf_column *output, gdf_time_unit time_unit); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_INT32 to a GDF_TIMESTAMP + * + * This is effectively casting the GDF_INT32 to the underlying GDF_INT64 physical data type of GDF_TIMESTAMP + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i32_to_timestamp(gdf_column *input, gdf_column *output, gdf_time_unit time_unit); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_INT64 to a GDF_TIMESTAMP + * + * This is effectively casting the GDF_INT64 to the underlying GDF_INT64 physical data type of GDF_TIMESTAMP + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i64_to_timestamp(gdf_column *input, gdf_column *output, gdf_time_unit time_unit); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_FLOAT32 to a GDF_TIMESTAMP + * + * This is effectively casting the GDF_FLOAT32 to the underlying GDF_INT64 physical data type of GDF_TIMESTAMP + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_f32_to_timestamp(gdf_column *input, gdf_column *output, gdf_time_unit time_unit); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_FLOAT64 to a GDF_TIMESTAMP + * + * This is effectively casting the GDF_FLOAT64 to the underlying GDF_INT64 physical data type of GDF_TIMESTAMP + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_f64_to_timestamp(gdf_column *input, gdf_column *output, gdf_time_unit time_unit); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_DATE32 to a GDF_TIMESTAMP + * + * This casting converts from days since UNIX epoch to gdf_time_unit since the UNIX epoch + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_date32_to_timestamp(gdf_column *input, gdf_column *output, gdf_time_unit time_unit); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_DATE64 to a GDF_TIMESTAMP + * + * This casting converts from milliseconds days since UNIX epoch to gdf_time_unit since the UNIX epoch + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_date64_to_timestamp(gdf_column *input, gdf_column *output, gdf_time_unit time_unit); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Casts data in a gdf_column type GDF_TIMESTAMP to a GDF_TIMESTAMP + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_timestamp_to_timestamp(gdf_column *input, gdf_column *output, gdf_time_unit time_unit); + /* datetime extract*/ + +/* --------------------------------------------------------------------------*/ +/** + * @brief Extracts year from any date time type and places results into a preallocated GDF_INT16 column + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_extract_datetime_year(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Extracts month from any date time type and places results into a preallocated GDF_INT16 column + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_extract_datetime_month(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Extracts day from any date time type and places results into a preallocated GDF_INT16 column + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_extract_datetime_day(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Extracts hour from either GDF_DATE64 or GDF_TIMESTAMP type and places results into a preallocated GDF_INT16 column + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_extract_datetime_hour(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Extracts minute from either GDF_DATE64 or GDF_TIMESTAMP type and places results into a preallocated GDF_INT16 column + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_extract_datetime_minute(gdf_column *input, gdf_column *output); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Extracts second from either GDF_DATE64 or GDF_TIMESTAMP type and places results into a preallocated GDF_INT16 column + * + * @Param[in] gdf_column of the input + * @Param[out] output gdf_column. The output memory needs to be preallocated + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_extract_datetime_second(gdf_column *input, gdf_column *output); @@ -714,9 +2427,9 @@ unsigned int gdf_reduce_optimal_output_size(); /* --------------------------------------------------------------------------* * @brief Computes the sum of the values in all rows of a column * - * @param[in] col Input column - * @param[out] dev_result The output sum - * @param[in] dev_result_size The size of dev_result in elements, which should + * @Param[in] col Input column + * @Param[out] dev_result The output sum + * @Param[in] dev_result_size The size of dev_result in elements, which should * be computed using gdf_reduce_optimal_output_size * This is used as intermediate storage, and the * first element contains the total result @@ -731,9 +2444,9 @@ gdf_error gdf_sum(gdf_column *col, void *dev_result, gdf_size_type dev_result_si * @brief Computes the multiplicative product of the values in all rows of * a column * - * @param[in] col Input column - * @param[out] dev_result The output product - * @param[in] dev_result_size The size of dev_result in elements, which should + * @Param[in] col Input column + * @Param[out] dev_result The output product + * @Param[in] dev_result_size The size of dev_result in elements, which should * be computed using gdf_reduce_optimal_output_size * This is used as intermediate storage, and the * first element contains the total result @@ -748,9 +2461,9 @@ gdf_error gdf_product(gdf_column *col, void *dev_result, gdf_size_type dev_resul * * Sum of squares is useful for variance implementation. * - * @param[in] col Input column - * @param[out] dev_result The output sum of squares - * @param[in] dev_result_size The size of dev_result in elements, which should + * @Param[in] col Input column + * @Param[out] dev_result The output sum of squares + * @Param[in] dev_result_size The size of dev_result in elements, which should * be computed using gdf_reduce_optimal_output_size * This is used as intermediate storage, and the * first element contains the total result @@ -766,9 +2479,9 @@ gdf_error gdf_sum_of_squares(gdf_column *col, void *dev_result, gdf_size_type de /* --------------------------------------------------------------------------* * @brief Computes the minimum of the values in all rows of a column * - * @param[in] col Input column - * @param[out] dev_result The output minimum - * @param[in] dev_result_size The size of dev_result in elements, which should + * @Param[in] col Input column + * @Param[out] dev_result The output minimum + * @Param[in] dev_result_size The size of dev_result in elements, which should * be computed using gdf_reduce_optimal_output_size * This is used as intermediate storage, and the * first element contains the total result @@ -782,9 +2495,9 @@ gdf_error gdf_min(gdf_column *col, void *dev_result, gdf_size_type dev_result_si /* --------------------------------------------------------------------------* * @brief Computes the maximum of the values in all rows of a column * - * @param[in] col Input column - * @param[out] dev_result The output maximum - * @param[in] dev_result_size The size of dev_result in elements, which should + * @Param[in] col Input column + * @Param[out] dev_result The output maximum + * @Param[in] dev_result_size The size of dev_result in elements, which should * be computed using gdf_reduce_optimal_output_size * This is used as intermediate storage, and the * first element contains the total result @@ -800,37 +2513,167 @@ gdf_error gdf_max(gdf_column *col, void *dev_result, gdf_size_type dev_result_si * Filtering and comparison operators */ - -//These compare every value on the left hand side to a static value and return a stencil in output which will have 1 when the comparison operation returns 1 and 0 otherwise +/* --------------------------------------------------------------------------*/ +/** + * @brief Compare every value on the left hand side to a static value and return a stencil in output which will have 1 when the comparison operation returns 1 and 0 otherwise + * + * @Param[in] gdf_column of the input of type GDF_INT8 + * @Param[in] Static value to compare against the input + * @Param[out] output gdf_column of type GDF_INT8. The output memory needs to be preallocated + * @Param[in] gdf_comparison_operator enum defining the comparison operator to be used + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gpu_comparison_static_i8(gdf_column *lhs, int8_t value, gdf_column *output,gdf_comparison_operator operation); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Compare every value on the left hand side to a static value and return a stencil in output which will have 1 when the comparison operation returns 1 and 0 otherwise + * + * @Param[in] gdf_column of the input of type GDF_INT16 + * @Param[in] Static value to compare against the input + * @Param[out] output gdf_column of type GDF_INT8. The output memory needs to be preallocated + * @Param[in] gdf_comparison_operator enum defining the comparison operator to be used + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gpu_comparison_static_i16(gdf_column *lhs, int16_t value, gdf_column *output,gdf_comparison_operator operation); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Compare every value on the left hand side to a static value and return a stencil in output which will have 1 when the comparison operation returns 1 and 0 otherwise + * + * @Param[in] gdf_column of the input of type GDF_INT32 + * @Param[in] Static value to compare against the input + * @Param[out] output gdf_column of type GDF_INT8. The output memory needs to be preallocated + * @Param[in] gdf_comparison_operator enum defining the comparison operator to be used + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gpu_comparison_static_i32(gdf_column *lhs, int32_t value, gdf_column *output,gdf_comparison_operator operation); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Compare every value on the left hand side to a static value and return a stencil in output which will have 1 when the comparison operation returns 1 and 0 otherwise + * + * @Param[in] gdf_column of the input of type GDF_INT64 + * @Param[in] Static value to compare against the input + * @Param[out] output gdf_column of type GDF_INT8. The output memory needs to be preallocated + * @Param[in] gdf_comparison_operator enum defining the comparison operator to be used + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gpu_comparison_static_i64(gdf_column *lhs, int64_t value, gdf_column *output,gdf_comparison_operator operation); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Compare every value on the left hand side to a static value and return a stencil in output which will have 1 when the comparison operation returns 1 and 0 otherwise + * + * @Param[in] gdf_column of the input of type GDF_FLOAT32 + * @Param[in] Static value to compare against the input + * @Param[out] output gdf_column of type GDF_INT8. The output memory needs to be preallocated + * @Param[in] gdf_comparison_operator enum defining the comparison operator to be used + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gpu_comparison_static_f32(gdf_column *lhs, float value, gdf_column *output,gdf_comparison_operator operation); + +/* --------------------------------------------------------------------------*/ +/** + * @brief Compare every value on the left hand side to a static value and return a stencil in output which will have 1 when the comparison operation returns 1 and 0 otherwise + * + * @Param[in] gdf_column of the input of type GDF_FLOAT64 + * @Param[in] Static value to compare against the input + * @Param[out] output gdf_column of type GDF_INT8. The output memory needs to be preallocated + * @Param[in] gdf_comparison_operator enum defining the comparison operator to be used + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gpu_comparison_static_f64(gdf_column *lhs, double value, gdf_column *output,gdf_comparison_operator operation); -//allows you two compare two columns against each other using a comparison operation, retunrs a stencil like functions above +/* --------------------------------------------------------------------------*/ +/** + * @brief Compare two columns of any types against each other using a comparison operation, returns a stencil in output which will have 1 when the comparison operation returns 1 and 0 otherwise + * + * @Param[in] gdf_column of one input of any type + * @Param[in] gdf_column of second input of any type + * @Param[out] output gdf_column of type GDF_INT8. The output memory needs to be preallocated + * @Param[in] gdf_comparison_operator enum defining the comparison operator to be used + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gpu_comparison(gdf_column *lhs, gdf_column *rhs, gdf_column *output,gdf_comparison_operator operation); -//takes a stencil and uses it to compact a colum e.g. remove all values for which the stencil = 0 -//The lhs column is expected to have 0 null_count otherwise GDF_VALIDITY_UNSUPPORTED is returned +/* --------------------------------------------------------------------------*/ +/** + * @brief takes a stencil and uses it to compact a colum e.g. remove all values for which the stencil = 0 + * + * @Param[in] gdf_column of input of any type + * @Param[in] gdf_column holding the stencil + * @Param[out] output gdf_column of same type as input. The output memory needs to be preallocated to be the same size as input + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gpu_apply_stencil(gdf_column *lhs, gdf_column * stencil, gdf_column * output); +/* --------------------------------------------------------------------------*/ +/** + * @brief Concatenates two gdf_columns + * + * @Param[in] gdf_column of one input of any type + * @Param[in] gdf_column of same type as the first + * @Param[out] output gdf_column of same type as inputs. The output memory needs to be preallocated to be the same size as the sum of both inputs + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gpu_concat(gdf_column *lhs, gdf_column *rhs, gdf_column *output); + /* * Hashing */ -//class cudaStream_t; +/* --------------------------------------------------------------------------*/ +/** + * @brief Creates a hash of multiple gdf_columns + * + * @Param[in] an array of gdf_columns to be hashes together + * @Param[in] the number of columns in the array of gdf_columns to be hashes together + * @Param[out] output gdf_column of type GDF_INT64. The output memory needs to be preallocated + * @Param[in] A pointer to a cudaStream_t. If nullptr, the function will create a stream to use. + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error gpu_hash_columns(gdf_column ** columns_to_hash, int num_columns, gdf_column * output_column, void * stream); + /* * gdf introspection utlities */ +/* --------------------------------------------------------------------------*/ +/** + * @brief Returns the byte width of the data type of the gdf_column + * + * @Param[in] gdf_column whose data type's byte width will be determined + * @Param[out] the byte width of the data type + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ gdf_error get_column_byte_width(gdf_column * col, int * width); + /* Multi-Column SQL ops: WHERE (Filtering) @@ -838,76 +2681,177 @@ gdf_error get_column_byte_width(gdf_column * col, int * width); GROUP-BY */ -gdf_error gdf_filter(size_t nrows, //in: # rows - gdf_column* cols, //in: host-side array of gdf_columns with 0 null_count otherwise GDF_VALIDITY_UNSUPPORTED is returned - size_t ncols, //in: # cols - void** d_cols, //out: pre-allocated device-side array to be filled with gdf_column::data for each column; slicing of gdf_column array (host) - int* d_types, //out: pre-allocated device-side array to be filled with gdf_colum::dtype for each column; slicing of gdf_column array (host) - void** d_vals, //in: device-side array of values to filter against (type-erased) - size_t* d_indx, //out: device-side array of row indices that remain after filtering - size_t* new_sz); //out: host-side # rows that remain after filtering - -gdf_error gdf_group_by_sum(int ncols, // # columns - gdf_column** cols, //input cols with 0 null_count otherwise GDF_VALIDITY_UNSUPPORTED is returned - gdf_column* col_agg, //column to aggregate on with 0 null_count otherwise GDF_VALIDITY_UNSUPPORTED is returned - gdf_column* out_col_indices, //if not null return indices of re-ordered rows - gdf_column** out_col_values, //if not null return the grouped-by columns - //(multi-gather based on indices, which are needed anyway) - gdf_column* out_col_agg, //aggregation result - gdf_context* ctxt); //struct with additional info: bool is_sorted, flag_sort_or_hash, bool flag_count_distinct - -gdf_error gdf_group_by_min(int ncols, // # columns - gdf_column** cols, //input cols with 0 null_count otherwise GDF_VALIDITY_UNSUPPORTED is returned - gdf_column* col_agg, //column to aggregate on with 0 null_count otherwise GDF_VALIDITY_UNSUPPORTED is returned - gdf_column* out_col_indices, //if not null return indices of re-ordered rows - gdf_column** out_col_values, //if not null return the grouped-by columns - //(multi-gather based on indices, which are needed anyway) - gdf_column* out_col_agg, //aggregation result - gdf_context* ctxt); //struct with additional info: bool is_sorted, flag_sort_or_hash, bool flag_count_distinct - - -gdf_error gdf_group_by_max(int ncols, // # columns - gdf_column** cols, //input cols with 0 null_count otherwise GDF_VALIDITY_UNSUPPORTED is returned - gdf_column* col_agg, //column to aggregate on with 0 null_count otherwise GDF_VALIDITY_UNSUPPORTED is returned - gdf_column* out_col_indices, //if not null return indices of re-ordered rows - gdf_column** out_col_values, //if not null return the grouped-by columns - //(multi-gather based on indices, which are needed anyway) - gdf_column* out_col_agg, //aggregation result - gdf_context* ctxt); //struct with additional info: bool is_sorted, flag_sort_or_hash, bool flag_count_distinct - - -gdf_error gdf_group_by_avg(int ncols, // # columns - gdf_column** cols, //input cols with 0 null_count otherwise GDF_VALIDITY_UNSUPPORTED is returned - gdf_column* col_agg, //column to aggregate on with 0 null_count otherwise GDF_VALIDITY_UNSUPPORTED is returned - gdf_column* out_col_indices, //if not null return indices of re-ordered rows - gdf_column** out_col_values, //if not null return the grouped-by columns - //(multi-gather based on indices, which are needed anyway) - gdf_column* out_col_agg, //aggregation result - gdf_context* ctxt); //struct with additional info: bool is_sorted, flag_sort_or_hash, bool flag_count_distinct - -gdf_error gdf_group_by_count(int ncols, // # columns - gdf_column** cols, //input cols with 0 null_count otherwise GDF_VALIDITY_UNSUPPORTED is returned - gdf_column* col_agg, //column to aggregate on with 0 null_count otherwise GDF_VALIDITY_UNSUPPORTED is returned - gdf_column* out_col_indices, //if not null return indices of re-ordered rows - gdf_column** out_col_values, //if not null return the grouped-by columns - //(multi-gather based on indices, which are needed anyway) - gdf_column* out_col_agg, //aggregation result - gdf_context* ctxt); //struct with additional info: bool is_sorted, flag_sort_or_hash, bool flag_count_distinct - -gdf_error gdf_quantile_exact( gdf_column* col_in, //input column with 0 null_count otherwise GDF_VALIDITY_UNSUPPORTED is returned - gdf_quantile_method prec, //precision: type of quantile method calculation - double q, //requested quantile in [0,1] - void* t_erased_res, //result; for should probably be double*; it's void* because - //(1) for uniformity of interface with ; - //(2) for possible types bigger than double, in the future; - gdf_context* ctxt); //context info - -gdf_error gdf_quantile_aprrox( gdf_column* col_in, //input column with 0 null_count otherwise GDF_VALIDITY_UNSUPPORTED is returned - double q, //requested quantile in [0,1] - void* t_erased_res, //type-erased result of same type as column; - gdf_context* ctxt); //context info +/* --------------------------------------------------------------------------*/ +/** + * @brief Performs SQL like WHERE (Filtering) + * + * @Param[in] # rows + * @Param[in] host-side array of gdf_columns with 0 null_count otherwise GDF_VALIDITY_UNSUPPORTED is returned + * @Param[in] # cols + * @Param[out] pre-allocated device-side array to be filled with gdf_column::data for each column; slicing of gdf_column array (host) + * @Param[out] pre-allocated device-side array to be filled with gdf_colum::dtype for each column; slicing of gdf_column array (host) + * @Param[in] device-side array of values to filter against (type-erased) + * @Param[out] device-side array of row indices that remain after filtering + * @Param[out] host-side # rows that remain after filtering + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ +gdf_error gdf_filter(size_t nrows, + gdf_column* cols, + size_t ncols, + void** d_cols, + int* d_types, + void** d_vals, + size_t* d_indx, + size_t* new_sz); + +/** + * @brief Performs SQL like GROUP BY with SUM aggregation + * + * @Param[in] # columns + * @Param[in] input cols + * @Param[in] column to aggregate on + * @Param[out] if not null return indices of re-ordered rows + * @Param[out] if not null return the grouped-by columns (multi-gather based on indices, which are needed anyway) + * @Param[out] aggregation result + * @Param[in] struct with additional info: bool is_sorted, flag_sort_or_hash, bool flag_count_distinct + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ +gdf_error gdf_group_by_sum(int ncols, + gdf_column** cols, + gdf_column* col_agg, + gdf_column* out_col_indices, + gdf_column** out_col_values, + gdf_column* out_col_agg, + gdf_context* ctxt); + +/** + * @brief Performs SQL like GROUP BY with MIN aggregation + * + * @Param[in] # columns + * @Param[in] input cols + * @Param[in] column to aggregate on + * @Param[out] if not null return indices of re-ordered rows + * @Param[out] if not null return the grouped-by columns (multi-gather based on indices, which are needed anyway) + * @Param[out] aggregation result + * @Param[in] struct with additional info: bool is_sorted, flag_sort_or_hash, bool flag_count_distinct + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ +gdf_error gdf_group_by_min(int ncols, + gdf_column** cols, + gdf_column* col_agg, + gdf_column* out_col_indices, + gdf_column** out_col_values, + gdf_column* out_col_agg, + gdf_context* ctxt); + +/** + * @brief Performs SQL like GROUP BY with MAX aggregation + * + * @Param[in] # columns + * @Param[in] input cols + * @Param[in] column to aggregate on + * @Param[out] if not null return indices of re-ordered rows + * @Param[out] if not null return the grouped-by columns (multi-gather based on indices, which are needed anyway) + * @Param[out] aggregation result + * @Param[in] struct with additional info: bool is_sorted, flag_sort_or_hash, bool flag_count_distinct + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ +gdf_error gdf_group_by_max(int ncols, + gdf_column** cols, + gdf_column* col_agg, + gdf_column* out_col_indices, + gdf_column** out_col_values, + gdf_column* out_col_agg, + gdf_context* ctxt); + +/** + * @brief Performs SQL like GROUP BY with AVG aggregation + * + * @Param[in] # columns + * @Param[in] input cols + * @Param[in] column to aggregate on + * @Param[out] if not null return indices of re-ordered rows + * @Param[out] if not null return the grouped-by columns (multi-gather based on indices, which are needed anyway) + * @Param[out] aggregation result + * @Param[in] struct with additional info: bool is_sorted, flag_sort_or_hash, bool flag_count_distinct + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ +gdf_error gdf_group_by_avg(int ncols, + gdf_column** cols, + gdf_column* col_agg, + gdf_column* out_col_indices, + gdf_column** out_col_values, + gdf_column* out_col_agg, + gdf_context* ctxt); + +/** + * @brief Performs SQL like GROUP BY with COUNT aggregation + * + * @Param[in] # columns + * @Param[in] input cols + * @Param[in] column to aggregate on + * @Param[out] if not null return indices of re-ordered rows + * @Param[out] if not null return the grouped-by columns (multi-gather based on indices, which are needed anyway) + * @Param[out] aggregation result + * @Param[in] struct with additional info: bool is_sorted, flag_sort_or_hash, bool flag_count_distinct + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ +gdf_error gdf_group_by_count(int ncols, + gdf_column** cols, + gdf_column* col_agg, + gdf_column* out_col_indices, + gdf_column** out_col_values, + gdf_column* out_col_agg, + gdf_context* ctxt); + +/** + * @brief Calculates exact quantiles + * + * @Param[in] input column + * @Param[in] precision: type of quantile method calculation + * @Param[in] requested quantile in [0,1] + * @Param[out] result; for should probably be double*; it's void* because: (1) for uniformity of interface with ; (2) for possible types bigger than double, in the future; + * @Param[in] struct with additional info + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ +gdf_error gdf_quantile_exact(gdf_column* col_in, + gdf_quantile_method prec, + double q, + void* t_erased_res, + gdf_context* ctxt); + +/** + * @brief Calculates approximate quantiles + * + * @Param[in] input column + * @Param[in] requested quantile in [0,1] + * @Param[out] result; type-erased result of same type as column; + * @Param[in] struct with additional info + * +* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + */ +/* ----------------------------------------------------------------------------*/ +gdf_error gdf_quantile_aprrox(gdf_column* col_in, + double q, + void* t_erased_res, + gdf_context* ctxt); -/* --------------------------------------------------------------------------* +/* --------------------------------------------------------------------------*/ +/** * @brief Replace elements from `col` according to the mapping `old_values` to * `new_values`, that is, replace all `old_values[i]` present in `col` * with `new_values[i]`. @@ -917,13 +2861,14 @@ gdf_error gdf_quantile_aprrox( gdf_column* col_in, //input column with 0 * @Param[in] new_values gdf_column with the new values * * @Returns GDF_SUCCESS upon successful completion - * - * --------------------------------------------------------------------------*/ + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_find_and_replace_all(gdf_column* col, const gdf_column* old_values, const gdf_column* new_values); -/* --------------------------------------------------------------------------* +/* --------------------------------------------------------------------------*/ +/** * @brief Sorts an array of gdf_column. * * @Param[in] input_columns Array of gdf_columns @@ -937,8 +2882,8 @@ gdf_error gdf_find_and_replace_all(gdf_column* col, * indices * * @Returns GDF_SUCCESS upon successful completion - * - * ----------------------------------------------------------------------------*/ + */ +/* ----------------------------------------------------------------------------*/ gdf_error gdf_order_by(gdf_column** input_columns, int8_t* asc_desc, size_t num_inputs, diff --git a/cpp/src/join/joining.cu b/cpp/src/join/joining.cu index 68c44d4daa9d..ee21b43dbf58 100644 --- a/cpp/src/join/joining.cu +++ b/cpp/src/join/joining.cu @@ -36,13 +36,13 @@ constexpr output_index_type MAX_JOIN_SIZE{std::numeric_limits /* --------------------------------------------------------------------------*/ /** - * @Synopsis Computes the Join result between two tables using the hash-based implementation. + * @brief Computes the Join result between two tables using the hash-based implementation. * - * @Param num_cols The number of columns to join - * @Param leftcol The left set of columns to join - * @Param rightcol The right set of columns to join - * @Param l_result The join computed indices of the left table - * @Param r_result The join computed indices of the right table + * @Param[in] num_cols The number of columns to join + * @Param[in] leftcol The left set of columns to join + * @Param[in] rightcol The right set of columns to join + * @Param[out] l_result The join computed indices of the left table + * @Param[out] r_result The join computed indices of the right table * @tparam join_type The type of join to be performed * @tparam size_type The data type used for size calculations * @@ -121,19 +121,19 @@ gdf_error sort_join_typed(gdf_column *leftcol, gdf_column *rightcol, /* --------------------------------------------------------------------------*/ /** - * @Synopsis Computes the join operation between a single left and single right column - using the sort based implementation. + * @brief Computes the join operation between a single left and single right column + * using the sort based implementation. * - * @Param leftcol The left column to join - * @Param rightcol The right column to join - * @Param left_result The join computed indices of the left table - * @Param right_result The join computed indices of the right table - * @Param ctxt Structure that determines various run parameters, such as if the inputs - are already sorted. - @tparama join_type The type of join to perform + * @Param[in] leftcol The left column to join + * @Param[in] rightcol The right column to join + * @Param[out] left_result The join computed indices of the left table + * @Param[out] right_result The join computed indices of the right table + * @Param[in] ctxt Structure that determines various run parameters, such as if the inputs + * are already sorted. + * @tparama join_type The type of join to perform * * @Returns GDF_SUCCESS upon succesful completion of the join, otherwise returns - appropriate error code. + * appropriate error code. */ /* ----------------------------------------------------------------------------*/ template @@ -169,14 +169,16 @@ gdf_error sort_join(gdf_column *leftcol, gdf_column *rightc /* --------------------------------------------------------------------------*/ /** -* @Synopsis Allocates a buffer and fills it with a repeated value -* -* @Param buffer Address of the buffer to be allocated -* @Param buffer_length Amount of memory to be allocated -* @Param value The value to be filled into the buffer -* @tparam data_type The data type to be used for the buffer -* @tparam size_type The data type used for size calculations -*/ + * @brief Allocates a buffer and fills it with a repeated value + * + * @Param[in,out] buffer Address of the buffer to be allocated + * @Param[in] buffer_length Amount of memory to be allocated + * @Param[in] value The value to be filled into the buffer + * @tparam data_type The data type to be used for the buffer + * @tparam size_type The data type used for size calculations + * + * @Returns GDF_SUCCESS upon succesful completion + */ /* ----------------------------------------------------------------------------*/ template @@ -191,13 +193,15 @@ gdf_error allocValueBuffer(data_type ** buffer, /* --------------------------------------------------------------------------*/ /** -* @Synopsis Allocates a buffer and fills it with a sequence -* -* @Param buffer Address of the buffer to be allocated -* @Param buffer_length Amount of memory to be allocated -* @tparam data_type The data type to be used for the buffer -* @tparam size_type The data type used for size calculations -*/ + * @brief Allocates a buffer and fills it with a sequence + * + * @Param[in,out] buffer Address of the buffer to be allocated + * @Param[in] buffer_length Amount of memory to be allocated + * @tparam data_type The data type to be used for the buffer + * @tparam size_type The data type used for size calculations + * + * @Returns GDF_SUCCESS upon succesful completion + */ /* ----------------------------------------------------------------------------*/ template @@ -211,14 +215,14 @@ gdf_error allocSequenceBuffer(data_type ** buffer, /* --------------------------------------------------------------------------*/ /** - * @Synopsis Trivially computes full join of two tables if one of the tables - are empty + * @brief Trivially computes full join of two tables if one of the tables + * are empty * - * @Param left_size The size of the left table - * @Param right_size The size of the right table - * @Param rightcol The right set of columns to join - * @Param left_result The join computed indices of the left table - * @Param right_result The join computed indices of the right table + * @Param[in] left_size The size of the left table + * @Param[in] right_size The size of the right table + * @Param[in] rightcol The right set of columns to join + * @Param[out] left_result The join computed indices of the left table + * @Param[out] right_result The join computed indices of the right table * @tparam size_type The data type used for size calculations * * @Returns GDF_SUCCESS upon succesfull compute, otherwise returns appropriate error code @@ -265,15 +269,15 @@ gdf_error trivial_full_join( /* --------------------------------------------------------------------------*/ /** - * @Synopsis Computes the join operation between two sets of columns + * @brief Computes the join operation between two sets of columns * - * @Param num_cols The number of columns to join - * @Param leftcol The left set of columns to join - * @Param rightcol The right set of columns to join - * @Param left_result The join computed indices of the left table - * @Param right_result The join computed indices of the right table - * @Param join_context A structure that determines various run parameters, such as - whether to perform a hash or sort based join + * @Param[in] num_cols The number of columns to join + * @Param[in] leftcol The left set of columns to join + * @Param[in] rightcol The right set of columns to join + * @Param[out] left_result The join computed indices of the left table + * @Param[out] right_result The join computed indices of the right table + * @Param[in] join_context A structure that determines various run parameters, such as + * whether to perform a hash or sort based join * @tparam join_type The type of join to be performed * * @Returns GDF_SUCCESS upon succesfull compute, otherwise returns appropriate error code From c9cba05e67960e6ecc70930c232ccf69e1b5f923 Mon Sep 17 00:00:00 2001 From: William Malpica Date: Wed, 30 Jan 2019 19:33:00 -0600 Subject: [PATCH 2/4] fixed compile time issue. added to the CHANGELOG --- CHANGELOG.md | 1 + cpp/src/dataframe/cudf_table.cuh | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 9e56c3079949..b6c28c5448b4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,7 @@ ## Improvements - PR #730 Improve performance of `gdf_table` constructor +- PR #561 Add Doxygen style comments to Join CUDA functions ## Bug Fixes diff --git a/cpp/src/dataframe/cudf_table.cuh b/cpp/src/dataframe/cudf_table.cuh index f5d1d46f7a3e..36e7f7b035ca 100644 --- a/cpp/src/dataframe/cudf_table.cuh +++ b/cpp/src/dataframe/cudf_table.cuh @@ -319,7 +319,7 @@ public: thrust::tabulate(rmm::exec_policy()->on(0), device_row_valid.begin(), device_row_valid.end(), - row_masker(d_columns_valids, num_cols)); + row_masker(d_columns_valids_ptr, num_cols)); d_row_valid = device_row_valid.data().get(); } From cc68168a8ab5d82f8d2a64dce2fd629ce9e0c72c Mon Sep 17 00:00:00 2001 From: William Malpica Date: Mon, 25 Feb 2019 13:36:00 -0600 Subject: [PATCH 3/4] changed @Param to @param --- cpp/include/cudf/functions.h | 1012 +++++++++++++++++----------------- cpp/src/join/joining.cu | 52 +- 2 files changed, 532 insertions(+), 532 deletions(-) diff --git a/cpp/include/cudf/functions.h b/cpp/include/cudf/functions.h index c03fe6cd3304..d07f8119b997 100644 --- a/cpp/include/cudf/functions.h +++ b/cpp/include/cudf/functions.h @@ -9,8 +9,8 @@ * color that will show up in the timeline view of nvvp/Nsight Systems. Can be * nested within other ranges. * - * @Param[in] name The name of the NVTX range - * @Param[in] color The predefined gdf_color enum to use to color this range + * @param[in] name The name of the NVTX range + * @param[in] color The predefined gdf_color enum to use to color this range * * @Returns */ @@ -29,8 +29,8 @@ gdf_error gdf_nvtx_range_push(char const * const name, gdf_color color ); * color that will show up in the timeline view of nvvp/Nsight Systems. Can be * nested within other ranges. * - * @Param[in] name The name of the NVTX range - * @Param[in] color The ARGB hex color code to use to color this range (e.g., 0xFF00FF00) + * @param[in] name The name of the NVTX range + * @param[in] color The ARGB hex color code to use to color this range (e.g., 0xFF00FF00) * * @Returns */ @@ -56,10 +56,10 @@ gdf_error gdf_nvtx_range_pop(); * @brief Counts the number of valid bits in the mask that corresponds to * the specified number of rows. * - * @Param[in] masks Array of gdf_valid_types with enough bits to represent + * @param[in] masks Array of gdf_valid_types with enough bits to represent * num_rows number of rows - * @Param[in] num_rows The number of rows represented in the bit-validity mask. - * @Param[out] count The number of valid rows in the mask + * @param[in] num_rows The number of rows represented in the bit-validity mask. + * @param[out] count The number of valid rows in the mask * * @Returns GDF_SUCCESS upon successful completion. */ @@ -84,11 +84,11 @@ gdf_size_type gdf_column_sizeof(); * @brief Create a GDF column given data and validity bitmask pointers, size, and * datatype * - * @Param[out] column The output column. - * @Param[in] data Pointer to data. - * @Param[in] valid Pointer to validity bitmask for the data. - * @Param[in] size Number of rows in the column. - * @Param[in] dtype Data type of the column. + * @param[out] column The output column. + * @param[in] data Pointer to data. + * @param[in] valid Pointer to validity bitmask for the data. + * @param[in] size Number of rows in the column. + * @param[in] dtype Data type of the column. * * @Returns gdf_error Returns GDF_SUCCESS upon successful creation. */ @@ -101,12 +101,12 @@ gdf_error gdf_column_view(gdf_column *column, void *data, gdf_valid_type *valid, * @brief Create a GDF column given data and validity bitmask pointers, size, and * datatype, and count of null (non-valid) elements * - * @Param[out] column The output column. - * @Param[in] data Pointer to data. - * @Param[in] valid Pointer to validity bitmask for the data. - * @Param[in] size Number of rows in the column. - * @Param[in] dtype Data type of the column. - * @Param[in] null_count The number of non-valid elements in the validity bitmask + * @param[out] column The output column. + * @param[in] data Pointer to data. + * @param[in] valid Pointer to validity bitmask for the data. + * @param[in] size Number of rows in the column. + * @param[in] dtype Data type of the column. + * @param[in] null_count The number of non-valid elements in the validity bitmask * * @Returns gdf_error Returns GDF_SUCCESS upon successful creation. */ @@ -130,9 +130,9 @@ gdf_error gdf_column_free(gdf_column *column); * @brief Concatenates the gdf_columns into a single, contiguous column, * including the validity bitmasks * - * @Param[out] output A column whose buffers are already allocated that will - * @Param[in] columns_to_conat[] The columns to concatenate - * @Param[in] num_columns The number of columns to concatenate + * @param[out] output A column whose buffers are already allocated that will + * @param[in] columns_to_conat[] The columns to concatenate + * @param[in] num_columns The number of columns to concatenate * contain the concatenation of the input columns * * @Returns GDF_SUCCESS upon successful completion @@ -147,10 +147,10 @@ gdf_error gdf_column_concat(gdf_column *output, gdf_column *columns_to_concat[], /** * @brief Constructor for the gdf_context struct * - * @Param[out] gdf_context being constructed - * @Param[in] Indicates if the input data is sorted. 0 = No, 1 = yes - * @Param[in] the method to be used for the operation (e.g., sort vs hash) - * @Param[in] for COUNT: DISTINCT = 1, else = 0 + * @param[out] gdf_context being constructed + * @param[in] Indicates if the input data is sorted. 0 = No, 1 = yes + * @param[in] the method to be used for the operation (e.g., sort vs hash) + * @param[in] for COUNT: DISTINCT = 1, else = 0 * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -165,7 +165,7 @@ gdf_error gdf_context_view(gdf_context *context, int flag_sorted, gdf_method fla /** * @brief Converts a gdf_error error code into a string * - * @Param[in] gdf_error + * @param[in] gdf_error * * @Returns name of the error */ @@ -185,7 +185,7 @@ int gdf_cuda_last_error(); /** * @brief Returns the description string for an error code. * - * @Param[in] cuda error code + * @param[in] cuda error code * * @Returns description string for an error code. */ @@ -196,7 +196,7 @@ const char * gdf_cuda_error_string(int cuda_error); /** * @brief Returns the string representation of an error code enum name. * - * @Param[in] cuda error code + * @param[in] cuda error code * * @Returns string representation of an error code enum name. */ @@ -210,8 +210,8 @@ const char * gdf_cuda_error_name(int cuda_error); /** * @brief Opens a parser from a pyarrow RecordBatch schema * - * @Param[in] Pointer to a byte array containing the pyarrow RecordBatch schema - * @Param[in] Size of the byte array + * @param[in] Pointer to a byte array containing the pyarrow RecordBatch schema + * @param[in] Size of the byte array * * @Returns Pointer to a parsing struct gdf_ipc_parser_type */ @@ -222,9 +222,9 @@ gdf_ipc_parser_type* gdf_ipc_parser_open(const uint8_t *schema, size_t length); /** * @brief Opens a pyarrow RecordBatch bytearray * - * @Param[in] Pointer to a parsing struct gdf_ipc_parser_type - * @Param[in] Pointer to a pyarrow RecordBatch bytearray - * @Param[in] Size of the byte array + * @param[in] Pointer to a parsing struct gdf_ipc_parser_type + * @param[in] Pointer to a pyarrow RecordBatch bytearray + * @param[in] Size of the byte array * * @Returns */ @@ -237,7 +237,7 @@ void gdf_ipc_parser_open_recordbatches(gdf_ipc_parser_type *handle, /** * @brief Closes a parser from a pyarrow RecordBatch schema * - * @Param[in] Pointer to a parsing struct gdf_ipc_parser_type + * @param[in] Pointer to a parsing struct gdf_ipc_parser_type * * @Returns void */ @@ -248,7 +248,7 @@ void gdf_ipc_parser_close(gdf_ipc_parser_type *handle); /** * @brief Checks for a failure in the parser * - * @Param[in] Pointer to a parsing struct gdf_ipc_parser_type + * @param[in] Pointer to a parsing struct gdf_ipc_parser_type * * @Returns 1 if error */ @@ -259,7 +259,7 @@ int gdf_ipc_parser_failed(gdf_ipc_parser_type *handle); /** * @brief Returns parsed data as json * - * @Param[in] Pointer to a parsing struct gdf_ipc_parser_type + * @param[in] Pointer to a parsing struct gdf_ipc_parser_type * * @Returns char* of parsed data as json */ @@ -270,7 +270,7 @@ const char* gdf_ipc_parser_to_json(gdf_ipc_parser_type *handle); /** * @brief Gets error from gdf_ipc_parser_type * - * @Param[in] Pointer to a parsing struct gdf_ipc_parser_type + * @param[in] Pointer to a parsing struct gdf_ipc_parser_type * * @Returns Error message as char* */ @@ -281,7 +281,7 @@ const char* gdf_ipc_parser_get_error(gdf_ipc_parser_type *handle); /** * @brief Gets parsed data from gdf_ipc_parser_type * - * @Param[in] Pointer to a parsing struct gdf_ipc_parser_type + * @param[in] Pointer to a parsing struct gdf_ipc_parser_type * * @Returns Pointer parsed data */ @@ -292,7 +292,7 @@ const void* gdf_ipc_parser_get_data(gdf_ipc_parser_type *handle); /** * @brief Gets data offset from gdf_ipc_parser_type * - * @Param[in] Pointer to a parsing struct gdf_ipc_parser_type + * @param[in] Pointer to a parsing struct gdf_ipc_parser_type * * @Returns Data offset */ @@ -303,7 +303,7 @@ int64_t gdf_ipc_parser_get_data_offset(gdf_ipc_parser_type *handle); /** * @brief Returns parsed schema as json * - * @Param[in] Pointer to a parsing struct gdf_ipc_parser_type + * @param[in] Pointer to a parsing struct gdf_ipc_parser_type * * @Returns char* of parsed schema as json */ @@ -314,7 +314,7 @@ const char *gdf_ipc_parser_get_schema_json(gdf_ipc_parser_type *handle); /** * @brief Returns layout as json * - * @Param[in] Pointer to a parsing struct gdf_ipc_parser_type + * @param[in] Pointer to a parsing struct gdf_ipc_parser_type * * @Returns char* of layout as json */ @@ -328,10 +328,10 @@ const char *gdf_ipc_parser_get_layout_json(gdf_ipc_parser_type *handle); /** * @brief Constructor for the gdf_radixsort_plan_type object * - * @Param[in] Number of items to sort - * @Param[in] Indicates if sort should be ascending or descending. 1 = Descending, 0 = Ascending - * @Param[in] The least-significant bit index (inclusive) needed for key comparison - * @Param[in] The most-significant bit index (exclusive) needed for key comparison (e.g., sizeof(unsigned int) * 8) + * @param[in] Number of items to sort + * @param[in] Indicates if sort should be ascending or descending. 1 = Descending, 0 = Ascending + * @param[in] The least-significant bit index (inclusive) needed for key comparison + * @param[in] The most-significant bit index (exclusive) needed for key comparison (e.g., sizeof(unsigned int) * 8) * * @Returns gdf_radixsort_plan_type object pointer */ @@ -343,9 +343,9 @@ gdf_radixsort_plan_type* gdf_radixsort_plan(size_t num_items, int descending, /** * @brief Allocates device memory for the radixsort * - * @Param[in] Radix sort plan - * @Param[in] sizeof data type of key - * @Param[in] sizeof data type of val + * @param[in] Radix sort plan + * @param[in] sizeof data type of key + * @param[in] sizeof data type of val * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -357,7 +357,7 @@ gdf_error gdf_radixsort_plan_setup(gdf_radixsort_plan_type *hdl, /** * @brief Frees device memory used for the radixsort * - * @Param[in] Radix sort plan + * @param[in] Radix sort plan * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -375,9 +375,9 @@ gdf_error gdf_radixsort_plan_free(gdf_radixsort_plan_type *hdl); /** * @brief Performs a radixsort on the key and value columns where the key is an int8 * - * @Param[in] Radix sort plan - * @Param[in] key gdf_column - * @Param[in] value gdf_column + * @param[in] Radix sort plan + * @param[in] key gdf_column + * @param[in] value gdf_column * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -390,9 +390,9 @@ gdf_error gdf_radixsort_i8(gdf_radixsort_plan_type *hdl, /** * @brief Performs a radixsort on the key and value columns where the key is an int32 * - * @Param[in] Radix sort plan - * @Param[in] key gdf_column - * @Param[in] value gdf_column + * @param[in] Radix sort plan + * @param[in] key gdf_column + * @param[in] value gdf_column * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -405,9 +405,9 @@ gdf_error gdf_radixsort_i32(gdf_radixsort_plan_type *hdl, /** * @brief performs a radixsort on the key and value columns where the key is an int64 * - * @Param[in] Radix sort plan - * @Param[in] key gdf_column - * @Param[in] value gdf_column + * @param[in] Radix sort plan + * @param[in] key gdf_column + * @param[in] value gdf_column * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -420,9 +420,9 @@ gdf_error gdf_radixsort_i64(gdf_radixsort_plan_type *hdl, /** * @brief performs a radixsort on the key and value columns where the key is an float * - * @Param[in] Radix sort plan - * @Param[in] key gdf_column - * @Param[in] value gdf_column + * @param[in] Radix sort plan + * @param[in] key gdf_column + * @param[in] value gdf_column * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -435,9 +435,9 @@ gdf_error gdf_radixsort_f32(gdf_radixsort_plan_type *hdl, /** * @brief performs a radixsort on the key and value columns where the key is an double * - * @Param[in] Radix sort plan - * @Param[in] key gdf_column - * @Param[in] value gdf_column + * @param[in] Radix sort plan + * @param[in] key gdf_column + * @param[in] value gdf_column * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -450,9 +450,9 @@ gdf_error gdf_radixsort_f64(gdf_radixsort_plan_type *hdl, /** * @brief performs a radixsort on the key and value columns where the key is any type * - * @Param[in] Radix sort plan - * @Param[in] key gdf_column - * @Param[in] value gdf_column + * @param[in] Radix sort plan + * @param[in] key gdf_column + * @param[in] value gdf_column * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -468,10 +468,10 @@ gdf_error gdf_radixsort_generic(gdf_radixsort_plan_type *hdl, /** * @brief Constructor for the gdf_segmented_radixsort_plan_type object * - * @Param[in] Number of items to sort - * @Param[in] Indicates if sort should be ascending or descending. 1 = Descending, 0 = Ascending - * @Param[in] The least-significant bit index (inclusive) needed for key comparison - * @Param[in] The most-significant bit index (exclusive) needed for key comparison (e.g., sizeof(unsigned int) * 8) + * @param[in] Number of items to sort + * @param[in] Indicates if sort should be ascending or descending. 1 = Descending, 0 = Ascending + * @param[in] The least-significant bit index (inclusive) needed for key comparison + * @param[in] The most-significant bit index (exclusive) needed for key comparison (e.g., sizeof(unsigned int) * 8) * * @Returns gdf_segmented_radixsort_plan_type object pointer */ @@ -485,9 +485,9 @@ gdf_segmented_radixsort_plan_type* gdf_segmented_radixsort_plan(size_t num_items /** * @brief Allocates device memory for the segmented radixsort * - * @Param[in] Segmented Radix sort plan - * @Param[in] sizeof data type of key - * @Param[in] sizeof data type of val + * @param[in] Segmented Radix sort plan + * @param[in] sizeof data type of key + * @param[in] sizeof data type of val * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -500,7 +500,7 @@ gdf_error gdf_segmented_radixsort_plan_setup(gdf_segmented_radixsort_plan_type * /** * @brief Frees device memory used for the segmented radixsort * - * @Param[in] Segmented Radix sort plan + * @param[in] Segmented Radix sort plan * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -518,12 +518,12 @@ gdf_error gdf_segmented_radixsort_plan_free(gdf_segmented_radixsort_plan_type *h /** * @brief performs a segmented radixsort on the key and value columns where the key is an int8 * - * @Param[in] Radix sort plan - * @Param[in] key gdf_column - * @Param[in] value gdf_column - * @Param[in] The number of segments that comprise the sorting data - * @Param[in] Pointer to the sequence of beginning offsets of length num_segments, such that d_begin_offsets[i] is the first element of the ith data segment in d_keys_* and d_values_* - * @Param[in] Pointer to the sequence of ending offsets of length num_segments, such that d_end_offsets[i]-1 is the last element of the ith data segment in d_keys_* and d_values_*. If d_end_offsets[i]-1 <= d_begin_offsets[i], the ith is considered empty. + * @param[in] Radix sort plan + * @param[in] key gdf_column + * @param[in] value gdf_column + * @param[in] The number of segments that comprise the sorting data + * @param[in] Pointer to the sequence of beginning offsets of length num_segments, such that d_begin_offsets[i] is the first element of the ith data segment in d_keys_* and d_values_* + * @param[in] Pointer to the sequence of ending offsets of length num_segments, such that d_end_offsets[i]-1 is the last element of the ith data segment in d_keys_* and d_values_*. If d_end_offsets[i]-1 <= d_begin_offsets[i], the ith is considered empty. * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -538,12 +538,12 @@ gdf_error gdf_segmented_radixsort_i8(gdf_segmented_radixsort_plan_type *hdl, /** * @brief performs a segmented radixsort on the key and value columns where the key is an int32 * - * @Param[in] Radix sort plan - * @Param[in] key gdf_column - * @Param[in] value gdf_column - * @Param[in] The number of segments that comprise the sorting data - * @Param[in] Pointer to the sequence of beginning offsets of length num_segments, such that d_begin_offsets[i] is the first element of the ith data segment in d_keys_* and d_values_* - * @Param[in] Pointer to the sequence of ending offsets of length num_segments, such that d_end_offsets[i]-1 is the last element of the ith data segment in d_keys_* and d_values_*. If d_end_offsets[i]-1 <= d_begin_offsets[i], the ith is considered empty. + * @param[in] Radix sort plan + * @param[in] key gdf_column + * @param[in] value gdf_column + * @param[in] The number of segments that comprise the sorting data + * @param[in] Pointer to the sequence of beginning offsets of length num_segments, such that d_begin_offsets[i] is the first element of the ith data segment in d_keys_* and d_values_* + * @param[in] Pointer to the sequence of ending offsets of length num_segments, such that d_end_offsets[i]-1 is the last element of the ith data segment in d_keys_* and d_values_*. If d_end_offsets[i]-1 <= d_begin_offsets[i], the ith is considered empty. * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -558,12 +558,12 @@ gdf_error gdf_segmented_radixsort_i32(gdf_segmented_radixsort_plan_type *hdl, /** * @brief performs a segmented radixsort on the key and value columns where the key is an int64 * - * @Param[in] Radix sort plan - * @Param[in] key gdf_column - * @Param[in] value gdf_column - * @Param[in] The number of segments that comprise the sorting data - * @Param[in] Pointer to the sequence of beginning offsets of length num_segments, such that d_begin_offsets[i] is the first element of the ith data segment in d_keys_* and d_values_* - * @Param[in] Pointer to the sequence of ending offsets of length num_segments, such that d_end_offsets[i]-1 is the last element of the ith data segment in d_keys_* and d_values_*. If d_end_offsets[i]-1 <= d_begin_offsets[i], the ith is considered empty. + * @param[in] Radix sort plan + * @param[in] key gdf_column + * @param[in] value gdf_column + * @param[in] The number of segments that comprise the sorting data + * @param[in] Pointer to the sequence of beginning offsets of length num_segments, such that d_begin_offsets[i] is the first element of the ith data segment in d_keys_* and d_values_* + * @param[in] Pointer to the sequence of ending offsets of length num_segments, such that d_end_offsets[i]-1 is the last element of the ith data segment in d_keys_* and d_values_*. If d_end_offsets[i]-1 <= d_begin_offsets[i], the ith is considered empty. * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -578,12 +578,12 @@ gdf_error gdf_segmented_radixsort_i64(gdf_segmented_radixsort_plan_type *hdl, /** * @brief performs a segmented radixsort on the key and value columns where the key is an float * - * @Param[in] Radix sort plan - * @Param[in] key gdf_column - * @Param[in] value gdf_column - * @Param[in] The number of segments that comprise the sorting data - * @Param[in] Pointer to the sequence of beginning offsets of length num_segments, such that d_begin_offsets[i] is the first element of the ith data segment in d_keys_* and d_values_* - * @Param[in] Pointer to the sequence of ending offsets of length num_segments, such that d_end_offsets[i]-1 is the last element of the ith data segment in d_keys_* and d_values_*. If d_end_offsets[i]-1 <= d_begin_offsets[i], the ith is considered empty. + * @param[in] Radix sort plan + * @param[in] key gdf_column + * @param[in] value gdf_column + * @param[in] The number of segments that comprise the sorting data + * @param[in] Pointer to the sequence of beginning offsets of length num_segments, such that d_begin_offsets[i] is the first element of the ith data segment in d_keys_* and d_values_* + * @param[in] Pointer to the sequence of ending offsets of length num_segments, such that d_end_offsets[i]-1 is the last element of the ith data segment in d_keys_* and d_values_*. If d_end_offsets[i]-1 <= d_begin_offsets[i], the ith is considered empty. * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -598,12 +598,12 @@ gdf_error gdf_segmented_radixsort_f32(gdf_segmented_radixsort_plan_type *hdl, /** * @brief performs a segmented radixsort on the key and value columns where the key is an double * - * @Param[in] Radix sort plan - * @Param[in] key gdf_column - * @Param[in] value gdf_column - * @Param[in] The number of segments that comprise the sorting data - * @Param[in] Pointer to the sequence of beginning offsets of length num_segments, such that d_begin_offsets[i] is the first element of the ith data segment in d_keys_* and d_values_* - * @Param[in] Pointer to the sequence of ending offsets of length num_segments, such that d_end_offsets[i]-1 is the last element of the ith data segment in d_keys_* and d_values_*. If d_end_offsets[i]-1 <= d_begin_offsets[i], the ith is considered empty. + * @param[in] Radix sort plan + * @param[in] key gdf_column + * @param[in] value gdf_column + * @param[in] The number of segments that comprise the sorting data + * @param[in] Pointer to the sequence of beginning offsets of length num_segments, such that d_begin_offsets[i] is the first element of the ith data segment in d_keys_* and d_values_* + * @param[in] Pointer to the sequence of ending offsets of length num_segments, such that d_end_offsets[i]-1 is the last element of the ith data segment in d_keys_* and d_values_*. If d_end_offsets[i]-1 <= d_begin_offsets[i], the ith is considered empty. * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -618,12 +618,12 @@ gdf_error gdf_segmented_radixsort_f64(gdf_segmented_radixsort_plan_type *hdl, /** * @brief performs a segmented radixsort on the key and value columns where the key is any type * - * @Param[in] Radix sort plan - * @Param[in] key gdf_column - * @Param[in] value gdf_column - * @Param[in] The number of segments that comprise the sorting data - * @Param[in] Pointer to the sequence of beginning offsets of length num_segments, such that d_begin_offsets[i] is the first element of the ith data segment in d_keys_* and d_values_* - * @Param[in] Pointer to the sequence of ending offsets of length num_segments, such that d_end_offsets[i]-1 is the last element of the ith data segment in d_keys_* and d_values_*. If d_end_offsets[i]-1 <= d_begin_offsets[i], the ith is considered empty. + * @param[in] Radix sort plan + * @param[in] key gdf_column + * @param[in] value gdf_column + * @param[in] The number of segments that comprise the sorting data + * @param[in] Pointer to the sequence of beginning offsets of length num_segments, such that d_begin_offsets[i] is the first element of the ith data segment in d_keys_* and d_values_* + * @param[in] Pointer to the sequence of ending offsets of length num_segments, such that d_end_offsets[i]-1 is the last element of the ith data segment in d_keys_* and d_values_*. If d_end_offsets[i]-1 <= d_begin_offsets[i], the ith is considered empty. * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -660,21 +660,21 @@ gdf_error gdf_transpose(gdf_size_type ncols, * columns must be set to 0 otherwise a GDF_VALIDITY_UNSUPPORTED error is * returned. * - * @Param[in] left_cols[] The columns of the left dataframe - * @Param[in] num_left_cols The number of columns in the left dataframe - * @Param[in] left_join_cols[] The column indices of columns from the left dataframe + * @param[in] left_cols[] The columns of the left dataframe + * @param[in] num_left_cols The number of columns in the left dataframe + * @param[in] left_join_cols[] The column indices of columns from the left dataframe * to join on - * @Param[in] right_cols[] The columns of the right dataframe - * @Param[in] num_right_cols The number of columns in the right dataframe - * @Param[in] right_join_cols[] The column indices of columns from the right dataframe + * @param[in] right_cols[] The columns of the right dataframe + * @param[in] num_right_cols The number of columns in the right dataframe + * @param[in] right_join_cols[] The column indices of columns from the right dataframe * to join on - * @Param[in] num_cols_to_join The total number of columns to join on - * @Param[in] result_num_cols The number of columns in the resulting dataframe - * @Param[out] gdf_column *result_cols[] If not nullptr, the dataframe that results from joining + * @param[in] num_cols_to_join The total number of columns to join on + * @param[in] result_num_cols The number of columns in the resulting dataframe + * @param[out] gdf_column *result_cols[] If not nullptr, the dataframe that results from joining * the left and right tables on the specified columns - * @Param[out] gdf_column * left_indices If not nullptr, indices of rows from the left table that match rows in the right table - * @Param[out] gdf_column * right_indices If not nullptr, indices of rows from the right table that match rows in the left table - * @Param[in] join_context The context to use to control how the join is performed,e.g., + * @param[out] gdf_column * left_indices If not nullptr, indices of rows from the left table that match rows in the right table + * @param[out] gdf_column * right_indices If not nullptr, indices of rows from the right table that match rows in the left table + * @param[in] join_context The context to use to control how the join is performed,e.g., * sort vs hash based implementation * * @Returns GDF_SUCCESS if the join operation was successful, otherwise an appropriate @@ -703,21 +703,21 @@ gdf_error gdf_inner_join( * columns must be set to 0 otherwise a GDF_VALIDITY_UNSUPPORTED error is * returned. * - * @Param[in] left_cols[] The columns of the left dataframe - * @Param[in] num_left_cols The number of columns in the left dataframe - * @Param[in] left_join_cols[] The column indices of columns from the left dataframe + * @param[in] left_cols[] The columns of the left dataframe + * @param[in] num_left_cols The number of columns in the left dataframe + * @param[in] left_join_cols[] The column indices of columns from the left dataframe * to join on - * @Param[in] right_cols[] The columns of the right dataframe - * @Param[in] num_right_cols The number of columns in the right dataframe - * @Param[in] right_join_cols[] The column indices of columns from the right dataframe + * @param[in] right_cols[] The columns of the right dataframe + * @param[in] num_right_cols The number of columns in the right dataframe + * @param[in] right_join_cols[] The column indices of columns from the right dataframe * to join on - * @Param[in] num_cols_to_join The total number of columns to join on - * @Param[in] result_num_cols The number of columns in the resulting dataframe - * @Param[out] gdf_column *result_cols[] If not nullptr, the dataframe that results from joining + * @param[in] num_cols_to_join The total number of columns to join on + * @param[in] result_num_cols The number of columns in the resulting dataframe + * @param[out] gdf_column *result_cols[] If not nullptr, the dataframe that results from joining * the left and right tables on the specified columns - * @Param[out] gdf_column * left_indices If not nullptr, indices of rows from the left table that match rows in the right table - * @Param[out] gdf_column * right_indices If not nullptr, indices of rows from the right table that match rows in the left table - * @Param[in] join_context The context to use to control how the join is performed,e.g., + * @param[out] gdf_column * left_indices If not nullptr, indices of rows from the left table that match rows in the right table + * @param[out] gdf_column * right_indices If not nullptr, indices of rows from the right table that match rows in the left table + * @param[in] join_context The context to use to control how the join is performed,e.g., * sort vs hash based implementation * * @Returns GDF_SUCCESS if the join operation was successful, otherwise an appropriate @@ -746,21 +746,21 @@ gdf_error gdf_left_join( * columns must be set to 0 otherwise a GDF_VALIDITY_UNSUPPORTED error is * returned. * - * @Param[in] left_cols[] The columns of the left dataframe - * @Param[in] num_left_cols The number of columns in the left dataframe - * @Param[in] left_join_cols[] The column indices of columns from the left dataframe + * @param[in] left_cols[] The columns of the left dataframe + * @param[in] num_left_cols The number of columns in the left dataframe + * @param[in] left_join_cols[] The column indices of columns from the left dataframe * to join on - * @Param[in] right_cols[] The columns of the right dataframe - * @Param[in] num_right_cols The number of columns in the right dataframe - * @Param[in] right_join_cols[] The column indices of columns from the right dataframe + * @param[in] right_cols[] The columns of the right dataframe + * @param[in] num_right_cols The number of columns in the right dataframe + * @param[in] right_join_cols[] The column indices of columns from the right dataframe * to join on - * @Param[in] num_cols_to_join The total number of columns to join on - * @Param[in] result_num_cols The number of columns in the resulting dataframe - * @Param[out] gdf_column *result_cols[] If not nullptr, the dataframe that results from joining + * @param[in] num_cols_to_join The total number of columns to join on + * @param[in] result_num_cols The number of columns in the resulting dataframe + * @param[out] gdf_column *result_cols[] If not nullptr, the dataframe that results from joining * the left and right tables on the specified columns - * @Param[out] gdf_column * left_indices If not nullptr, indices of rows from the left table that match rows in the right table - * @Param[out] gdf_column * right_indices If not nullptr, indices of rows from the right table that match rows in the left table - * @Param[in] join_context The context to use to control how the join is performed,e.g., + * @param[out] gdf_column * left_indices If not nullptr, indices of rows from the left table that match rows in the right table + * @param[out] gdf_column * right_indices If not nullptr, indices of rows from the right table that match rows in the left table + * @param[in] join_context The context to use to control how the join is performed,e.g., * sort vs hash based implementation * * @Returns GDF_SUCCESS if the join operation was successful, otherwise an appropriate @@ -790,17 +790,17 @@ gdf_error gdf_full_join( * Rearranges the input columns such that rows with hash values in the same bin * are contiguous. * - * @Param[in] num_input_cols The number of columns in the input columns - * @Param[in] input[] The input set of columns - * @Param[in] columns_to_hash[] Indices of the columns in the input set to hash - * @Param[in] num_cols_to_hash The number of columns to hash - * @Param[in] num_partitions The number of partitions to rearrange the input rows into - * @Param[out] partitioned_output Preallocated gdf_columns to hold the rearrangement + * @param[in] num_input_cols The number of columns in the input columns + * @param[in] input[] The input set of columns + * @param[in] columns_to_hash[] Indices of the columns in the input set to hash + * @param[in] num_cols_to_hash The number of columns to hash + * @param[in] num_partitions The number of partitions to rearrange the input rows into + * @param[out] partitioned_output Preallocated gdf_columns to hold the rearrangement * of the input columns into the desired number of partitions - * @Param[out] partition_offsets Preallocated array the size of the number of + * @param[out] partition_offsets Preallocated array the size of the number of * partitions. Where partition_offsets[i] indicates the starting position * of partition 'i' - * @Param[in] hash The hash function to use + * @param[in] hash The hash function to use * * @Returns If the operation was successful, returns GDF_SUCCESS */ @@ -820,9 +820,9 @@ gdf_error gdf_hash_partition(int num_input_cols, /** * @brief Computes the prefix sum of a column * - * @Param[in] inp Input column for prefix sum with null_count = 0 - * @Param[out] out The output column containing the prefix sum of the input - * @Param[in] inclusive Flag for applying an inclusive prefix sum + * @param[in] inp Input column for prefix sum with null_count = 0 + * @param[out] out The output column containing the prefix sum of the input + * @param[in] inclusive Flag for applying an inclusive prefix sum * * @Returns GDF_SUCCESS if the operation was successful, otherwise an appropriate * error code. If inp->null_count is not set to 0 GDF_VALIDITY_UNSUPPORTED is @@ -835,9 +835,9 @@ gdf_error gdf_prefixsum_generic(gdf_column *inp, gdf_column *out, int inclusive) /** * @brief Computes the prefix sum of a column * - * @Param[in] inp Input column for prefix sum with null_count = 0 - * @Param[out] out The output column containing the prefix sum of the input - * @Param[in] inclusive Flag for applying an inclusive prefix sum + * @param[in] inp Input column for prefix sum with null_count = 0 + * @param[out] out The output column containing the prefix sum of the input + * @param[in] inclusive Flag for applying an inclusive prefix sum * * @Returns GDF_SUCCESS if the operation was successful, otherwise an appropriate * error code. If inp->null_count is not set to 0 GDF_VALIDITY_UNSUPPORTED is @@ -850,9 +850,9 @@ gdf_error gdf_prefixsum_i8(gdf_column *inp, gdf_column *out, int inclusive); /** * @brief Computes the prefix sum of a column * - * @Param[in] inp Input column for prefix sum with null_count = 0 - * @Param[out] out The output column containing the prefix sum of the input - * @Param[in] inclusive Flag for applying an inclusive prefix sum + * @param[in] inp Input column for prefix sum with null_count = 0 + * @param[out] out The output column containing the prefix sum of the input + * @param[in] inclusive Flag for applying an inclusive prefix sum * * @Returns GDF_SUCCESS if the operation was successful, otherwise an appropriate * error code. If inp->null_count is not set to 0 GDF_VALIDITY_UNSUPPORTED is @@ -865,9 +865,9 @@ gdf_error gdf_prefixsum_i32(gdf_column *inp, gdf_column *out, int inclusive); /** * @brief Computes the prefix sum of a column * - * @Param[in] inp Input column for prefix sum with null_count = 0 - * @Param[out] out The output column containing the prefix sum of the input - * @Param[in] inclusive Flag for applying an inclusive prefix sum + * @param[in] inp Input column for prefix sum with null_count = 0 + * @param[out] out The output column containing the prefix sum of the input + * @param[in] inclusive Flag for applying an inclusive prefix sum * * @Returns GDF_SUCCESS if the operation was successful, otherwise an appropriate * error code. If inp->null_count is not set to 0 GDF_VALIDITY_UNSUPPORTED is @@ -906,8 +906,8 @@ gdf_error gdf_hash(int num_cols, /** * @brief Computes trigonometric sine function for any floating point data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -918,8 +918,8 @@ gdf_error gdf_sin_generic(gdf_column *input, gdf_column *output); /** * @brief Computes trigonometric sine function for float data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -930,8 +930,8 @@ gdf_error gdf_sin_f32(gdf_column *input, gdf_column *output); /** * @brief Computes trigonometric sine function for double data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -942,8 +942,8 @@ gdf_error gdf_sin_f64(gdf_column *input, gdf_column *output); /** * @brief Computes trigonometric cosine function for any floating point data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -954,8 +954,8 @@ gdf_error gdf_cos_generic(gdf_column *input, gdf_column *output); /** * @brief Computes trigonometric cosine function for float data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -966,8 +966,8 @@ gdf_error gdf_cos_f32(gdf_column *input, gdf_column *output); /** * @brief Computes trigonometric cosine function for double data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -978,8 +978,8 @@ gdf_error gdf_cos_f64(gdf_column *input, gdf_column *output); /** * @brief Computes trigonometric tangent function for any floating point data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -990,8 +990,8 @@ gdf_error gdf_tan_generic(gdf_column *input, gdf_column *output); /** * @brief Computes trigonometric tangent function for float data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1002,8 +1002,8 @@ gdf_error gdf_tan_f32(gdf_column *input, gdf_column *output); /** * @brief Computes trigonometric tangent function for double data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1014,8 +1014,8 @@ gdf_error gdf_tan_f64(gdf_column *input, gdf_column *output); /** * @brief Computes trigonometric arcsin function for any floating point data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1026,8 +1026,8 @@ gdf_error gdf_asin_generic(gdf_column *input, gdf_column *output); /** * @brief Computes trigonometric arcsin function for float data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1038,8 +1038,8 @@ gdf_error gdf_asin_f32(gdf_column *input, gdf_column *output); /** * @brief Computes trigonometric arcsin function for double data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1050,8 +1050,8 @@ gdf_error gdf_asin_f64(gdf_column *input, gdf_column *output); /** * @brief Computes trigonometric arccos function for any floating point data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1062,8 +1062,8 @@ gdf_error gdf_acos_generic(gdf_column *input, gdf_column *output); /** * @brief Computes trigonometric arccos function for float data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1074,8 +1074,8 @@ gdf_error gdf_acos_f32(gdf_column *input, gdf_column *output); /** * @brief Computes trigonometric arccos function for double data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1086,8 +1086,8 @@ gdf_error gdf_acos_f64(gdf_column *input, gdf_column *output); /** * @brief Computes trigonometric arctan function for any floating point data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1098,8 +1098,8 @@ gdf_error gdf_atan_generic(gdf_column *input, gdf_column *output); /** * @brief Computes trigonometric arctan function for a float data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1110,8 +1110,8 @@ gdf_error gdf_atan_f32(gdf_column *input, gdf_column *output); /** * @brief Computes trigonometric arctan function for a double data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1125,8 +1125,8 @@ gdf_error gdf_atan_f64(gdf_column *input, gdf_column *output); /** * @brief Computes e (Euler's number, 2.7182818...) raised to the given power arg for any floating point data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1137,8 +1137,8 @@ gdf_error gdf_exp_generic(gdf_column *input, gdf_column *output); /** * @brief Computes e (Euler's number, 2.7182818...) raised to the given power arg float data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1149,8 +1149,8 @@ gdf_error gdf_exp_f32(gdf_column *input, gdf_column *output); /** * @brief Computes e (Euler's number, 2.7182818...) raised to the given power arg for double data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1161,8 +1161,8 @@ gdf_error gdf_exp_f64(gdf_column *input, gdf_column *output); /** * @brief Computes the natural (base e) logarithm of arg for any floating point data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1173,8 +1173,8 @@ gdf_error gdf_log_generic(gdf_column *input, gdf_column *output); /** * @brief Computes the natural (base e) logarithm of arg for float data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1185,8 +1185,8 @@ gdf_error gdf_log_f32(gdf_column *input, gdf_column *output); /** * @brief Computes the natural (base e) logarithm of arg for double data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1200,8 +1200,8 @@ gdf_error gdf_log_f64(gdf_column *input, gdf_column *output); /** * @brief Computes the square root for any floating point data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1212,8 +1212,8 @@ gdf_error gdf_sqrt_generic(gdf_column *input, gdf_column *output); /** * @brief Computes the square root for float data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1224,8 +1224,8 @@ gdf_error gdf_sqrt_f32(gdf_column *input, gdf_column *output); /** * @brief Computes the square root for double data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1239,8 +1239,8 @@ gdf_error gdf_sqrt_f64(gdf_column *input, gdf_column *output); /** * @brief Computes the smallest integer value not less than arg for any floating point data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1251,8 +1251,8 @@ gdf_error gdf_ceil_generic(gdf_column *input, gdf_column *output); /** * @brief Computes the smallest integer value not less than arg for float data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1263,8 +1263,8 @@ gdf_error gdf_ceil_f32(gdf_column *input, gdf_column *output); /** * @brief Computes the smallest integer value not less than arg for double data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1275,8 +1275,8 @@ gdf_error gdf_ceil_f64(gdf_column *input, gdf_column *output); /** * @brief Computes the largest integer value not greater than arg for any floating point data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1287,8 +1287,8 @@ gdf_error gdf_floor_generic(gdf_column *input, gdf_column *output); /** * @brief Computes the largest integer value not greater than arg for float data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1299,8 +1299,8 @@ gdf_error gdf_floor_f32(gdf_column *input, gdf_column *output); /** * @brief Computes the largest integer value not greater than arg for double data type * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1314,8 +1314,8 @@ gdf_error gdf_floor_f64(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column of any data type to a GDF_FLOAT32 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1326,8 +1326,8 @@ gdf_error gdf_cast_generic_to_f32(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column of type GDF_INT8 to a GDF_FLOAT32 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1338,8 +1338,8 @@ gdf_error gdf_cast_i8_to_f32(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column of type GDF_INT32 to a GDF_FLOAT32 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1350,8 +1350,8 @@ gdf_error gdf_cast_i32_to_f32(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column of type GDF_INT64 to a GDF_FLOAT32 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1362,8 +1362,8 @@ gdf_error gdf_cast_i64_to_f32(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column of type GDF_FLOAT32 to a GDF_FLOAT32 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1374,8 +1374,8 @@ gdf_error gdf_cast_f32_to_f32(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column of type GDF_FLOAT64 to a GDF_FLOAT32 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1388,8 +1388,8 @@ gdf_error gdf_cast_f64_to_f32(gdf_column *input, gdf_column *output); * * This is effectively casting the underlying GDF_INT32 physical data type of GDF_DATE32 to GDF_FLOAT32 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1402,8 +1402,8 @@ gdf_error gdf_cast_date32_to_f32(gdf_column *input, gdf_column *output); * * This is effectively casting the underlying GDF_INT64 physical data type of GDF_DATE64 to GDF_FLOAT32 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1416,8 +1416,8 @@ gdf_error gdf_cast_date64_to_f32(gdf_column *input, gdf_column *output); * * This is effectively casting the underlying GDF_INT64 physical data type of GDF_TIMESTAMP to GDF_FLOAT32 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1428,8 +1428,8 @@ gdf_error gdf_cast_timestamp_to_f32(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column of any data type to a GDF_FLOAT64 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1440,8 +1440,8 @@ gdf_error gdf_cast_generic_to_f64(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column type GDF_INT8 to a GDF_FLOAT64 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1452,8 +1452,8 @@ gdf_error gdf_cast_i8_to_f64(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column type GDF_INT32 to a GDF_FLOAT64 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1464,8 +1464,8 @@ gdf_error gdf_cast_i32_to_f64(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column type GDF_INT64 to a GDF_FLOAT64 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1476,8 +1476,8 @@ gdf_error gdf_cast_i64_to_f64(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column type GDF_FLOAT32 to a GDF_FLOAT64 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1488,8 +1488,8 @@ gdf_error gdf_cast_f32_to_f64(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column type GDF_FLOAT64 to a GDF_FLOAT64 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1502,8 +1502,8 @@ gdf_error gdf_cast_f64_to_f64(gdf_column *input, gdf_column *output); * * This is effectively casting the underlying GDF_INT32 physical data type of GDF_DATE32 to GDF_FLOAT64 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1516,8 +1516,8 @@ gdf_error gdf_cast_date32_to_f64(gdf_column *input, gdf_column *output); * * This is effectively casting the underlying GDF_INT64 physical data type of GDF_DATE64 to GDF_FLOAT64 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1530,8 +1530,8 @@ gdf_error gdf_cast_date64_to_f64(gdf_column *input, gdf_column *output); * * This is effectively casting the underlying GDF_INT64 physical data type of GDF_TIMESTAMP to GDF_FLOAT64 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1542,8 +1542,8 @@ gdf_error gdf_cast_timestamp_to_f64(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column of any data type to a GDF_INT8 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1554,8 +1554,8 @@ gdf_error gdf_cast_generic_to_i8(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column type GDF_INT8 to a GDF_INT8 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1566,8 +1566,8 @@ gdf_error gdf_cast_i8_to_i8(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column type GDF_INT32 to a GDF_INT8 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1578,8 +1578,8 @@ gdf_error gdf_cast_i32_to_i8(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column type GDF_INT64 to a GDF_INT8 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1590,8 +1590,8 @@ gdf_error gdf_cast_i64_to_i8(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column type GDF_FLOAT32 to a GDF_INT8 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1602,8 +1602,8 @@ gdf_error gdf_cast_f32_to_i8(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column type GDF_FLOAT64 to a GDF_INT8 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1616,8 +1616,8 @@ gdf_error gdf_cast_f64_to_i8(gdf_column *input, gdf_column *output); * * This is effectively casting the underlying GDF_INT32 physical data type of GDF_DATE32 to GDF_INT8 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1630,8 +1630,8 @@ gdf_error gdf_cast_date32_to_i8(gdf_column *input, gdf_column *output); * * This is effectively casting the underlying GDF_INT64 physical data type of GDF_DATE64 to GDF_INT8 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1644,8 +1644,8 @@ gdf_error gdf_cast_date64_to_i8(gdf_column *input, gdf_column *output); * * This is effectively casting the underlying GDF_INT64 physical data type of GDF_TIMESTAMP to GDF_INT8 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1656,8 +1656,8 @@ gdf_error gdf_cast_timestamp_to_i8(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column of any data type to a GDF_INT32 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1668,8 +1668,8 @@ gdf_error gdf_cast_generic_to_i32(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column type GDF_INT8 to a GDF_INT32 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1680,8 +1680,8 @@ gdf_error gdf_cast_i8_to_i32(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column type GDF_INT32 to a GDF_INT32 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1692,8 +1692,8 @@ gdf_error gdf_cast_i32_to_i32(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column type GDF_INT64 to a GDF_INT32 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1704,8 +1704,8 @@ gdf_error gdf_cast_i64_to_i32(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column type GDF_FLOAT32 to a GDF_INT32 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1716,8 +1716,8 @@ gdf_error gdf_cast_f32_to_i32(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column type GDF_FLOAT64 to a GDF_INT32 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1730,8 +1730,8 @@ gdf_error gdf_cast_f64_to_i32(gdf_column *input, gdf_column *output); * * This is effectively casting the underlying GDF_INT32 physical data type of GDF_DATE32 to GDF_INT32 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1744,8 +1744,8 @@ gdf_error gdf_cast_date32_to_i32(gdf_column *input, gdf_column *output); * * This is effectively casting the underlying GDF_INT64 physical data type of GDF_DATE64 to GDF_INT32 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1758,8 +1758,8 @@ gdf_error gdf_cast_date64_to_i32(gdf_column *input, gdf_column *output); * * This is effectively casting the underlying GDF_INT64 physical data type of GDF_TIMESTAMP to GDF_INT32 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1770,8 +1770,8 @@ gdf_error gdf_cast_timestamp_to_i32(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column of any data type to a GDF_INT64 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1782,8 +1782,8 @@ gdf_error gdf_cast_generic_to_i64(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column type GDF_INT8 to a GDF_INT64 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1794,8 +1794,8 @@ gdf_error gdf_cast_i8_to_i64(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column type GDF_INT32 to a GDF_INT64 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1806,8 +1806,8 @@ gdf_error gdf_cast_i32_to_i64(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column type GDF_INT64 to a GDF_INT64 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1818,8 +1818,8 @@ gdf_error gdf_cast_i64_to_i64(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column type GDF_FLOAT32 to a GDF_INT64 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1830,8 +1830,8 @@ gdf_error gdf_cast_f32_to_i64(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column type GDF_FLOAT64 to a GDF_INT64 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1844,8 +1844,8 @@ gdf_error gdf_cast_f64_to_i64(gdf_column *input, gdf_column *output); * * This is effectively casting the underlying GDF_INT32 physical data type of GDF_DATE32 to GDF_INT64 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1858,8 +1858,8 @@ gdf_error gdf_cast_date32_to_i64(gdf_column *input, gdf_column *output); * * This is effectively casting the underlying GDF_INT64 physical data type of GDF_DATE64 to GDF_INT64 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1872,8 +1872,8 @@ gdf_error gdf_cast_date64_to_i64(gdf_column *input, gdf_column *output); * * This is effectively casting the underlying GDF_INT64 physical data type of GDF_TIMESTAMP to GDF_INT64 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1884,8 +1884,8 @@ gdf_error gdf_cast_timestamp_to_i64(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column of any data type to a GDF_DATE32 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1898,8 +1898,8 @@ gdf_error gdf_cast_generic_to_date32(gdf_column *input, gdf_column *output); * * This is effectively casting the GDF_INT8 to the underlying GDF_INT32 physical data type of GDF_DATE32 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1912,8 +1912,8 @@ gdf_error gdf_cast_i8_to_date32(gdf_column *input, gdf_column *output); * * This is effectively casting the GDF_INT32 to the underlying GDF_INT32 physical data type of GDF_DATE32 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1926,8 +1926,8 @@ gdf_error gdf_cast_i32_to_date32(gdf_column *input, gdf_column *output); * * This is effectively casting the GDF_INT64 to the underlying GDF_INT32 physical data type of GDF_DATE32 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1940,8 +1940,8 @@ gdf_error gdf_cast_i64_to_date32(gdf_column *input, gdf_column *output); * * This is effectively casting the GDF_FLOAT32 to the underlying GDF_INT32 physical data type of GDF_DATE32 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1954,8 +1954,8 @@ gdf_error gdf_cast_f32_to_date32(gdf_column *input, gdf_column *output); * * This is effectively casting the GDF_FLOAT64 to the underlying GDF_INT32 physical data type of GDF_DATE32 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1966,8 +1966,8 @@ gdf_error gdf_cast_f64_to_date32(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column type GDF_DATE32 to a GDF_DATE32 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1980,8 +1980,8 @@ gdf_error gdf_cast_date32_to_date32(gdf_column *input, gdf_column *output); * * This casting converts from milliseconds since the UNIX epoch to days since the UNIX epoch * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -1994,8 +1994,8 @@ gdf_error gdf_cast_date64_to_date32(gdf_column *input, gdf_column *output); * * This casting converts from gdf_time_unit since the UNIX epoch to days since the UNIX epoch * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2006,8 +2006,8 @@ gdf_error gdf_cast_timestamp_to_date32(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column of any data type to a GDF_FLOAT64 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2020,8 +2020,8 @@ gdf_error gdf_cast_generic_to_date64(gdf_column *input, gdf_column *output); * * This is effectively casting the GDF_INT8 to the underlying GDF_INT64 physical data type of GDF_DATE64 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2034,8 +2034,8 @@ gdf_error gdf_cast_i8_to_date64(gdf_column *input, gdf_column *output); * * This is effectively casting the GDF_INT32 to the underlying GDF_INT64 physical data type of GDF_DATE64 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2048,8 +2048,8 @@ gdf_error gdf_cast_i32_to_date64(gdf_column *input, gdf_column *output); * * This is effectively casting the GDF_INT64 to the underlying GDF_INT64 physical data type of GDF_DATE64 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2062,8 +2062,8 @@ gdf_error gdf_cast_i64_to_date64(gdf_column *input, gdf_column *output); * * This is effectively casting the GDF_FLOAT32 to the underlying GDF_INT64 physical data type of GDF_DATE64 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2076,8 +2076,8 @@ gdf_error gdf_cast_f32_to_date64(gdf_column *input, gdf_column *output); * * This is effectively casting the GDF_FLOAT64 to the underlying GDF_INT64 physical data type of GDF_DATE64 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2090,8 +2090,8 @@ gdf_error gdf_cast_f64_to_date64(gdf_column *input, gdf_column *output); * * This casting converts from days since the UNIX epoch to milliseconds since the UNIX epoch * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2102,8 +2102,8 @@ gdf_error gdf_cast_date32_to_date64(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column type GDF_DATE64 to a GDF_DATE64 * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2116,8 +2116,8 @@ gdf_error gdf_cast_date64_to_date64(gdf_column *input, gdf_column *output); * * This casting converts from gdf_time_unit since the UNIX epoch to milliseconds since the UNIX epoch * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2128,8 +2128,8 @@ gdf_error gdf_cast_timestamp_to_date64(gdf_column *input, gdf_column *output); /** * @brief Casts data in a gdf_column of any data type to a GDF_TIMESTAMP * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2142,8 +2142,8 @@ gdf_error gdf_cast_generic_to_timestamp(gdf_column *input, gdf_column *output, g * * This is effectively casting the GDF_INT8 to the underlying GDF_INT64 physical data type of GDF_TIMESTAMP * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2156,8 +2156,8 @@ gdf_error gdf_cast_i8_to_timestamp(gdf_column *input, gdf_column *output, gdf_ti * * This is effectively casting the GDF_INT32 to the underlying GDF_INT64 physical data type of GDF_TIMESTAMP * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2170,8 +2170,8 @@ gdf_error gdf_cast_i32_to_timestamp(gdf_column *input, gdf_column *output, gdf_t * * This is effectively casting the GDF_INT64 to the underlying GDF_INT64 physical data type of GDF_TIMESTAMP * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2184,8 +2184,8 @@ gdf_error gdf_cast_i64_to_timestamp(gdf_column *input, gdf_column *output, gdf_t * * This is effectively casting the GDF_FLOAT32 to the underlying GDF_INT64 physical data type of GDF_TIMESTAMP * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2198,8 +2198,8 @@ gdf_error gdf_cast_f32_to_timestamp(gdf_column *input, gdf_column *output, gdf_t * * This is effectively casting the GDF_FLOAT64 to the underlying GDF_INT64 physical data type of GDF_TIMESTAMP * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2212,8 +2212,8 @@ gdf_error gdf_cast_f64_to_timestamp(gdf_column *input, gdf_column *output, gdf_t * * This casting converts from days since UNIX epoch to gdf_time_unit since the UNIX epoch * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2226,8 +2226,8 @@ gdf_error gdf_cast_date32_to_timestamp(gdf_column *input, gdf_column *output, gd * * This casting converts from milliseconds days since UNIX epoch to gdf_time_unit since the UNIX epoch * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2238,8 +2238,8 @@ gdf_error gdf_cast_date64_to_timestamp(gdf_column *input, gdf_column *output, gd /** * @brief Casts data in a gdf_column type GDF_TIMESTAMP to a GDF_TIMESTAMP * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2253,8 +2253,8 @@ gdf_error gdf_cast_timestamp_to_timestamp(gdf_column *input, gdf_column *output, /** * @brief Extracts year from any date time type and places results into a preallocated GDF_INT16 column * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2265,8 +2265,8 @@ gdf_error gdf_extract_datetime_year(gdf_column *input, gdf_column *output); /** * @brief Extracts month from any date time type and places results into a preallocated GDF_INT16 column * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2277,8 +2277,8 @@ gdf_error gdf_extract_datetime_month(gdf_column *input, gdf_column *output); /** * @brief Extracts day from any date time type and places results into a preallocated GDF_INT16 column * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2289,8 +2289,8 @@ gdf_error gdf_extract_datetime_day(gdf_column *input, gdf_column *output); /** * @brief Extracts hour from either GDF_DATE64 or GDF_TIMESTAMP type and places results into a preallocated GDF_INT16 column * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2301,8 +2301,8 @@ gdf_error gdf_extract_datetime_hour(gdf_column *input, gdf_column *output); /** * @brief Extracts minute from either GDF_DATE64 or GDF_TIMESTAMP type and places results into a preallocated GDF_INT16 column * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2313,8 +2313,8 @@ gdf_error gdf_extract_datetime_minute(gdf_column *input, gdf_column *output); /** * @brief Extracts second from either GDF_DATE64 or GDF_TIMESTAMP type and places results into a preallocated GDF_INT16 column * - * @Param[in] gdf_column of the input - * @Param[out] output gdf_column. The output memory needs to be preallocated + * @param[in] gdf_column of the input + * @param[out] output gdf_column. The output memory needs to be preallocated * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2448,9 +2448,9 @@ unsigned int gdf_reduction_get_intermediate_output_size(); /* --------------------------------------------------------------------------* * @brief Computes the sum of the values in all rows of a column * - * @Param[in] col Input column - * @Param[out] dev_result The output sum - * @Param[in] dev_result_size The size of dev_result in elements, which should + * @param[in] col Input column + * @param[out] dev_result The output sum + * @param[in] dev_result_size The size of dev_result in elements, which should * be computed using gdf_reduction_get_intermediate_output_size * This is used as intermediate storage, and the * first element contains the total result @@ -2465,9 +2465,9 @@ gdf_error gdf_sum(gdf_column *col, void *dev_result, gdf_size_type dev_result_si * @brief Computes the multiplicative product of the values in all rows of * a column * - * @Param[in] col Input column - * @Param[out] dev_result The output product - * @Param[in] dev_result_size The size of dev_result in elements, which should + * @param[in] col Input column + * @param[out] dev_result The output product + * @param[in] dev_result_size The size of dev_result in elements, which should * be computed using gdf_reduction_get_intermediate_output_size * This is used as intermediate storage, and the * first element contains the total result @@ -2482,9 +2482,9 @@ gdf_error gdf_product(gdf_column *col, void *dev_result, gdf_size_type dev_resul * * Sum of squares is useful for variance implementation. * - * @Param[in] col Input column - * @Param[out] dev_result The output sum of squares - * @Param[in] dev_result_size The size of dev_result in elements, which should + * @param[in] col Input column + * @param[out] dev_result The output sum of squares + * @param[in] dev_result_size The size of dev_result in elements, which should * be computed using gdf_reduction_get_intermediate_output_size * This is used as intermediate storage, and the * first element contains the total result @@ -2500,9 +2500,9 @@ gdf_error gdf_sum_of_squares(gdf_column *col, void *dev_result, gdf_size_type de /* --------------------------------------------------------------------------* * @brief Computes the minimum of the values in all rows of a column * - * @Param[in] col Input column - * @Param[out] dev_result The output minimum - * @Param[in] dev_result_size The size of dev_result in elements, which should + * @param[in] col Input column + * @param[out] dev_result The output minimum + * @param[in] dev_result_size The size of dev_result in elements, which should * be computed using gdf_reduction_get_intermediate_output_size * This is used as intermediate storage, and the * first element contains the total result @@ -2516,9 +2516,9 @@ gdf_error gdf_min(gdf_column *col, void *dev_result, gdf_size_type dev_result_si /* --------------------------------------------------------------------------* * @brief Computes the maximum of the values in all rows of a column * - * @Param[in] col Input column - * @Param[out] dev_result The output maximum - * @Param[in] dev_result_size The size of dev_result in elements, which should + * @param[in] col Input column + * @param[out] dev_result The output maximum + * @param[in] dev_result_size The size of dev_result in elements, which should * be computed using gdf_reduction_get_intermediate_output_size * This is used as intermediate storage, and the * first element contains the total result @@ -2538,10 +2538,10 @@ gdf_error gdf_max(gdf_column *col, void *dev_result, gdf_size_type dev_result_si /** * @brief Compare every value on the left hand side to a static value and return a stencil in output which will have 1 when the comparison operation returns 1 and 0 otherwise * - * @Param[in] gdf_column of the input of type GDF_INT8 - * @Param[in] Static value to compare against the input - * @Param[out] output gdf_column of type GDF_INT8. The output memory needs to be preallocated - * @Param[in] gdf_comparison_operator enum defining the comparison operator to be used + * @param[in] gdf_column of the input of type GDF_INT8 + * @param[in] Static value to compare against the input + * @param[out] output gdf_column of type GDF_INT8. The output memory needs to be preallocated + * @param[in] gdf_comparison_operator enum defining the comparison operator to be used * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2552,10 +2552,10 @@ gdf_error gdf_comparison_static_i8(gdf_column *lhs, int8_t value, gdf_column *ou /** * @brief Compare every value on the left hand side to a static value and return a stencil in output which will have 1 when the comparison operation returns 1 and 0 otherwise * - * @Param[in] gdf_column of the input of type GDF_INT16 - * @Param[in] Static value to compare against the input - * @Param[out] output gdf_column of type GDF_INT8. The output memory needs to be preallocated - * @Param[in] gdf_comparison_operator enum defining the comparison operator to be used + * @param[in] gdf_column of the input of type GDF_INT16 + * @param[in] Static value to compare against the input + * @param[out] output gdf_column of type GDF_INT8. The output memory needs to be preallocated + * @param[in] gdf_comparison_operator enum defining the comparison operator to be used * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2566,10 +2566,10 @@ gdf_error gdf_comparison_static_i16(gdf_column *lhs, int16_t value, gdf_column * /** * @brief Compare every value on the left hand side to a static value and return a stencil in output which will have 1 when the comparison operation returns 1 and 0 otherwise * - * @Param[in] gdf_column of the input of type GDF_INT32 - * @Param[in] Static value to compare against the input - * @Param[out] output gdf_column of type GDF_INT8. The output memory needs to be preallocated - * @Param[in] gdf_comparison_operator enum defining the comparison operator to be used + * @param[in] gdf_column of the input of type GDF_INT32 + * @param[in] Static value to compare against the input + * @param[out] output gdf_column of type GDF_INT8. The output memory needs to be preallocated + * @param[in] gdf_comparison_operator enum defining the comparison operator to be used * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2580,10 +2580,10 @@ gdf_error gdf_comparison_static_i32(gdf_column *lhs, int32_t value, gdf_column * /** * @brief Compare every value on the left hand side to a static value and return a stencil in output which will have 1 when the comparison operation returns 1 and 0 otherwise * - * @Param[in] gdf_column of the input of type GDF_INT64 - * @Param[in] Static value to compare against the input - * @Param[out] output gdf_column of type GDF_INT8. The output memory needs to be preallocated - * @Param[in] gdf_comparison_operator enum defining the comparison operator to be used + * @param[in] gdf_column of the input of type GDF_INT64 + * @param[in] Static value to compare against the input + * @param[out] output gdf_column of type GDF_INT8. The output memory needs to be preallocated + * @param[in] gdf_comparison_operator enum defining the comparison operator to be used * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2594,10 +2594,10 @@ gdf_error gdf_comparison_static_i64(gdf_column *lhs, int64_t value, gdf_column * /** * @brief Compare every value on the left hand side to a static value and return a stencil in output which will have 1 when the comparison operation returns 1 and 0 otherwise * - * @Param[in] gdf_column of the input of type GDF_FLOAT32 - * @Param[in] Static value to compare against the input - * @Param[out] output gdf_column of type GDF_INT8. The output memory needs to be preallocated - * @Param[in] gdf_comparison_operator enum defining the comparison operator to be used + * @param[in] gdf_column of the input of type GDF_FLOAT32 + * @param[in] Static value to compare against the input + * @param[out] output gdf_column of type GDF_INT8. The output memory needs to be preallocated + * @param[in] gdf_comparison_operator enum defining the comparison operator to be used * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2608,10 +2608,10 @@ gdf_error gdf_comparison_static_f32(gdf_column *lhs, float value, gdf_column *ou /** * @brief Compare every value on the left hand side to a static value and return a stencil in output which will have 1 when the comparison operation returns 1 and 0 otherwise * - * @Param[in] gdf_column of the input of type GDF_FLOAT64 - * @Param[in] Static value to compare against the input - * @Param[out] output gdf_column of type GDF_INT8. The output memory needs to be preallocated - * @Param[in] gdf_comparison_operator enum defining the comparison operator to be used + * @param[in] gdf_column of the input of type GDF_FLOAT64 + * @param[in] Static value to compare against the input + * @param[out] output gdf_column of type GDF_INT8. The output memory needs to be preallocated + * @param[in] gdf_comparison_operator enum defining the comparison operator to be used * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2622,10 +2622,10 @@ gdf_error gdf_comparison_static_f64(gdf_column *lhs, double value, gdf_column *o /** * @brief Compare two columns of any types against each other using a comparison operation, returns a stencil in output which will have 1 when the comparison operation returns 1 and 0 otherwise * - * @Param[in] gdf_column of one input of any type - * @Param[in] gdf_column of second input of any type - * @Param[out] output gdf_column of type GDF_INT8. The output memory needs to be preallocated - * @Param[in] gdf_comparison_operator enum defining the comparison operator to be used + * @param[in] gdf_column of one input of any type + * @param[in] gdf_column of second input of any type + * @param[out] output gdf_column of type GDF_INT8. The output memory needs to be preallocated + * @param[in] gdf_comparison_operator enum defining the comparison operator to be used * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2636,9 +2636,9 @@ gdf_error gdf_comparison(gdf_column *lhs, gdf_column *rhs, gdf_column *output,gd /** * @brief takes a stencil and uses it to compact a colum e.g. remove all values for which the stencil = 0 * - * @Param[in] gdf_column of input of any type - * @Param[in] gdf_column holding the stencil - * @Param[out] output gdf_column of same type as input. The output memory needs to be preallocated to be the same size as input + * @param[in] gdf_column of input of any type + * @param[in] gdf_column holding the stencil + * @param[out] output gdf_column of same type as input. The output memory needs to be preallocated to be the same size as input * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2649,9 +2649,9 @@ gdf_error gdf_apply_stencil(gdf_column *lhs, gdf_column * stencil, gdf_column * /** * @brief Concatenates two gdf_columns * - * @Param[in] gdf_column of one input of any type - * @Param[in] gdf_column of same type as the first - * @Param[out] output gdf_column of same type as inputs. The output memory needs to be preallocated to be the same size as the sum of both inputs + * @param[in] gdf_column of one input of any type + * @param[in] gdf_column of same type as the first + * @param[out] output gdf_column of same type as inputs. The output memory needs to be preallocated to be the same size as the sum of both inputs * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2667,10 +2667,10 @@ gdf_error gdf_concat(gdf_column *lhs, gdf_column *rhs, gdf_column *output); /** * @brief Creates a hash of multiple gdf_columns * - * @Param[in] an array of gdf_columns to be hashes together - * @Param[in] the number of columns in the array of gdf_columns to be hashes together - * @Param[out] output gdf_column of type GDF_INT64. The output memory needs to be preallocated - * @Param[in] A pointer to a cudaStream_t. If nullptr, the function will create a stream to use. + * @param[in] an array of gdf_columns to be hashes together + * @param[in] the number of columns in the array of gdf_columns to be hashes together + * @param[out] output gdf_column of type GDF_INT64. The output memory needs to be preallocated + * @param[in] A pointer to a cudaStream_t. If nullptr, the function will create a stream to use. * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2686,8 +2686,8 @@ gdf_error gdf_hash_columns(gdf_column ** columns_to_hash, int num_columns, gdf_c /** * @brief Returns the byte width of the data type of the gdf_column * - * @Param[in] gdf_column whose data type's byte width will be determined - * @Param[out] the byte width of the data type + * @param[in] gdf_column whose data type's byte width will be determined + * @param[out] the byte width of the data type * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2706,14 +2706,14 @@ gdf_error get_column_byte_width(gdf_column * col, int * width); /** * @brief Performs SQL like WHERE (Filtering) * - * @Param[in] # rows - * @Param[in] host-side array of gdf_columns with 0 null_count otherwise GDF_VALIDITY_UNSUPPORTED is returned - * @Param[in] # cols - * @Param[out] pre-allocated device-side array to be filled with gdf_column::data for each column; slicing of gdf_column array (host) - * @Param[out] pre-allocated device-side array to be filled with gdf_colum::dtype for each column; slicing of gdf_column array (host) - * @Param[in] device-side array of values to filter against (type-erased) - * @Param[out] device-side array of row indices that remain after filtering - * @Param[out] host-side # rows that remain after filtering + * @param[in] # rows + * @param[in] host-side array of gdf_columns with 0 null_count otherwise GDF_VALIDITY_UNSUPPORTED is returned + * @param[in] # cols + * @param[out] pre-allocated device-side array to be filled with gdf_column::data for each column; slicing of gdf_column array (host) + * @param[out] pre-allocated device-side array to be filled with gdf_colum::dtype for each column; slicing of gdf_column array (host) + * @param[in] device-side array of values to filter against (type-erased) + * @param[out] device-side array of row indices that remain after filtering + * @param[out] host-side # rows that remain after filtering * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2730,13 +2730,13 @@ gdf_error gdf_filter(size_t nrows, /** * @brief Performs SQL like GROUP BY with SUM aggregation * - * @Param[in] # columns - * @Param[in] input cols - * @Param[in] column to aggregate on - * @Param[out] if not null return indices of re-ordered rows - * @Param[out] if not null return the grouped-by columns (multi-gather based on indices, which are needed anyway) - * @Param[out] aggregation result - * @Param[in] struct with additional info: bool is_sorted, flag_sort_or_hash, bool flag_count_distinct + * @param[in] # columns + * @param[in] input cols + * @param[in] column to aggregate on + * @param[out] if not null return indices of re-ordered rows + * @param[out] if not null return the grouped-by columns (multi-gather based on indices, which are needed anyway) + * @param[out] aggregation result + * @param[in] struct with additional info: bool is_sorted, flag_sort_or_hash, bool flag_count_distinct * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2752,13 +2752,13 @@ gdf_error gdf_group_by_sum(int ncols, /** * @brief Performs SQL like GROUP BY with MIN aggregation * - * @Param[in] # columns - * @Param[in] input cols - * @Param[in] column to aggregate on - * @Param[out] if not null return indices of re-ordered rows - * @Param[out] if not null return the grouped-by columns (multi-gather based on indices, which are needed anyway) - * @Param[out] aggregation result - * @Param[in] struct with additional info: bool is_sorted, flag_sort_or_hash, bool flag_count_distinct + * @param[in] # columns + * @param[in] input cols + * @param[in] column to aggregate on + * @param[out] if not null return indices of re-ordered rows + * @param[out] if not null return the grouped-by columns (multi-gather based on indices, which are needed anyway) + * @param[out] aggregation result + * @param[in] struct with additional info: bool is_sorted, flag_sort_or_hash, bool flag_count_distinct * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2774,13 +2774,13 @@ gdf_error gdf_group_by_min(int ncols, /** * @brief Performs SQL like GROUP BY with MAX aggregation * - * @Param[in] # columns - * @Param[in] input cols - * @Param[in] column to aggregate on - * @Param[out] if not null return indices of re-ordered rows - * @Param[out] if not null return the grouped-by columns (multi-gather based on indices, which are needed anyway) - * @Param[out] aggregation result - * @Param[in] struct with additional info: bool is_sorted, flag_sort_or_hash, bool flag_count_distinct + * @param[in] # columns + * @param[in] input cols + * @param[in] column to aggregate on + * @param[out] if not null return indices of re-ordered rows + * @param[out] if not null return the grouped-by columns (multi-gather based on indices, which are needed anyway) + * @param[out] aggregation result + * @param[in] struct with additional info: bool is_sorted, flag_sort_or_hash, bool flag_count_distinct * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2796,13 +2796,13 @@ gdf_error gdf_group_by_max(int ncols, /** * @brief Performs SQL like GROUP BY with AVG aggregation * - * @Param[in] # columns - * @Param[in] input cols - * @Param[in] column to aggregate on - * @Param[out] if not null return indices of re-ordered rows - * @Param[out] if not null return the grouped-by columns (multi-gather based on indices, which are needed anyway) - * @Param[out] aggregation result - * @Param[in] struct with additional info: bool is_sorted, flag_sort_or_hash, bool flag_count_distinct + * @param[in] # columns + * @param[in] input cols + * @param[in] column to aggregate on + * @param[out] if not null return indices of re-ordered rows + * @param[out] if not null return the grouped-by columns (multi-gather based on indices, which are needed anyway) + * @param[out] aggregation result + * @param[in] struct with additional info: bool is_sorted, flag_sort_or_hash, bool flag_count_distinct * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2818,13 +2818,13 @@ gdf_error gdf_group_by_avg(int ncols, /** * @brief Performs SQL like GROUP BY with COUNT aggregation * - * @Param[in] # columns - * @Param[in] input cols - * @Param[in] column to aggregate on - * @Param[out] if not null return indices of re-ordered rows - * @Param[out] if not null return the grouped-by columns (multi-gather based on indices, which are needed anyway) - * @Param[out] aggregation result - * @Param[in] struct with additional info: bool is_sorted, flag_sort_or_hash, bool flag_count_distinct + * @param[in] # columns + * @param[in] input cols + * @param[in] column to aggregate on + * @param[out] if not null return indices of re-ordered rows + * @param[out] if not null return the grouped-by columns (multi-gather based on indices, which are needed anyway) + * @param[out] aggregation result + * @param[in] struct with additional info: bool is_sorted, flag_sort_or_hash, bool flag_count_distinct * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2840,11 +2840,11 @@ gdf_error gdf_group_by_count(int ncols, /** * @brief Calculates exact quantiles * - * @Param[in] input column - * @Param[in] precision: type of quantile method calculation - * @Param[in] requested quantile in [0,1] - * @Param[out] result; for should probably be double*; it's void* because: (1) for uniformity of interface with ; (2) for possible types bigger than double, in the future; - * @Param[in] struct with additional info + * @param[in] input column + * @param[in] precision: type of quantile method calculation + * @param[in] requested quantile in [0,1] + * @param[out] result; for should probably be double*; it's void* because: (1) for uniformity of interface with ; (2) for possible types bigger than double, in the future; + * @param[in] struct with additional info * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2858,10 +2858,10 @@ gdf_error gdf_quantile_exact(gdf_column* col_in, /** * @brief Calculates approximate quantiles * - * @Param[in] input column - * @Param[in] requested quantile in [0,1] - * @Param[out] result; type-erased result of same type as column; - * @Param[in] struct with additional info + * @param[in] input column + * @param[in] requested quantile in [0,1] + * @param[out] result; type-erased result of same type as column; + * @param[in] struct with additional info * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ @@ -2877,9 +2877,9 @@ gdf_error gdf_quantile_aprrox(gdf_column* col_in, * `new_values`, that is, replace all `old_values[i]` present in `col` * with `new_values[i]`. * - * @Param[in,out] col gdf_column with the data to be modified - * @Param[in] old_values gdf_column with the old values to be replaced - * @Param[in] new_values gdf_column with the new values + * @param[in,out] col gdf_column with the data to be modified + * @param[in] old_values gdf_column with the old values to be replaced + * @param[in] new_values gdf_column with the new values * * @Returns GDF_SUCCESS upon successful completion */ @@ -2892,14 +2892,14 @@ gdf_error gdf_find_and_replace_all(gdf_column* col, /** * @brief Sorts an array of gdf_column. * - * @Param[in] input_columns Array of gdf_columns - * @Param[in] asc_desc Device array of sort order types for each column + * @param[in] input_columns Array of gdf_columns + * @param[in] asc_desc Device array of sort order types for each column * (0 is ascending order and 1 is descending). If NULL * is provided defaults to ascending order for evey column. - * @Param[in] num_inputs # columns - * @Param[in] flag_nulls_are_smallest Flag to indicate if nulls are to be considered + * @param[in] num_inputs # columns + * @param[in] flag_nulls_are_smallest Flag to indicate if nulls are to be considered * smaller than non-nulls or viceversa - * @Param[out] output_indices Pre-allocated gdf_column to be filled with sorted + * @param[out] output_indices Pre-allocated gdf_column to be filled with sorted * indices * * @Returns GDF_SUCCESS upon successful completion @@ -2928,8 +2928,8 @@ gdf_error gdf_order_by(gdf_column** input_columns, * replace all nulls of the first column with the corresponding elemetns of the * second column * - * @Param[in,out] col_out A gdf_column that is the output of this function with null values replaced - * @Param[in] col_in A gdf_column that is of size 1 or same size as col_out, contains value / values to be placed in col_out + * @param[in,out] col_out A gdf_column that is the output of this function with null values replaced + * @param[in] col_in A gdf_column that is of size 1 or same size as col_out, contains value / values to be placed in col_out * * @Returns GDF_SUCCESS upon successful completion * diff --git a/cpp/src/join/joining.cu b/cpp/src/join/joining.cu index a3359a07736c..1289fba35188 100644 --- a/cpp/src/join/joining.cu +++ b/cpp/src/join/joining.cu @@ -38,11 +38,11 @@ constexpr output_index_type MAX_JOIN_SIZE{std::numeric_limits /** * @brief Computes the Join result between two tables using the hash-based implementation. * - * @Param[in] num_cols The number of columns to join - * @Param[in] leftcol The left set of columns to join - * @Param[in] rightcol The right set of columns to join - * @Param[out] l_result The join computed indices of the left table - * @Param[out] r_result The join computed indices of the right table + * @param[in] num_cols The number of columns to join + * @param[in] leftcol The left set of columns to join + * @param[in] rightcol The right set of columns to join + * @param[out] l_result The join computed indices of the left table + * @param[out] r_result The join computed indices of the right table * @tparam join_type The type of join to be performed * @tparam size_type The data type used for size calculations * @@ -124,11 +124,11 @@ gdf_error sort_join_typed(gdf_column *leftcol, gdf_column *rightcol, * @brief Computes the join operation between a single left and single right column * using the sort based implementation. * - * @Param[in] leftcol The left column to join - * @Param[in] rightcol The right column to join - * @Param[out] left_result The join computed indices of the left table - * @Param[out] right_result The join computed indices of the right table - * @Param[in] ctxt Structure that determines various run parameters, such as if the inputs + * @param[in] leftcol The left column to join + * @param[in] rightcol The right column to join + * @param[out] left_result The join computed indices of the left table + * @param[out] right_result The join computed indices of the right table + * @param[in] ctxt Structure that determines various run parameters, such as if the inputs * are already sorted. * @tparama join_type The type of join to perform * @@ -171,9 +171,9 @@ gdf_error sort_join(gdf_column *leftcol, gdf_column *rightc /** * @brief Allocates a buffer and fills it with a repeated value * - * @Param[in,out] buffer Address of the buffer to be allocated - * @Param[in] buffer_length Amount of memory to be allocated - * @Param[in] value The value to be filled into the buffer + * @param[in,out] buffer Address of the buffer to be allocated + * @param[in] buffer_length Amount of memory to be allocated + * @param[in] value The value to be filled into the buffer * @tparam data_type The data type to be used for the buffer * @tparam size_type The data type used for size calculations * @@ -195,8 +195,8 @@ gdf_error allocValueBuffer(data_type ** buffer, /** * @brief Allocates a buffer and fills it with a sequence * - * @Param[in,out] buffer Address of the buffer to be allocated - * @Param[in] buffer_length Amount of memory to be allocated + * @param[in,out] buffer Address of the buffer to be allocated + * @param[in] buffer_length Amount of memory to be allocated * @tparam data_type The data type to be used for the buffer * @tparam size_type The data type used for size calculations * @@ -218,11 +218,11 @@ gdf_error allocSequenceBuffer(data_type ** buffer, * @brief Trivially computes full join of two tables if one of the tables * are empty * - * @Param[in] left_size The size of the left table - * @Param[in] right_size The size of the right table - * @Param[in] rightcol The right set of columns to join - * @Param[out] left_result The join computed indices of the left table - * @Param[out] right_result The join computed indices of the right table + * @param[in] left_size The size of the left table + * @param[in] right_size The size of the right table + * @param[in] rightcol The right set of columns to join + * @param[out] left_result The join computed indices of the left table + * @param[out] right_result The join computed indices of the right table * @tparam size_type The data type used for size calculations * * @Returns GDF_SUCCESS upon succesfull compute, otherwise returns appropriate error code @@ -271,12 +271,12 @@ gdf_error trivial_full_join( /** * @brief Computes the join operation between two sets of columns * - * @Param[in] num_cols The number of columns to join - * @Param[in] leftcol The left set of columns to join - * @Param[in] rightcol The right set of columns to join - * @Param[out] left_result The join computed indices of the left table - * @Param[out] right_result The join computed indices of the right table - * @Param[in] join_context A structure that determines various run parameters, such as + * @param[in] num_cols The number of columns to join + * @param[in] leftcol The left set of columns to join + * @param[in] rightcol The right set of columns to join + * @param[out] left_result The join computed indices of the left table + * @param[out] right_result The join computed indices of the right table + * @param[in] join_context A structure that determines various run parameters, such as * whether to perform a hash or sort based join * @tparam join_type The type of join to be performed * From 990af067be3060da7ce18dbf662b7aecbb78aec3 Mon Sep 17 00:00:00 2001 From: jeanp413 Date: Thu, 28 Feb 2019 13:42:38 -0500 Subject: [PATCH 4/4] Fixed documentation formatting --- cpp/include/cudf/functions.h | 738 +++++++------------------- cpp/src/quantiles/quantiles.cu | 2 +- cpp/tests/quantiles/quantiles_test.cu | 2 +- python/cudf/_gdf.py | 2 +- python/cudf/bindings/cudf_cpp.pxd | 2 +- 5 files changed, 191 insertions(+), 555 deletions(-) diff --git a/cpp/include/cudf/functions.h b/cpp/include/cudf/functions.h index 332531f49350..289043a7fc1f 100644 --- a/cpp/include/cudf/functions.h +++ b/cpp/include/cudf/functions.h @@ -1,6 +1,5 @@ #pragma once -/* --------------------------------------------------------------------------*/ /** * @brief Start a NVTX range with predefined color. * @@ -12,15 +11,10 @@ * @param[in] name The name of the NVTX range * @param[in] color The predefined gdf_color enum to use to color this range * - * @returns + * @Returnss */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_nvtx_range_push(char const * const name, gdf_color color ); - - - -/* --------------------------------------------------------------------------*/ /** * @brief Start a NVTX range with a custom ARGB color code. * @@ -32,13 +26,10 @@ gdf_error gdf_nvtx_range_push(char const * const name, gdf_color color ); * @param[in] name The name of the NVTX range * @param[in] color The ARGB hex color code to use to color this range (e.g., 0xFF00FF00) * - * @returns + * @Returnss */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_nvtx_range_push_hex(char const * const name, unsigned int color ); - -/* --------------------------------------------------------------------------*/ /** * @brief Ends the inner-most NVTX range. * @@ -46,12 +37,10 @@ gdf_error gdf_nvtx_range_push_hex(char const * const name, unsigned int color ); * will demarcate the end of the inner-most range, i.e., the most recent call to * gdf_nvtx_range_push. * - * @returns + * @Returnss */ -/* --------------------------------------------------------------------------*/ gdf_error gdf_nvtx_range_pop(); -/* --------------------------------------------------------------------------*/ /** * @brief Counts the number of valid bits in the mask that corresponds to * the specified number of rows. @@ -61,25 +50,21 @@ gdf_error gdf_nvtx_range_pop(); * @param[in] num_rows The number of rows represented in the bit-validity mask. * @param[out] count The number of valid rows in the mask * - * @returns GDF_SUCCESS upon successful completion. + * @Returnss GDF_SUCCESS upon successful completion. */ -/* --------------------------------------------------------------------------*/ gdf_error gdf_count_nonzero_mask(gdf_valid_type const *masks, gdf_size_type num_rows, gdf_size_type *count); /* column operations */ -/* --------------------------------------------------------------------------*/ /** * @brief Return the size of the gdf_column data type. * * @Returns gdf_size_type Size of the gdf_column data type. */ -/* ----------------------------------------------------------------------------*/ gdf_size_type gdf_column_sizeof(); -/* --------------------------------------------------------------------------*/ /** * @brief Create a GDF column given data and validity bitmask pointers, size, and * datatype @@ -92,11 +77,9 @@ gdf_size_type gdf_column_sizeof(); * * @Returns gdf_error Returns GDF_SUCCESS upon successful creation. */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_column_view(gdf_column *column, void *data, gdf_valid_type *valid, gdf_size_type size, gdf_dtype dtype); -/* --------------------------------------------------------------------------*/ /** * @brief Create a GDF column given data and validity bitmask pointers, size, and * datatype, and count of null (non-valid) elements @@ -110,11 +93,9 @@ gdf_error gdf_column_view(gdf_column *column, void *data, gdf_valid_type *valid, * * @Returns gdf_error Returns GDF_SUCCESS upon successful creation. */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_column_view_augmented(gdf_column *column, void *data, gdf_valid_type *valid, gdf_size_type size, gdf_dtype dtype, gdf_size_type null_count); -/* --------------------------------------------------------------------------*/ /** * @brief Free the CUDA device memory of a gdf_column * @@ -122,28 +103,24 @@ gdf_error gdf_column_view_augmented(gdf_column *column, void *data, gdf_valid_ty * * @Returns gdf_error GDF_SUCCESS or GDF_ERROR if there is an error freeing the data */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_column_free(gdf_column *column); -/* --------------------------------------------------------------------------*/ /** * @brief Concatenates the gdf_columns into a single, contiguous column, * including the validity bitmasks * * @param[out] output A column whose buffers are already allocated that will + * contain the concatenation of the input columns * @param[in] columns_to_conat[] The columns to concatenate * @param[in] num_columns The number of columns to concatenate - * contain the concatenation of the input columns * - * @returns GDF_SUCCESS upon successful completion + * @Returnss GDF_SUCCESS upon successful completion */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_column_concat(gdf_column *output, gdf_column *columns_to_concat[], int num_columns); /* context operations */ -/* --------------------------------------------------------------------------*/ /** * @brief Constructor for the gdf_context struct * @@ -154,14 +131,12 @@ gdf_error gdf_column_concat(gdf_column *output, gdf_column *columns_to_concat[], * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_context_view(gdf_context *context, int flag_sorted, gdf_method flag_method, int flag_distinct, int flag_sort_result, int flag_sort_inplace); /* error handling */ -/* --------------------------------------------------------------------------*/ /** * @brief Converts a gdf_error error code into a string * @@ -169,19 +144,15 @@ gdf_error gdf_context_view(gdf_context *context, int flag_sorted, gdf_method fla * * @Returns name of the error */ -/* ----------------------------------------------------------------------------*/ const char * gdf_error_get_name(gdf_error errcode); -/* --------------------------------------------------------------------------*/ /** * @brief Returns the last error from a runtime call. * * @Returns last error from a runtime call. */ -/* ----------------------------------------------------------------------------*/ int gdf_cuda_last_error(); -/* --------------------------------------------------------------------------*/ /** * @brief Returns the description string for an error code. * @@ -189,10 +160,8 @@ int gdf_cuda_last_error(); * * @Returns description string for an error code. */ -/* ----------------------------------------------------------------------------*/ const char * gdf_cuda_error_string(int cuda_error); -/* --------------------------------------------------------------------------*/ /** * @brief Returns the string representation of an error code enum name. * @@ -200,25 +169,21 @@ const char * gdf_cuda_error_string(int cuda_error); * * @Returns string representation of an error code enum name. */ -/* ----------------------------------------------------------------------------*/ const char * gdf_cuda_error_name(int cuda_error); /* ipc */ -/* --------------------------------------------------------------------------*/ /** * @brief Opens a parser from a pyarrow RecordBatch schema * * @param[in] Pointer to a byte array containing the pyarrow RecordBatch schema * @param[in] Size of the byte array - * + * * @Returns Pointer to a parsing struct gdf_ipc_parser_type */ -/* ----------------------------------------------------------------------------*/ gdf_ipc_parser_type* gdf_ipc_parser_open(const uint8_t *schema, size_t length); -/* --------------------------------------------------------------------------*/ /** * @brief Opens a pyarrow RecordBatch bytearray * @@ -228,12 +193,10 @@ gdf_ipc_parser_type* gdf_ipc_parser_open(const uint8_t *schema, size_t length); * * @Returns */ -/* ----------------------------------------------------------------------------*/ void gdf_ipc_parser_open_recordbatches(gdf_ipc_parser_type *handle, const uint8_t *recordbatches, size_t length); -/* --------------------------------------------------------------------------*/ /** * @brief Closes a parser from a pyarrow RecordBatch schema * @@ -241,10 +204,8 @@ void gdf_ipc_parser_open_recordbatches(gdf_ipc_parser_type *handle, * * @Returns void */ -/* ----------------------------------------------------------------------------*/ void gdf_ipc_parser_close(gdf_ipc_parser_type *handle); -/* --------------------------------------------------------------------------*/ /** * @brief Checks for a failure in the parser * @@ -252,10 +213,8 @@ void gdf_ipc_parser_close(gdf_ipc_parser_type *handle); * * @Returns 1 if error */ -/* ----------------------------------------------------------------------------*/ int gdf_ipc_parser_failed(gdf_ipc_parser_type *handle); -/* --------------------------------------------------------------------------*/ /** * @brief Returns parsed data as json * @@ -263,10 +222,8 @@ int gdf_ipc_parser_failed(gdf_ipc_parser_type *handle); * * @Returns char* of parsed data as json */ -/* ----------------------------------------------------------------------------*/ const char* gdf_ipc_parser_to_json(gdf_ipc_parser_type *handle); -/* --------------------------------------------------------------------------*/ /** * @brief Gets error from gdf_ipc_parser_type * @@ -274,10 +231,8 @@ const char* gdf_ipc_parser_to_json(gdf_ipc_parser_type *handle); * * @Returns Error message as char* */ -/* ----------------------------------------------------------------------------*/ const char* gdf_ipc_parser_get_error(gdf_ipc_parser_type *handle); -/* --------------------------------------------------------------------------*/ /** * @brief Gets parsed data from gdf_ipc_parser_type * @@ -285,10 +240,8 @@ const char* gdf_ipc_parser_get_error(gdf_ipc_parser_type *handle); * * @Returns Pointer parsed data */ -/* ----------------------------------------------------------------------------*/ const void* gdf_ipc_parser_get_data(gdf_ipc_parser_type *handle); -/* --------------------------------------------------------------------------*/ /** * @brief Gets data offset from gdf_ipc_parser_type * @@ -296,10 +249,8 @@ const void* gdf_ipc_parser_get_data(gdf_ipc_parser_type *handle); * * @Returns Data offset */ -/* ----------------------------------------------------------------------------*/ int64_t gdf_ipc_parser_get_data_offset(gdf_ipc_parser_type *handle); -/* --------------------------------------------------------------------------*/ /** * @brief Returns parsed schema as json * @@ -307,10 +258,8 @@ int64_t gdf_ipc_parser_get_data_offset(gdf_ipc_parser_type *handle); * * @Returns char* of parsed schema as json */ -/* ----------------------------------------------------------------------------*/ const char *gdf_ipc_parser_get_schema_json(gdf_ipc_parser_type *handle); -/* --------------------------------------------------------------------------*/ /** * @brief Returns layout as json * @@ -318,13 +267,11 @@ const char *gdf_ipc_parser_get_schema_json(gdf_ipc_parser_type *handle); * * @Returns char* of layout as json */ -/* ----------------------------------------------------------------------------*/ const char *gdf_ipc_parser_get_layout_json(gdf_ipc_parser_type *handle); /* sorting */ -/* --------------------------------------------------------------------------*/ /** * @brief Constructor for the gdf_radixsort_plan_type object * @@ -335,11 +282,9 @@ const char *gdf_ipc_parser_get_layout_json(gdf_ipc_parser_type *handle); * * @Returns gdf_radixsort_plan_type object pointer */ -/* ----------------------------------------------------------------------------*/ gdf_radixsort_plan_type* gdf_radixsort_plan(size_t num_items, int descending, unsigned begin_bit, unsigned end_bit); -/* --------------------------------------------------------------------------*/ /** * @brief Allocates device memory for the radixsort * @@ -349,11 +294,9 @@ gdf_radixsort_plan_type* gdf_radixsort_plan(size_t num_items, int descending, * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_radixsort_plan_setup(gdf_radixsort_plan_type *hdl, size_t sizeof_key, size_t sizeof_val); -/* --------------------------------------------------------------------------*/ /** * @brief Frees device memory used for the radixsort * @@ -361,7 +304,6 @@ gdf_error gdf_radixsort_plan_setup(gdf_radixsort_plan_type *hdl, * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_radixsort_plan_free(gdf_radixsort_plan_type *hdl); @@ -371,7 +313,6 @@ gdf_error gdf_radixsort_plan_free(gdf_radixsort_plan_type *hdl); * otherwise a GDF_VALIDITY_UNSUPPORTED error is returned. */ -/* --------------------------------------------------------------------------*/ /** * @brief Performs a radixsort on the key and value columns where the key is an int8 * @@ -381,12 +322,10 @@ gdf_error gdf_radixsort_plan_free(gdf_radixsort_plan_type *hdl); * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_radixsort_i8(gdf_radixsort_plan_type *hdl, gdf_column *keycol, gdf_column *valcol); -/* --------------------------------------------------------------------------*/ /** * @brief Performs a radixsort on the key and value columns where the key is an int32 * @@ -396,12 +335,10 @@ gdf_error gdf_radixsort_i8(gdf_radixsort_plan_type *hdl, * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_radixsort_i32(gdf_radixsort_plan_type *hdl, gdf_column *keycol, gdf_column *valcol); -/* --------------------------------------------------------------------------*/ /** * @brief performs a radixsort on the key and value columns where the key is an int64 * @@ -411,12 +348,10 @@ gdf_error gdf_radixsort_i32(gdf_radixsort_plan_type *hdl, * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_radixsort_i64(gdf_radixsort_plan_type *hdl, gdf_column *keycol, gdf_column *valcol); -/* --------------------------------------------------------------------------*/ /** * @brief performs a radixsort on the key and value columns where the key is an float * @@ -426,12 +361,10 @@ gdf_error gdf_radixsort_i64(gdf_radixsort_plan_type *hdl, * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_radixsort_f32(gdf_radixsort_plan_type *hdl, gdf_column *keycol, gdf_column *valcol); -/* --------------------------------------------------------------------------*/ /** * @brief performs a radixsort on the key and value columns where the key is an double * @@ -441,12 +374,10 @@ gdf_error gdf_radixsort_f32(gdf_radixsort_plan_type *hdl, * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_radixsort_f64(gdf_radixsort_plan_type *hdl, gdf_column *keycol, gdf_column *valcol); -/* --------------------------------------------------------------------------*/ /** * @brief performs a radixsort on the key and value columns where the key is any type * @@ -456,7 +387,6 @@ gdf_error gdf_radixsort_f64(gdf_radixsort_plan_type *hdl, * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_radixsort_generic(gdf_radixsort_plan_type *hdl, gdf_column *keycol, gdf_column *valcol); @@ -464,7 +394,6 @@ gdf_error gdf_radixsort_generic(gdf_radixsort_plan_type *hdl, /* segmented sorting */ -/* --------------------------------------------------------------------------*/ /** * @brief Constructor for the gdf_segmented_radixsort_plan_type object * @@ -475,13 +404,11 @@ gdf_error gdf_radixsort_generic(gdf_radixsort_plan_type *hdl, * * @Returns gdf_segmented_radixsort_plan_type object pointer */ -/* ----------------------------------------------------------------------------*/ gdf_segmented_radixsort_plan_type* gdf_segmented_radixsort_plan(size_t num_items, int descending, unsigned begin_bit, unsigned end_bit); -/* --------------------------------------------------------------------------*/ /** * @brief Allocates device memory for the segmented radixsort * @@ -491,12 +418,10 @@ gdf_segmented_radixsort_plan_type* gdf_segmented_radixsort_plan(size_t num_items * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_segmented_radixsort_plan_setup(gdf_segmented_radixsort_plan_type *hdl, size_t sizeof_key, size_t sizeof_val); -/* --------------------------------------------------------------------------*/ /** * @brief Frees device memory used for the segmented radixsort * @@ -504,17 +429,15 @@ gdf_error gdf_segmented_radixsort_plan_setup(gdf_segmented_radixsort_plan_type * * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_segmented_radixsort_plan_free(gdf_segmented_radixsort_plan_type *hdl); /* -* The following function performs a sort on the key and value columns. -* The null_count of the keycol and valcol columns are expected to be 0 -* otherwise a GDF_VALIDITY_UNSUPPORTED error is returned. -*/ + * The following function performs a sort on the key and value columns. + * The null_count of the keycol and valcol columns are expected to be 0 + * otherwise a GDF_VALIDITY_UNSUPPORTED error is returned. + */ -/* --------------------------------------------------------------------------*/ /** * @brief performs a segmented radixsort on the key and value columns where the key is an int8 * @@ -527,14 +450,12 @@ gdf_error gdf_segmented_radixsort_plan_free(gdf_segmented_radixsort_plan_type *h * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_segmented_radixsort_i8(gdf_segmented_radixsort_plan_type *hdl, gdf_column *keycol, gdf_column *valcol, unsigned num_segments, unsigned *d_begin_offsets, unsigned *d_end_offsets); -/* --------------------------------------------------------------------------*/ /** * @brief performs a segmented radixsort on the key and value columns where the key is an int32 * @@ -547,14 +468,12 @@ gdf_error gdf_segmented_radixsort_i8(gdf_segmented_radixsort_plan_type *hdl, * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_segmented_radixsort_i32(gdf_segmented_radixsort_plan_type *hdl, gdf_column *keycol, gdf_column *valcol, unsigned num_segments, unsigned *d_begin_offsets, unsigned *d_end_offsets); -/* --------------------------------------------------------------------------*/ /** * @brief performs a segmented radixsort on the key and value columns where the key is an int64 * @@ -567,14 +486,12 @@ gdf_error gdf_segmented_radixsort_i32(gdf_segmented_radixsort_plan_type *hdl, * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_segmented_radixsort_i64(gdf_segmented_radixsort_plan_type *hdl, gdf_column *keycol, gdf_column *valcol, unsigned num_segments, unsigned *d_begin_offsets, unsigned *d_end_offsets); -/* --------------------------------------------------------------------------*/ /** * @brief performs a segmented radixsort on the key and value columns where the key is an float * @@ -587,14 +504,12 @@ gdf_error gdf_segmented_radixsort_i64(gdf_segmented_radixsort_plan_type *hdl, * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_segmented_radixsort_f32(gdf_segmented_radixsort_plan_type *hdl, gdf_column *keycol, gdf_column *valcol, unsigned num_segments, unsigned *d_begin_offsets, unsigned *d_end_offsets); -/* --------------------------------------------------------------------------*/ /** * @brief performs a segmented radixsort on the key and value columns where the key is an double * @@ -607,14 +522,12 @@ gdf_error gdf_segmented_radixsort_f32(gdf_segmented_radixsort_plan_type *hdl, * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_segmented_radixsort_f64(gdf_segmented_radixsort_plan_type *hdl, gdf_column *keycol, gdf_column *valcol, unsigned num_segments, unsigned *d_begin_offsets, unsigned *d_end_offsets); -/* --------------------------------------------------------------------------*/ /** * @brief performs a segmented radixsort on the key and value columns where the key is any type * @@ -627,7 +540,6 @@ gdf_error gdf_segmented_radixsort_f64(gdf_segmented_radixsort_plan_type *hdl, * * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_segmented_radixsort_generic(gdf_segmented_radixsort_plan_type *hdl, gdf_column *keycol, gdf_column *valcol, unsigned num_segments, @@ -642,7 +554,7 @@ gdf_error gdf_segmented_radixsort_generic(gdf_segmented_radixsort_plan_type *hdl * @param[in] ncols Number of columns in in_cols * @param[in] in_cols[] Input table of (ncols) number of columns each of size (nrows) * @param[out] out_cols[] Preallocated output_table of (nrows) columns each of size (ncols) - * @return gdf_error GDF_SUCCESS if successful, else appropriate error code + * @Returns gdf_error GDF_SUCCESS if successful, else appropriate error code */ gdf_error gdf_transpose(gdf_size_type ncols, gdf_column** in_cols, @@ -650,9 +562,6 @@ gdf_error gdf_transpose(gdf_size_type ncols, // joins -// joins - -/* --------------------------------------------------------------------------*/ /** * @brief Performs an inner join on the specified columns of two * dataframes (left, right) @@ -677,10 +586,9 @@ gdf_error gdf_transpose(gdf_size_type ncols, * @param[in] join_context The context to use to control how the join is performed,e.g., * sort vs hash based implementation * - * @returns GDF_SUCCESS if the join operation was successful, otherwise an appropriate + * @Returnss GDF_SUCCESS if the join operation was successful, otherwise an appropriate * error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_inner_join( gdf_column **left_cols, int num_left_cols, @@ -695,7 +603,6 @@ gdf_error gdf_inner_join( gdf_column * right_indices, gdf_context *join_context); -/* --------------------------------------------------------------------------*/ /** * @brief Performs a left join (also known as left outer join) on the * specified columns of two dataframes (left, right) @@ -720,10 +627,9 @@ gdf_error gdf_inner_join( * @param[in] join_context The context to use to control how the join is performed,e.g., * sort vs hash based implementation * - * @returns GDF_SUCCESS if the join operation was successful, otherwise an appropriate + * @Returnss GDF_SUCCESS if the join operation was successful, otherwise an appropriate * error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_left_join( gdf_column **left_cols, int num_left_cols, @@ -738,7 +644,6 @@ gdf_error gdf_left_join( gdf_column * right_indices, gdf_context *join_context); -/* --------------------------------------------------------------------------*/ /** * @brief Performs a full join (also known as full outer join) on the * specified columns of two dataframes (left, right) @@ -763,10 +668,9 @@ gdf_error gdf_left_join( * @param[in] join_context The context to use to control how the join is performed,e.g., * sort vs hash based implementation * - * @returns GDF_SUCCESS if the join operation was successful, otherwise an appropriate + * @Returnss GDF_SUCCESS if the join operation was successful, otherwise an appropriate * error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_full_join( gdf_column **left_cols, int num_left_cols, @@ -783,7 +687,6 @@ gdf_error gdf_full_join( /* partioning */ -/* --------------------------------------------------------------------------*/ /** * @brief Computes the hash values of the rows in the specified columns of the * input columns and bins the hash values into the desired number of partitions. @@ -802,9 +705,8 @@ gdf_error gdf_full_join( * of partition 'i' * @param[in] hash The hash function to use * - * @returns If the operation was successful, returns GDF_SUCCESS + * @Returnss If the operation was successful, returns GDF_SUCCESS */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_hash_partition(int num_input_cols, gdf_column * input[], int columns_to_hash[], @@ -816,7 +718,6 @@ gdf_error gdf_hash_partition(int num_input_cols, /* prefixsum */ -/* --------------------------------------------------------------------------*/ /** * @brief Computes the prefix sum of a column * @@ -824,14 +725,12 @@ gdf_error gdf_hash_partition(int num_input_cols, * @param[out] out The output column containing the prefix sum of the input * @param[in] inclusive Flag for applying an inclusive prefix sum * - * @returns GDF_SUCCESS if the operation was successful, otherwise an appropriate + * @Returnss GDF_SUCCESS if the operation was successful, otherwise an appropriate * error code. If inp->null_count is not set to 0 GDF_VALIDITY_UNSUPPORTED is * returned. */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_prefixsum_generic(gdf_column *inp, gdf_column *out, int inclusive); -/* --------------------------------------------------------------------------*/ /** * @brief Computes the prefix sum of a column * @@ -839,14 +738,12 @@ gdf_error gdf_prefixsum_generic(gdf_column *inp, gdf_column *out, int inclusive) * @param[out] out The output column containing the prefix sum of the input * @param[in] inclusive Flag for applying an inclusive prefix sum * - * @returns GDF_SUCCESS if the operation was successful, otherwise an appropriate + * @Returnss GDF_SUCCESS if the operation was successful, otherwise an appropriate * error code. If inp->null_count is not set to 0 GDF_VALIDITY_UNSUPPORTED is * returned. */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_prefixsum_i8(gdf_column *inp, gdf_column *out, int inclusive); -/* --------------------------------------------------------------------------*/ /** * @brief Computes the prefix sum of a column * @@ -854,14 +751,12 @@ gdf_error gdf_prefixsum_i8(gdf_column *inp, gdf_column *out, int inclusive); * @param[out] out The output column containing the prefix sum of the input * @param[in] inclusive Flag for applying an inclusive prefix sum * - * @returns GDF_SUCCESS if the operation was successful, otherwise an appropriate + * @Returnss GDF_SUCCESS if the operation was successful, otherwise an appropriate * error code. If inp->null_count is not set to 0 GDF_VALIDITY_UNSUPPORTED is * returned. */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_prefixsum_i32(gdf_column *inp, gdf_column *out, int inclusive); -/* --------------------------------------------------------------------------*/ /** * @brief Computes the prefix sum of a column * @@ -869,11 +764,10 @@ gdf_error gdf_prefixsum_i32(gdf_column *inp, gdf_column *out, int inclusive); * @param[out] out The output column containing the prefix sum of the input * @param[in] inclusive Flag for applying an inclusive prefix sum * - * @returns GDF_SUCCESS if the operation was successful, otherwise an appropriate + * @Returnss GDF_SUCCESS if the operation was successful, otherwise an appropriate * error code. If inp->null_count is not set to 0 GDF_VALIDITY_UNSUPPORTED is * returned. */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_prefixsum_i64(gdf_column *inp, gdf_column *out, int inclusive); @@ -891,7 +785,7 @@ gdf_error gdf_prefixsum_i64(gdf_column *inp, gdf_column *out, int inclusive); * then each element will be hashed as-is. * @param[out] output The hash value of each row of the input * - * @return GDF_SUCCESS if the operation was successful, otherwise an + * @Returns GDF_SUCCESS if the operation was successful, otherwise an * appropriate error code. * ----------------------------------------------------------------------------**/ gdf_error gdf_hash(int num_cols, @@ -902,487 +796,408 @@ gdf_error gdf_hash(int num_cols, /* trig */ -/* --------------------------------------------------------------------------*/ /** * @brief Computes trigonometric sine function for any floating point data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_sin_generic(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Computes trigonometric sine function for float data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_sin_f32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Computes trigonometric sine function for double data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_sin_f64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Computes trigonometric cosine function for any floating point data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cos_generic(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Computes trigonometric cosine function for float data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cos_f32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Computes trigonometric cosine function for double data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cos_f64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Computes trigonometric tangent function for any floating point data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_tan_generic(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Computes trigonometric tangent function for float data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_tan_f32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Computes trigonometric tangent function for double data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_tan_f64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Computes trigonometric arcsin function for any floating point data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_asin_generic(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Computes trigonometric arcsin function for float data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_asin_f32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Computes trigonometric arcsin function for double data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_asin_f64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Computes trigonometric arccos function for any floating point data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_acos_generic(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Computes trigonometric arccos function for float data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_acos_f32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Computes trigonometric arccos function for double data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_acos_f64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Computes trigonometric arctan function for any floating point data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_atan_generic(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Computes trigonometric arctan function for a float data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_atan_f32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Computes trigonometric arctan function for a double data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_atan_f64(gdf_column *input, gdf_column *output); /* exponential */ -/* --------------------------------------------------------------------------*/ /** * @brief Computes e (Euler's number, 2.7182818...) raised to the given power arg for any floating point data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_exp_generic(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Computes e (Euler's number, 2.7182818...) raised to the given power arg float data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_exp_f32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Computes e (Euler's number, 2.7182818...) raised to the given power arg for double data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_exp_f64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Computes the natural (base e) logarithm of arg for any floating point data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_log_generic(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Computes the natural (base e) logarithm of arg for float data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_log_f32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Computes the natural (base e) logarithm of arg for double data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_log_f64(gdf_column *input, gdf_column *output); /* power */ -/* --------------------------------------------------------------------------*/ /** * @brief Computes the square root for any floating point data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_sqrt_generic(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Computes the square root for float data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_sqrt_f32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Computes the square root for double data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_sqrt_f64(gdf_column *input, gdf_column *output); /* rounding */ -/* --------------------------------------------------------------------------*/ /** * @brief Computes the smallest integer value not less than arg for any floating point data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_ceil_generic(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Computes the smallest integer value not less than arg for float data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_ceil_f32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Computes the smallest integer value not less than arg for double data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_ceil_f64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Computes the largest integer value not greater than arg for any floating point data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_floor_generic(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Computes the largest integer value not greater than arg for float data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_floor_f32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Computes the largest integer value not greater than arg for double data type * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_floor_f64(gdf_column *input, gdf_column *output); /* casting */ -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column of any data type to a GDF_FLOAT32 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_generic_to_f32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column of type GDF_INT8 to a GDF_FLOAT32 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i8_to_f32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column of type GDF_INT32 to a GDF_FLOAT32 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i32_to_f32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column of type GDF_INT64 to a GDF_FLOAT32 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i64_to_f32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column of type GDF_FLOAT32 to a GDF_FLOAT32 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_f32_to_f32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column of type GDF_FLOAT64 to a GDF_FLOAT32 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_f64_to_f32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column of type GDF_DATE32 to a GDF_FLOAT32 * @@ -1391,12 +1206,10 @@ gdf_error gdf_cast_f64_to_f32(gdf_column *input, gdf_column *output); * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_date32_to_f32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column of type GDF_DATE64 to a GDF_FLOAT32 * @@ -1405,12 +1218,10 @@ gdf_error gdf_cast_date32_to_f32(gdf_column *input, gdf_column *output); * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_date64_to_f32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column of type GDF_TIMESTAMP to a GDF_FLOAT32 * @@ -1419,84 +1230,70 @@ gdf_error gdf_cast_date64_to_f32(gdf_column *input, gdf_column *output); * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_timestamp_to_f32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column of any data type to a GDF_FLOAT64 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_generic_to_f64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_INT8 to a GDF_FLOAT64 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i8_to_f64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_INT32 to a GDF_FLOAT64 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i32_to_f64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_INT64 to a GDF_FLOAT64 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i64_to_f64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_FLOAT32 to a GDF_FLOAT64 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_f32_to_f64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_FLOAT64 to a GDF_FLOAT64 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_f64_to_f64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_DATE32 to a GDF_FLOAT64 * @@ -1505,12 +1302,10 @@ gdf_error gdf_cast_f64_to_f64(gdf_column *input, gdf_column *output); * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_date32_to_f64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_DATE64 to a GDF_FLOAT64 * @@ -1519,12 +1314,10 @@ gdf_error gdf_cast_date32_to_f64(gdf_column *input, gdf_column *output); * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_date64_to_f64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_TIMESTAMP to a GDF_FLOAT64 * @@ -1533,84 +1326,70 @@ gdf_error gdf_cast_date64_to_f64(gdf_column *input, gdf_column *output); * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_timestamp_to_f64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column of any data type to a GDF_INT8 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_generic_to_i8(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_INT8 to a GDF_INT8 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i8_to_i8(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_INT32 to a GDF_INT8 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i32_to_i8(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_INT64 to a GDF_INT8 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i64_to_i8(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_FLOAT32 to a GDF_INT8 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_f32_to_i8(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_FLOAT64 to a GDF_INT8 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_f64_to_i8(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_DATE32 to a GDF_INT8 * @@ -1619,12 +1398,10 @@ gdf_error gdf_cast_f64_to_i8(gdf_column *input, gdf_column *output); * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_date32_to_i8(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_DATE64 to a GDF_INT8 * @@ -1633,12 +1410,10 @@ gdf_error gdf_cast_date32_to_i8(gdf_column *input, gdf_column *output); * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_date64_to_i8(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_TIMESTAMP to a GDF_INT8 * @@ -1647,84 +1422,70 @@ gdf_error gdf_cast_date64_to_i8(gdf_column *input, gdf_column *output); * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_timestamp_to_i8(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column of any data type to a GDF_INT32 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_generic_to_i32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_INT8 to a GDF_INT32 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i8_to_i32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_INT32 to a GDF_INT32 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i32_to_i32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_INT64 to a GDF_INT32 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i64_to_i32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_FLOAT32 to a GDF_INT32 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_f32_to_i32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_FLOAT64 to a GDF_INT32 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_f64_to_i32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_DATE32 to a GDF_INT32 * @@ -1733,12 +1494,10 @@ gdf_error gdf_cast_f64_to_i32(gdf_column *input, gdf_column *output); * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_date32_to_i32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_DATE64 to a GDF_INT32 * @@ -1747,12 +1506,10 @@ gdf_error gdf_cast_date32_to_i32(gdf_column *input, gdf_column *output); * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_date64_to_i32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_TIMESTAMP to a GDF_INT32 * @@ -1761,84 +1518,70 @@ gdf_error gdf_cast_date64_to_i32(gdf_column *input, gdf_column *output); * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_timestamp_to_i32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column of any data type to a GDF_INT64 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_generic_to_i64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_INT8 to a GDF_INT64 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i8_to_i64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_INT32 to a GDF_INT64 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i32_to_i64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_INT64 to a GDF_INT64 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i64_to_i64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_FLOAT32 to a GDF_INT64 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_f32_to_i64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_FLOAT64 to a GDF_INT64 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_f64_to_i64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_DATE32 to a GDF_INT64 * @@ -1847,12 +1590,10 @@ gdf_error gdf_cast_f64_to_i64(gdf_column *input, gdf_column *output); * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_date32_to_i64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_DATE64 to a GDF_INT64 * @@ -1861,12 +1602,10 @@ gdf_error gdf_cast_date32_to_i64(gdf_column *input, gdf_column *output); * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_date64_to_i64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_TIMESTAMP to a GDF_INT64 * @@ -1875,24 +1614,20 @@ gdf_error gdf_cast_date64_to_i64(gdf_column *input, gdf_column *output); * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_timestamp_to_i64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column of any data type to a GDF_DATE32 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_generic_to_date32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_INT8 to a GDF_DATE32 * @@ -1901,12 +1636,10 @@ gdf_error gdf_cast_generic_to_date32(gdf_column *input, gdf_column *output); * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i8_to_date32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_INT32 to a GDF_DATE32 * @@ -1915,12 +1648,10 @@ gdf_error gdf_cast_i8_to_date32(gdf_column *input, gdf_column *output); * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i32_to_date32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_INT64 to a GDF_DATE32 * @@ -1929,12 +1660,10 @@ gdf_error gdf_cast_i32_to_date32(gdf_column *input, gdf_column *output); * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i64_to_date32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_FLOAT32 to a GDF_DATE32 * @@ -1943,12 +1672,10 @@ gdf_error gdf_cast_i64_to_date32(gdf_column *input, gdf_column *output); * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_f32_to_date32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_FLOAT64 to a GDF_DATE32 * @@ -1957,24 +1684,20 @@ gdf_error gdf_cast_f32_to_date32(gdf_column *input, gdf_column *output); * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_f64_to_date32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_DATE32 to a GDF_DATE32 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_date32_to_date32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_DATE64 to a GDF_DATE32 * @@ -1983,12 +1706,10 @@ gdf_error gdf_cast_date32_to_date32(gdf_column *input, gdf_column *output); * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_date64_to_date32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_TIMESTAMP to a GDF_DATE32 * @@ -1997,24 +1718,20 @@ gdf_error gdf_cast_date64_to_date32(gdf_column *input, gdf_column *output); * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_timestamp_to_date32(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column of any data type to a GDF_FLOAT64 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_generic_to_date64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_INT8 to a GDF_DATE64 * @@ -2023,12 +1740,10 @@ gdf_error gdf_cast_generic_to_date64(gdf_column *input, gdf_column *output); * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i8_to_date64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_INT32 to a GDF_DATE64 * @@ -2037,12 +1752,10 @@ gdf_error gdf_cast_i8_to_date64(gdf_column *input, gdf_column *output); * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i32_to_date64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_INT64 to a GDF_DATE64 * @@ -2051,12 +1764,10 @@ gdf_error gdf_cast_i32_to_date64(gdf_column *input, gdf_column *output); * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i64_to_date64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_FLOAT32 to a GDF_DATE64 * @@ -2065,12 +1776,10 @@ gdf_error gdf_cast_i64_to_date64(gdf_column *input, gdf_column *output); * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_f32_to_date64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_FLOAT64 to a GDF_DATE64 * @@ -2079,12 +1788,10 @@ gdf_error gdf_cast_f32_to_date64(gdf_column *input, gdf_column *output); * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_f64_to_date64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_DATE32 to a GDF_DATE64 * @@ -2093,24 +1800,20 @@ gdf_error gdf_cast_f64_to_date64(gdf_column *input, gdf_column *output); * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_date32_to_date64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_DATE64 to a GDF_DATE64 * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_date64_to_date64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_TIMESTAMP to a GDF_DATE32 * @@ -2119,24 +1822,20 @@ gdf_error gdf_cast_date64_to_date64(gdf_column *input, gdf_column *output); * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_timestamp_to_date64(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column of any data type to a GDF_TIMESTAMP * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_generic_to_timestamp(gdf_column *input, gdf_column *output, gdf_time_unit time_unit); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_INT8 to a GDF_TIMESTAMP * @@ -2145,12 +1844,10 @@ gdf_error gdf_cast_generic_to_timestamp(gdf_column *input, gdf_column *output, g * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i8_to_timestamp(gdf_column *input, gdf_column *output, gdf_time_unit time_unit); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_INT32 to a GDF_TIMESTAMP * @@ -2159,12 +1856,10 @@ gdf_error gdf_cast_i8_to_timestamp(gdf_column *input, gdf_column *output, gdf_ti * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i32_to_timestamp(gdf_column *input, gdf_column *output, gdf_time_unit time_unit); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_INT64 to a GDF_TIMESTAMP * @@ -2173,12 +1868,10 @@ gdf_error gdf_cast_i32_to_timestamp(gdf_column *input, gdf_column *output, gdf_t * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_i64_to_timestamp(gdf_column *input, gdf_column *output, gdf_time_unit time_unit); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_FLOAT32 to a GDF_TIMESTAMP * @@ -2187,12 +1880,10 @@ gdf_error gdf_cast_i64_to_timestamp(gdf_column *input, gdf_column *output, gdf_t * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_f32_to_timestamp(gdf_column *input, gdf_column *output, gdf_time_unit time_unit); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_FLOAT64 to a GDF_TIMESTAMP * @@ -2201,12 +1892,10 @@ gdf_error gdf_cast_f32_to_timestamp(gdf_column *input, gdf_column *output, gdf_t * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_f64_to_timestamp(gdf_column *input, gdf_column *output, gdf_time_unit time_unit); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_DATE32 to a GDF_TIMESTAMP * @@ -2215,12 +1904,10 @@ gdf_error gdf_cast_f64_to_timestamp(gdf_column *input, gdf_column *output, gdf_t * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_date32_to_timestamp(gdf_column *input, gdf_column *output, gdf_time_unit time_unit); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_DATE64 to a GDF_TIMESTAMP * @@ -2229,96 +1916,81 @@ gdf_error gdf_cast_date32_to_timestamp(gdf_column *input, gdf_column *output, gd * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_date64_to_timestamp(gdf_column *input, gdf_column *output, gdf_time_unit time_unit); -/* --------------------------------------------------------------------------*/ /** * @brief Casts data in a gdf_column type GDF_TIMESTAMP to a GDF_TIMESTAMP * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_cast_timestamp_to_timestamp(gdf_column *input, gdf_column *output, gdf_time_unit time_unit); /* datetime extract*/ -/* --------------------------------------------------------------------------*/ /** * @brief Extracts year from any date time type and places results into a preallocated GDF_INT16 column * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_extract_datetime_year(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Extracts month from any date time type and places results into a preallocated GDF_INT16 column * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_extract_datetime_month(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Extracts day from any date time type and places results into a preallocated GDF_INT16 column * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_extract_datetime_day(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Extracts hour from either GDF_DATE64 or GDF_TIMESTAMP type and places results into a preallocated GDF_INT16 column * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_extract_datetime_hour(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Extracts minute from either GDF_DATE64 or GDF_TIMESTAMP type and places results into a preallocated GDF_INT16 column * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_extract_datetime_minute(gdf_column *input, gdf_column *output); -/* --------------------------------------------------------------------------*/ /** * @brief Extracts second from either GDF_DATE64 or GDF_TIMESTAMP type and places results into a preallocated GDF_INT16 column * * @param[in] gdf_column of the input * @param[out] output gdf_column. The output memory needs to be preallocated * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_extract_datetime_second(gdf_column *input, gdf_column *output); @@ -2432,20 +2104,20 @@ size for this use. */ -/* --------------------------------------------------------------------------* +/** * @brief Reports the intermediate buffer size in elements required for * all cuDF reduction operations (gdf_sum, gdf_product, * gdf_sum_of_squares, gdf_min and gdf_max) - * * - * @return The size of output/intermediate buffer to allocate for reductions + * + * @Returns The size of output/intermediate buffer to allocate for reductions * * @todo Reductions should be re-implemented to use an atomic add for each * block sum rather than launch a second kernel. When that happens, this * function can go away and the output can be a single element. - * --------------------------------------------------------------------------*/ + */ unsigned int gdf_reduction_get_intermediate_output_size(); -/* --------------------------------------------------------------------------* +/** * @brief Computes the sum of the values in all rows of a column * * @param[in] col Input column @@ -2455,13 +2127,13 @@ unsigned int gdf_reduction_get_intermediate_output_size(); * This is used as intermediate storage, and the * first element contains the total result * - * @return GDF_SUCCESS if the operation was successful, otherwise an + * @Returns GDF_SUCCESS if the operation was successful, otherwise an * appropriate error code. * - * --------------------------------------------------------------------------*/ + */ gdf_error gdf_sum(gdf_column *col, void *dev_result, gdf_size_type dev_result_size); -/* --------------------------------------------------------------------------* +/** * @brief Computes the multiplicative product of the values in all rows of * a column * @@ -2472,12 +2144,12 @@ gdf_error gdf_sum(gdf_column *col, void *dev_result, gdf_size_type dev_result_si * This is used as intermediate storage, and the * first element contains the total result * - * @return GDF_SUCCESS if the operation was successful, otherwise an + * @Returns GDF_SUCCESS if the operation was successful, otherwise an * appropriate error code. - * --------------------------------------------------------------------------*/ + */ gdf_error gdf_product(gdf_column *col, void *dev_result, gdf_size_type dev_result_size); -/* --------------------------------------------------------------------------* +/** * @brief Computes the sum of squares of the values in all rows of a column * * Sum of squares is useful for variance implementation. @@ -2489,15 +2161,15 @@ gdf_error gdf_product(gdf_column *col, void *dev_result, gdf_size_type dev_resul * This is used as intermediate storage, and the * first element contains the total result * - * @return GDF_SUCCESS if the operation was successful, otherwise an + * @Returns GDF_SUCCESS if the operation was successful, otherwise an * appropriate error code. * * @todo could be implemented using inner_product if that function is * implemented - * --------------------------------------------------------------------------*/ + */ gdf_error gdf_sum_of_squares(gdf_column *col, void *dev_result, gdf_size_type dev_result_size); -/* --------------------------------------------------------------------------* +/** * @brief Computes the minimum of the values in all rows of a column * * @param[in] col Input column @@ -2507,13 +2179,13 @@ gdf_error gdf_sum_of_squares(gdf_column *col, void *dev_result, gdf_size_type de * This is used as intermediate storage, and the * first element contains the total result * - * @return GDF_SUCCESS if the operation was successful, otherwise an + * @Returns GDF_SUCCESS if the operation was successful, otherwise an * appropriate error code. * - * --------------------------------------------------------------------------*/ + */ gdf_error gdf_min(gdf_column *col, void *dev_result, gdf_size_type dev_result_size); -/* --------------------------------------------------------------------------* +/** * @brief Computes the maximum of the values in all rows of a column * * @param[in] col Input column @@ -2523,10 +2195,10 @@ gdf_error gdf_min(gdf_column *col, void *dev_result, gdf_size_type dev_result_si * This is used as intermediate storage, and the * first element contains the total result * - * @return GDF_SUCCESS if the operation was successful, otherwise an + * @Returns GDF_SUCCESS if the operation was successful, otherwise an * appropriate error code. * - * --------------------------------------------------------------------------*/ + */ gdf_error gdf_max(gdf_column *col, void *dev_result, gdf_size_type dev_result_size); @@ -2534,7 +2206,6 @@ gdf_error gdf_max(gdf_column *col, void *dev_result, gdf_size_type dev_result_si * Filtering and comparison operators */ -/* --------------------------------------------------------------------------*/ /** * @brief Compare every value on the left hand side to a static value and return a stencil in output which will have 1 when the comparison operation returns 1 and 0 otherwise * @@ -2543,12 +2214,10 @@ gdf_error gdf_max(gdf_column *col, void *dev_result, gdf_size_type dev_result_si * @param[out] output gdf_column of type GDF_INT8. The output memory needs to be preallocated * @param[in] gdf_comparison_operator enum defining the comparison operator to be used * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_comparison_static_i8(gdf_column *lhs, int8_t value, gdf_column *output,gdf_comparison_operator operation); -/* --------------------------------------------------------------------------*/ /** * @brief Compare every value on the left hand side to a static value and return a stencil in output which will have 1 when the comparison operation returns 1 and 0 otherwise * @@ -2557,12 +2226,10 @@ gdf_error gdf_comparison_static_i8(gdf_column *lhs, int8_t value, gdf_column *ou * @param[out] output gdf_column of type GDF_INT8. The output memory needs to be preallocated * @param[in] gdf_comparison_operator enum defining the comparison operator to be used * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_comparison_static_i16(gdf_column *lhs, int16_t value, gdf_column *output,gdf_comparison_operator operation); -/* --------------------------------------------------------------------------*/ /** * @brief Compare every value on the left hand side to a static value and return a stencil in output which will have 1 when the comparison operation returns 1 and 0 otherwise * @@ -2571,12 +2238,10 @@ gdf_error gdf_comparison_static_i16(gdf_column *lhs, int16_t value, gdf_column * * @param[out] output gdf_column of type GDF_INT8. The output memory needs to be preallocated * @param[in] gdf_comparison_operator enum defining the comparison operator to be used * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_comparison_static_i32(gdf_column *lhs, int32_t value, gdf_column *output,gdf_comparison_operator operation); -/* --------------------------------------------------------------------------*/ /** * @brief Compare every value on the left hand side to a static value and return a stencil in output which will have 1 when the comparison operation returns 1 and 0 otherwise * @@ -2585,12 +2250,10 @@ gdf_error gdf_comparison_static_i32(gdf_column *lhs, int32_t value, gdf_column * * @param[out] output gdf_column of type GDF_INT8. The output memory needs to be preallocated * @param[in] gdf_comparison_operator enum defining the comparison operator to be used * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_comparison_static_i64(gdf_column *lhs, int64_t value, gdf_column *output,gdf_comparison_operator operation); -/* --------------------------------------------------------------------------*/ /** * @brief Compare every value on the left hand side to a static value and return a stencil in output which will have 1 when the comparison operation returns 1 and 0 otherwise * @@ -2599,12 +2262,10 @@ gdf_error gdf_comparison_static_i64(gdf_column *lhs, int64_t value, gdf_column * * @param[out] output gdf_column of type GDF_INT8. The output memory needs to be preallocated * @param[in] gdf_comparison_operator enum defining the comparison operator to be used * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_comparison_static_f32(gdf_column *lhs, float value, gdf_column *output,gdf_comparison_operator operation); -/* --------------------------------------------------------------------------*/ /** * @brief Compare every value on the left hand side to a static value and return a stencil in output which will have 1 when the comparison operation returns 1 and 0 otherwise * @@ -2613,12 +2274,10 @@ gdf_error gdf_comparison_static_f32(gdf_column *lhs, float value, gdf_column *ou * @param[out] output gdf_column of type GDF_INT8. The output memory needs to be preallocated * @param[in] gdf_comparison_operator enum defining the comparison operator to be used * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_comparison_static_f64(gdf_column *lhs, double value, gdf_column *output,gdf_comparison_operator operation); -/* --------------------------------------------------------------------------*/ /** * @brief Compare two columns of any types against each other using a comparison operation, returns a stencil in output which will have 1 when the comparison operation returns 1 and 0 otherwise * @@ -2627,12 +2286,10 @@ gdf_error gdf_comparison_static_f64(gdf_column *lhs, double value, gdf_column *o * @param[out] output gdf_column of type GDF_INT8. The output memory needs to be preallocated * @param[in] gdf_comparison_operator enum defining the comparison operator to be used * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_comparison(gdf_column *lhs, gdf_column *rhs, gdf_column *output,gdf_comparison_operator operation); -/* --------------------------------------------------------------------------*/ /** * @brief takes a stencil and uses it to compact a colum e.g. remove all values for which the stencil = 0 * @@ -2640,12 +2297,10 @@ gdf_error gdf_comparison(gdf_column *lhs, gdf_column *rhs, gdf_column *output,gd * @param[in] gdf_column holding the stencil * @param[out] output gdf_column of same type as input. The output memory needs to be preallocated to be the same size as input * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_apply_stencil(gdf_column *lhs, gdf_column * stencil, gdf_column * output); -/* --------------------------------------------------------------------------*/ /** * @brief Concatenates two gdf_columns * @@ -2653,9 +2308,8 @@ gdf_error gdf_apply_stencil(gdf_column *lhs, gdf_column * stencil, gdf_column * * @param[in] gdf_column of same type as the first * @param[out] output gdf_column of same type as inputs. The output memory needs to be preallocated to be the same size as the sum of both inputs * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_concat(gdf_column *lhs, gdf_column *rhs, gdf_column *output); @@ -2663,7 +2317,6 @@ gdf_error gdf_concat(gdf_column *lhs, gdf_column *rhs, gdf_column *output); * Hashing */ -/* --------------------------------------------------------------------------*/ /** * @brief Creates a hash of multiple gdf_columns * @@ -2672,9 +2325,8 @@ gdf_error gdf_concat(gdf_column *lhs, gdf_column *rhs, gdf_column *output); * @param[out] output gdf_column of type GDF_INT64. The output memory needs to be preallocated * @param[in] A pointer to a cudaStream_t. If nullptr, the function will create a stream to use. * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_hash_columns(gdf_column ** columns_to_hash, int num_columns, gdf_column * output_column, void * stream); @@ -2682,16 +2334,14 @@ gdf_error gdf_hash_columns(gdf_column ** columns_to_hash, int num_columns, gdf_c * gdf introspection utlities */ -/* --------------------------------------------------------------------------*/ /** * @brief Returns the byte width of the data type of the gdf_column * * @param[in] gdf_column whose data type's byte width will be determined * @param[out] the byte width of the data type * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error get_column_byte_width(gdf_column * col, int * width); @@ -2702,7 +2352,6 @@ gdf_error get_column_byte_width(gdf_column * col, int * width); GROUP-BY */ -/* --------------------------------------------------------------------------*/ /** * @brief Performs SQL like WHERE (Filtering) * @@ -2715,9 +2364,8 @@ gdf_error get_column_byte_width(gdf_column * col, int * width); * @param[out] device-side array of row indices that remain after filtering * @param[out] host-side # rows that remain after filtering * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_filter(size_t nrows, gdf_column* cols, size_t ncols, @@ -2737,10 +2385,9 @@ gdf_error gdf_filter(size_t nrows, * @param[out] if not null return the grouped-by columns (multi-gather based on indices, which are needed anyway) * @param[out] aggregation result * @param[in] struct with additional info: bool is_sorted, flag_sort_or_hash, bool flag_count_distinct - * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_group_by_sum(int ncols, gdf_column** cols, gdf_column* col_agg, @@ -2759,10 +2406,9 @@ gdf_error gdf_group_by_sum(int ncols, * @param[out] if not null return the grouped-by columns (multi-gather based on indices, which are needed anyway) * @param[out] aggregation result * @param[in] struct with additional info: bool is_sorted, flag_sort_or_hash, bool flag_count_distinct - * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_group_by_min(int ncols, gdf_column** cols, gdf_column* col_agg, @@ -2781,10 +2427,9 @@ gdf_error gdf_group_by_min(int ncols, * @param[out] if not null return the grouped-by columns (multi-gather based on indices, which are needed anyway) * @param[out] aggregation result * @param[in] struct with additional info: bool is_sorted, flag_sort_or_hash, bool flag_count_distinct - * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_group_by_max(int ncols, gdf_column** cols, gdf_column* col_agg, @@ -2803,10 +2448,9 @@ gdf_error gdf_group_by_max(int ncols, * @param[out] if not null return the grouped-by columns (multi-gather based on indices, which are needed anyway) * @param[out] aggregation result * @param[in] struct with additional info: bool is_sorted, flag_sort_or_hash, bool flag_count_distinct - * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_group_by_avg(int ncols, gdf_column** cols, gdf_column* col_agg, @@ -2825,10 +2469,9 @@ gdf_error gdf_group_by_avg(int ncols, * @param[out] if not null return the grouped-by columns (multi-gather based on indices, which are needed anyway) * @param[out] aggregation result * @param[in] struct with additional info: bool is_sorted, flag_sort_or_hash, bool flag_count_distinct - * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_group_by_count(int ncols, gdf_column** cols, gdf_column* col_agg, @@ -2845,10 +2488,9 @@ gdf_error gdf_group_by_count(int ncols, * @param[in] requested quantile in [0,1] * @param[out] result; for should probably be double*; it's void* because: (1) for uniformity of interface with ; (2) for possible types bigger than double, in the future; * @param[in] struct with additional info - * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ gdf_error gdf_quantile_exact(gdf_column* col_in, gdf_quantile_method prec, double q, @@ -2862,16 +2504,14 @@ gdf_error gdf_quantile_exact(gdf_column* col_in, * @param[in] requested quantile in [0,1] * @param[out] result; type-erased result of same type as column; * @param[in] struct with additional info - * -* @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code + * + * @Returns GDF_SUCCESS upon successful compute, otherwise returns appropriate error code */ -/* ----------------------------------------------------------------------------*/ -gdf_error gdf_quantile_aprrox(gdf_column* col_in, +gdf_error gdf_quantile_approx(gdf_column* col_in, double q, void* t_erased_res, gdf_context* ctxt); -/* --------------------------------------------------------------------------*/ /** * @brief Replace elements from `col` according to the mapping `old_values` to * `new_values`, that is, replace all `old_values[i]` present in `col` @@ -2881,14 +2521,13 @@ gdf_error gdf_quantile_aprrox(gdf_column* col_in, * @param[in] old_values gdf_column with the old values to be replaced * @param[in] new_values gdf_column with the new values * - * @returns GDF_SUCCESS upon successful completion + * @Returnss GDF_SUCCESS upon successful completion * - * --------------------------------------------------------------------------*/ + */ gdf_error gdf_find_and_replace_all(gdf_column* col, const gdf_column* old_values, const gdf_column* new_values); -/* --------------------------------------------------------------------------*/ /** * @brief Sorts an array of gdf_column. * @@ -2902,16 +2541,15 @@ gdf_error gdf_find_and_replace_all(gdf_column* col, * @param[out] output_indices Pre-allocated gdf_column to be filled with sorted * indices * - * @returns GDF_SUCCESS upon successful completion - * - * ----------------------------------------------------------------------------*/ + * @Returnss GDF_SUCCESS upon successful completion + */ gdf_error gdf_order_by(gdf_column** input_columns, int8_t* asc_desc, size_t num_inputs, gdf_column* output_indices, int flag_nulls_are_smallest); -/* --------------------------------------------------------------------------* +/** * @brief Replaces all null values in a column with either a specific value or corresponding values of another column * * This function is a binary function. It will take in two gdf_columns. @@ -2932,11 +2570,10 @@ gdf_error gdf_order_by(gdf_column** input_columns, * @param[in] col_in A gdf_column that is of size 1 or same size as col_out, contains value / values to be placed in col_out * * @Returns GDF_SUCCESS upon successful completion - * - * --------------------------------------------------------------------------*/ + */ gdf_error gdf_replace_nulls(gdf_column* col_out, const gdf_column* col_in); -/* --------------------------------------------------------------------------* +/** * @brief Finds the indices of the bins in which each value of the column * belongs. * @@ -2954,10 +2591,9 @@ gdf_error gdf_replace_nulls(gdf_column* col_out, * @param[out] out_indices Output device array of same size as `col` * to be filled with bin indices * - * @return GDF_SUCCESS upon successful completion, otherwise an + * @Returns GDF_SUCCESS upon successful completion, otherwise an * appropriate error code. - * - * ----------------------------------------------------------------------------*/ + */ gdf_error gdf_digitize(gdf_column* col, gdf_column* bins, // same type as col bool right, diff --git a/cpp/src/quantiles/quantiles.cu b/cpp/src/quantiles/quantiles.cu index 6b92caea69ff..895617d4c483 100644 --- a/cpp/src/quantiles/quantiles.cu +++ b/cpp/src/quantiles/quantiles.cu @@ -204,7 +204,7 @@ gdf_error gdf_quantile_exact( gdf_column* col_in, //input column; return ret; } -gdf_error gdf_quantile_aprrox( gdf_column* col_in, //input column; +gdf_error gdf_quantile_approx( gdf_column* col_in, //input column; double q, //requested quantile in [0,1] void* t_erased_res, //type-erased result of same type as column; gdf_context* ctxt) //context info diff --git a/cpp/tests/quantiles/quantiles_test.cu b/cpp/tests/quantiles/quantiles_test.cu index 6edbc6d703b5..87d6719f1090 100644 --- a/cpp/tests/quantiles/quantiles_test.cu +++ b/cpp/tests/quantiles/quantiles_test.cu @@ -65,7 +65,7 @@ void f_quantile_tester(gdf_column* col_in, std::vector& v_out_exact, std: { VType res = 0; auto q = qvals[j]; - gdf_error ret = gdf_quantile_aprrox(col_in, q, &res, &ctxt); + gdf_error ret = gdf_quantile_approx(col_in, q, &res, &ctxt); v_out_exact[j] = res; EXPECT_EQ( ret, expected_error) << "approx " << " returns unexpected failure\n"; diff --git a/python/cudf/_gdf.py b/python/cudf/_gdf.py index 50fcacbbb0e5..a8f744a95705 100644 --- a/python/cudf/_gdf.py +++ b/python/cudf/_gdf.py @@ -591,7 +591,7 @@ def quantile(column, quant, method, exact): ffi.cast('void *', px), gdf_context) else: - libgdf.gdf_quantile_aprrox(column.cffi_view, + libgdf.gdf_quantile_approx(column.cffi_view, q, ffi.cast('void *', px), gdf_context) diff --git a/python/cudf/bindings/cudf_cpp.pxd b/python/cudf/bindings/cudf_cpp.pxd index 99f3e67d0a15..5182576f3b8a 100644 --- a/python/cudf/bindings/cudf_cpp.pxd +++ b/python/cudf/bindings/cudf_cpp.pxd @@ -670,7 +670,7 @@ cdef extern from "cudf.h" nogil: gdf_context* ctxt) - cdef gdf_error gdf_quantile_aprrox( gdf_column* col_in, + cdef gdf_error gdf_quantile_approx( gdf_column* col_in, double q, void* t_erased_res, gdf_context* ctxt)