Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
cudf Namespace Reference

cuDF interfaces More...

Namespaces

 dictionary
 Dictionary column APIs.
 
 groupby
 groupby APIs
 
 io
 IO interfaces.
 
 strings
 Strings column APIs.
 

Classes

class  aggregation
 Base class for specifying the desired aggregation in an aggregation_request. More...
 
class  chrono_scalar
 An owning class to represent a timestamp/duration value in device memory. More...
 
class  column
 A container of nullable device data as a column of elements. More...
 
class  column_device_view
 An immutable, non-owning view of device data as a column of elements that is trivially copyable and usable in CUDA device code. More...
 
struct  column_metadata
 Detailed meta data information for arrow array. More...
 
class  column_view
 A non-owning, immutable view of device data as a column of elements, some of which may be null as indicated by a bitmask. More...
 
struct  cuda_error
 Exception thrown when a CUDA error is encountered. More...
 
class  data_type
 Indicator for the logical data type of an element in a column. More...
 
class  dictionary_column_view
 A wrapper class for operations on a dictionary column. More...
 
struct  dictionary_wrapper
 A strongly typed wrapper for indices in a DICTIONARY type column. More...
 
class  duration_scalar
 
class  duration_scalar_device_view
 A type of scalar_device_view that stores a pointer to a duration value. More...
 
class  element_equality_comparator
 Performs an equality comparison between two elements in two columns. More...
 
class  element_hasher
 Computes the hash value of an element in the given column. More...
 
class  element_hasher_with_seed
 
class  element_relational_comparator
 Performs a relational comparison between two elements in two columns. More...
 
class  fixed_point_scalar
 An owning class to represent a fixed_point number in device memory. More...
 
class  fixed_point_scalar_device_view
 A type of scalar_device_view that stores a pointer to a fixed_point value. More...
 
class  hash_join
 Hash join that builds hash table in creation and probes results in subsequent *_join member functions. More...
 
struct  id_to_type_impl
 
struct  index_element_fn
 Dispatch functor for resolving the index value for a dictionary element. More...
 
struct  is_boolean_impl
 
struct  is_chrono_impl
 
struct  is_compound_impl
 
struct  is_convertible
 
struct  is_convertible< cudf::detail::timestamp< Duration1 >, cudf::detail::timestamp< Duration2 > >
 
struct  is_dictionary_impl
 
struct  is_duration_impl
 
struct  is_equality_comparable_impl
 
struct  is_equality_comparable_impl< L, R, void_t< equality_comparable< L, R > > >
 
struct  is_fixed_point_impl
 
struct  is_fixed_width_impl
 
struct  is_floating_point_impl
 
struct  is_index_type_impl
 
struct  is_logically_castable_from_impl
 
struct  is_logically_castable_impl
 
struct  is_logically_castable_impl< Type, Type >
 
struct  is_logically_castable_to_impl
 
struct  is_nested_impl
 
struct  is_numeric_impl
 
struct  is_relationally_comparable_impl
 
struct  is_relationally_comparable_impl< L, R, void_t< less_comparable< L, R >, greater_comparable< L, R > > >
 
struct  is_timestamp_impl
 
struct  is_unsigned_impl
 
class  list_device_view
 A non-owning, immutable view of device data that represents a list of elements of arbitrary type (including further nested lists). More...
 
struct  list_size_functor
 returns size of the list by row index More...
 
class  list_view
 A non-owning, immutable view of device data that represents a list of elements of arbitrary type (including further nested lists). More...
 
class  lists_column_view
 Given a column-view of lists type, an instance of this class provides a wrapper on this compound column for list operations. More...
 
struct  logic_error
 Exception thrown when logical precondition is violated. More...
 
class  mutable_column_device_view
 A mutable, non-owning view of device data as a column of elements that is trivially copyable and usable in CUDA device code. More...
 
class  mutable_column_view
 A non-owning, mutable view of device data as a column of elements, some of which may be null as indicated by a bitmask. More...
 
class  mutable_table_device_view
 
class  mutable_table_view
 A set of mutable_column_views of the same size. More...
 
class  numeric_scalar
 An owning class to represent a numerical value in device memory. More...
 
class  numeric_scalar_device_view
 A type of scalar_device_view that stores a pointer to a numerical value. More...
 
struct  order_info
 Indicates how a collection of values has been ordered. More...
 
struct  packed_columns
 Column data in a serialized format. More...
 
struct  packed_table
 The result(s) of a contiguous_split More...
 
class  row_equality_comparator
 
class  row_hasher
 Computes the hash value of a row in the given table. More...
 
class  row_hasher_initial_values
 Computes the hash value of a row in the given table, combined with an initial hash value for each column. More...
 
class  row_lexicographic_comparator
 Computes whether one row is lexicographically less than another row. More...
 
class  scalar
 An owning class to represent a singular value. More...
 
class  string_scalar
 An owning class to represent a string in device memory. More...
 
class  string_scalar_device_view
 A type of scalar_device_view that stores a pointer to a string value. More...
 
class  string_view
 A non-owning, immutable view of device data that is a variable length char array representing a UTF-8 string. More...
 
class  strings_column_view
 Given a column-view of strings type, an instance of this class provides a wrapper on this compound column for strings operations. More...
 
class  struct_view
 A non-owning, immutable view of device data that represents a struct with fields of arbitrary types (including primitives, lists, and other structs) More...
 
class  structs_column_view
 
class  table
 A set of cudf::column's of the same size. More...
 
class  table_device_view
 
class  table_view
 A set of cudf::column_view's of the same size. More...
 
class  timestamp_scalar
 
class  timestamp_scalar_device_view
 A type of scalar_device_view that stores a pointer to a timestamp value. More...
 
struct  type_to_name
 
struct  type_to_scalar_type_impl
 
struct  type_to_scalar_type_impl< cudf::dictionary32 >
 
struct  type_to_scalar_type_impl< cudf::list_view >
 
struct  type_to_scalar_type_impl< cudf::string_view >
 
struct  type_to_scalar_type_impl< cudf::struct_view >
 
struct  type_to_scalar_type_impl< numeric::decimal32 >
 
struct  type_to_scalar_type_impl< numeric::decimal64 >
 
struct  type_to_scalar_type_impl< std::string >
 
struct  window_bounds
 Abstraction for window boundary sizes. More...
 

Typedefs

using char_utf8 = uint32_t
 UTF-8 characters are 1-4 bytes.
 
using size_type = int32_t
 
using bitmask_type = uint32_t
 
using valid_type = uint8_t
 
template<typename... >
using void_t = void
 
template<typename L , typename R >
using less_comparable = decltype(std::declval< L >()< std::declval< R >())
 
template<typename L , typename R >
using greater_comparable = decltype(std::declval< L >() > std::declval< R >())
 
template<typename L , typename R >
using equality_comparable = decltype(std::declval< L >()==std::declval< R >())
 
template<typename T >
using is_timestamp_t = cuda::std::disjunction< std::is_same< cudf::timestamp_D, T >, std::is_same< cudf::timestamp_s, T >, std::is_same< cudf::timestamp_ms, T >, std::is_same< cudf::timestamp_us, T >, std::is_same< cudf::timestamp_ns, T > >
 
template<typename T >
using is_duration_t = cuda::std::disjunction< std::is_same< cudf::duration_D, T >, std::is_same< cudf::duration_s, T >, std::is_same< cudf::duration_ms, T >, std::is_same< cudf::duration_us, T >, std::is_same< cudf::duration_ns, T > >
 
template<cudf::type_id Id>
using id_to_type = typename id_to_type_impl< Id >::type
 Maps a cudf::type_id to it's corresponding concrete C++ type. More...
 
template<typename T >
using device_storage_type_t = std::conditional_t< std::is_same< numeric::decimal32, T >::value, int32_t, std::conditional_t< std::is_same< numeric::decimal64, T >::value, int64_t, T > >
 "Returns" the corresponding type that is stored on the device when using cudf::column More...
 
template<typename T >
using scalar_type_t = typename type_to_scalar_type_impl< T >::ScalarType
 Maps a C++ type to the scalar type required to hold its value. More...
 
template<typename T >
using scalar_device_type_t = typename type_to_scalar_type_impl< T >::ScalarDeviceType
 
using dictionary32 = dictionary_wrapper< int32_t >
 
using duration_D = cuda::std::chrono::duration< int32_t, cuda::std::chrono::days::period >
 Type alias representing an int32_t duration of days.
 
using duration_s = cuda::std::chrono::duration< int64_t, cuda::std::chrono::seconds::period >
 Type alias representing an int64_t duration of seconds.
 
using duration_ms = cuda::std::chrono::duration< int64_t, cuda::std::chrono::milliseconds::period >
 Type alias representing an int64_t duration of milliseconds.
 
using duration_us = cuda::std::chrono::duration< int64_t, cuda::std::chrono::microseconds::period >
 Type alias representing an int64_t duration of microseconds.
 
using duration_ns = cuda::std::chrono::duration< int64_t, cuda::std::chrono::nanoseconds::period >
 Type alias representing an int64_t duration of nanoseconds.
 
using timestamp_D = detail::timestamp< cuda::std::chrono::duration< int32_t, cuda::std::ratio< 86400 > >>
 Type alias representing an int32_t duration of days since the unix epoch.
 
using timestamp_s = detail::timestamp< cuda::std::chrono::duration< int64_t, cuda::std::ratio< 1 > >>
 Type alias representing an int64_t duration of seconds since the unix epoch.
 
using timestamp_ms = detail::timestamp< cuda::std::chrono::duration< int64_t, cuda::std::milli > >
 Type alias representing an int64_t duration of milliseconds since the unix epoch.
 
using timestamp_us = detail::timestamp< cuda::std::chrono::duration< int64_t, cuda::std::micro > >
 Type alias representing an int64_t duration of microseconds since the unix epoch.
 
using timestamp_ns = detail::timestamp< cuda::std::chrono::duration< int64_t, cuda::std::nano > >
 Type alias representing an int64_t duration of nanoseconds since the unix epoch.
 

Enumerations

enum  udf_type : bool { CUDA, PTX }
 
enum  binary_operator : int32_t {
  binary_operator::ADD, binary_operator::SUB, binary_operator::MUL, binary_operator::DIV,
  binary_operator::TRUE_DIV, binary_operator::FLOOR_DIV, binary_operator::MOD, binary_operator::PYMOD,
  binary_operator::POW, binary_operator::EQUAL, binary_operator::NOT_EQUAL, binary_operator::LESS,
  binary_operator::GREATER, binary_operator::LESS_EQUAL, binary_operator::GREATER_EQUAL, binary_operator::BITWISE_AND,
  binary_operator::BITWISE_OR, binary_operator::BITWISE_XOR, binary_operator::LOGICAL_AND, binary_operator::LOGICAL_OR,
  binary_operator::COALESCE, binary_operator::GENERIC_BINARY, binary_operator::SHIFT_LEFT, binary_operator::SHIFT_RIGHT,
  binary_operator::SHIFT_RIGHT_UNSIGNED, binary_operator::LOG_BASE, binary_operator::ATAN2, binary_operator::PMOD,
  binary_operator::NULL_EQUALS, binary_operator::NULL_MAX, binary_operator::NULL_MIN, binary_operator::INVALID_BINARY
}
 Types of binary operations that can be performed on data. More...
 
enum  out_of_bounds_policy : bool { NULLIFY, out_of_bounds_policy::DONT_CHECK }
 Policy to account for possible out-of-bounds indices. More...
 
enum  mask_allocation_policy { mask_allocation_policy::NEVER, mask_allocation_policy::RETAIN, mask_allocation_policy::ALWAYS }
 Indicates when to allocate a mask, based on an existing mask. More...
 
enum  sample_with_replacement : bool { FALSE, TRUE }
 Indicates whether a row can be sampled more than once.
 
enum  scan_type : bool { INCLUSIVE, EXCLUSIVE }
 Enum to describe scan operation type.
 
enum  replace_policy : bool { PRECEDING, FOLLOWING }
 Policy to specify the position of replacement values relative to null rows. More...
 
enum  flip_endianness : bool { NO, YES }
 Configures whether byte casting flips endianness.
 
enum  rounding_method : int32_t { HALF_UP, HALF_EVEN }
 Different rounding methods for cudf::round More...
 
enum  rank_method {
  rank_method::FIRST, rank_method::AVERAGE, rank_method::MIN, rank_method::MAX,
  rank_method::DENSE
}
 Tie-breaker method to use for ranking the column. More...
 
enum  duplicate_keep_option { duplicate_keep_option::KEEP_FIRST = 0, duplicate_keep_option::KEEP_LAST, duplicate_keep_option::KEEP_NONE }
 Choices for drop_duplicates API for retainment of duplicate rows. More...
 
enum  weak_ordering { weak_ordering::LESS, weak_ordering::EQUIVALENT, weak_ordering::GREATER }
 Result type of the element_relational_comparator function object. More...
 
enum  order : bool { order::ASCENDING, order::DESCENDING }
 Indicates the order in which elements should be sorted. More...
 
enum  null_policy : bool { null_policy::EXCLUDE, null_policy::INCLUDE }
 Enum to specify whether to include nulls or exclude nulls. More...
 
enum  nan_policy : bool { nan_policy::NAN_IS_NULL, nan_policy::NAN_IS_VALID }
 Enum to treat NaN floating point value as null or non-null element. More...
 
enum  null_equality : bool { null_equality::EQUAL, null_equality::UNEQUAL }
 
enum  null_order : bool { null_order::AFTER, null_order::BEFORE }
 Indicates how null values compare against all other values. More...
 
enum  sorted : bool { NO, YES }
 Indicates whether a collection of values is known to be sorted.
 
enum  mask_state : int32_t { mask_state::UNALLOCATED, mask_state::UNINITIALIZED, mask_state::ALL_VALID, mask_state::ALL_NULL }
 Controls the allocation/initialization of a null mask. More...
 
enum  interpolation : int32_t {
  interpolation::LINEAR, interpolation::LOWER, interpolation::HIGHER, interpolation::MIDPOINT,
  interpolation::NEAREST
}
 Interpolation method to use when the desired quantile lies between two data points i and j. More...
 
enum  type_id : int32_t {
  type_id::EMPTY, type_id::INT8, type_id::INT16, type_id::INT32,
  type_id::INT64, type_id::UINT8, type_id::UINT16, type_id::UINT32,
  type_id::UINT64, type_id::FLOAT32, type_id::FLOAT64, type_id::BOOL8,
  type_id::TIMESTAMP_DAYS, type_id::TIMESTAMP_SECONDS, type_id::TIMESTAMP_MILLISECONDS, type_id::TIMESTAMP_MICROSECONDS,
  type_id::TIMESTAMP_NANOSECONDS, type_id::DURATION_DAYS, type_id::DURATION_SECONDS, type_id::DURATION_MILLISECONDS,
  type_id::DURATION_MICROSECONDS, type_id::DURATION_NANOSECONDS, type_id::DICTIONARY32, type_id::STRING,
  type_id::LIST, type_id::DECIMAL32, type_id::DECIMAL64, type_id::STRUCT,
  type_id::NUM_TYPE_IDS
}
 Identifies a column's logical element type. More...
 
enum  hash_id {
  hash_id::HASH_IDENTITY = 0, hash_id::HASH_MURMUR3, hash_id::HASH_MD5, hash_id::HASH_SERIAL_MURMUR3,
  hash_id::HASH_SPARK_MURMUR3
}
 Identifies the hash function to be used. More...
 
enum  unary_operator : int32_t {
  SIN, COS, TAN, ARCSIN,
  ARCCOS, ARCTAN, SINH, COSH,
  TANH, ARCSINH, ARCCOSH, ARCTANH,
  EXP, LOG, SQRT, CBRT,
  CEIL, FLOOR, ABS, RINT,
  BIT_INVERT, NOT
}
 

Functions

std::unique_ptr< aggregationmake_sum_aggregation ()
 Factory to create a SUM aggregation.
 
std::unique_ptr< aggregationmake_product_aggregation ()
 Factory to create a PRODUCT aggregation.
 
std::unique_ptr< aggregationmake_min_aggregation ()
 Factory to create a MIN aggregation.
 
std::unique_ptr< aggregationmake_max_aggregation ()
 Factory to create a MAX aggregation.
 
std::unique_ptr< aggregationmake_count_aggregation (null_policy null_handling=null_policy::EXCLUDE)
 Factory to create a COUNT aggregation. More...
 
std::unique_ptr< aggregationmake_any_aggregation ()
 Factory to create a ANY aggregation.
 
std::unique_ptr< aggregationmake_all_aggregation ()
 Factory to create a ALL aggregation.
 
std::unique_ptr< aggregationmake_sum_of_squares_aggregation ()
 Factory to create a SUM_OF_SQUARES aggregation.
 
std::unique_ptr< aggregationmake_mean_aggregation ()
 Factory to create a MEAN aggregation.
 
std::unique_ptr< aggregationmake_variance_aggregation (size_type ddof=1)
 Factory to create a VARIANCE aggregation. More...
 
std::unique_ptr< aggregationmake_std_aggregation (size_type ddof=1)
 Factory to create a STD aggregation. More...
 
std::unique_ptr< aggregationmake_median_aggregation ()
 Factory to create a MEDIAN aggregation.
 
std::unique_ptr< aggregationmake_quantile_aggregation (std::vector< double > const &q, interpolation i=interpolation::LINEAR)
 Factory to create a QUANTILE aggregation. More...
 
std::unique_ptr< aggregationmake_argmax_aggregation ()
 Factory to create an argmax aggregation. More...
 
std::unique_ptr< aggregationmake_argmin_aggregation ()
 Factory to create an argmin aggregation. More...
 
std::unique_ptr< aggregationmake_nunique_aggregation (null_policy null_handling=null_policy::EXCLUDE)
 Factory to create a nunique aggregation. More...
 
std::unique_ptr< aggregationmake_nth_element_aggregation (size_type n, null_policy null_handling=null_policy::INCLUDE)
 Factory to create a nth_element aggregation. More...
 
std::unique_ptr< aggregationmake_row_number_aggregation ()
 Factory to create a ROW_NUMBER aggregation.
 
std::unique_ptr< aggregationmake_collect_aggregation ()
 Factory to create a COLLECT_NUMBER aggregation.
 
std::unique_ptr< aggregationmake_lag_aggregation (size_type offset)
 Factory to create a LAG aggregation.
 
std::unique_ptr< aggregationmake_lead_aggregation (size_type offset)
 Factory to create a LEAD aggregation.
 
std::unique_ptr< aggregationmake_udf_aggregation (udf_type type, std::string const &user_defined_aggregator, data_type output_type)
 Factory to create an aggregation base on UDF for PTX or CUDA. More...
 
std::unique_ptr< columnbinary_operation (scalar const &lhs, column_view const &rhs, binary_operator op, data_type output_type, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Performs a binary operation between a scalar and a column. More...
 
std::unique_ptr< columnbinary_operation (column_view const &lhs, scalar const &rhs, binary_operator op, data_type output_type, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Performs a binary operation between a column and a scalar. More...
 
std::unique_ptr< columnbinary_operation (column_view const &lhs, column_view const &rhs, binary_operator op, data_type output_type, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Performs a binary operation between two columns. More...
 
std::unique_ptr< columnbinary_operation (column_view const &lhs, column_view const &rhs, std::string const &ptx, data_type output_type, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Performs a binary operation between two columns using a user-defined PTX function. More...
 
template<>
__device__ numeric::decimal32 const column_device_view::element< numeric::decimal32 > (size_type element_index) const noexcept
 Returns a numeric::decimal32 element at the specified index for a fixed_point column. More...
 
template<>
__device__ numeric::decimal64 const column_device_view::element< numeric::decimal64 > (size_type element_index) const noexcept
 Returns a numeric::decimal64 element at the specified index for a fixed_point column. More...
 
std::unique_ptr< columnmake_empty_column (data_type type)
 Creates an empty column of the specified type. More...
 
std::unique_ptr< columnmake_numeric_column (data_type type, size_type size, mask_state state=mask_state::UNALLOCATED, rmm::cuda_stream_view stream=rmm::cuda_stream_default, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Construct column with sufficient uninitialized storage to hold size elements of the specified numeric data_type with an optional null mask. More...
 
template<typename B >
std::unique_ptr< columnmake_numeric_column (data_type type, size_type size, B &&null_mask, size_type null_count=cudf::UNKNOWN_NULL_COUNT, rmm::cuda_stream_view stream=rmm::cuda_stream_default, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Construct column with sufficient uninitialized storage to hold size elements of the specified numeric data_type with a null mask. More...
 
std::unique_ptr< columnmake_fixed_point_column (data_type type, size_type size, mask_state state=mask_state::UNALLOCATED, rmm::cuda_stream_view stream=rmm::cuda_stream_default, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Construct column with sufficient uninitialized storage to hold size elements of the specified fixed_point data_type with an optional null mask. More...
 
template<typename B >
std::unique_ptr< columnmake_fixed_point_column (data_type type, size_type size, B &&null_mask, size_type null_count=cudf::UNKNOWN_NULL_COUNT, rmm::cuda_stream_view stream=rmm::cuda_stream_default, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Construct column with sufficient uninitialized storage to hold size elements of the specified fixed_point data_type with a null mask. More...
 
std::unique_ptr< columnmake_timestamp_column (data_type type, size_type size, mask_state state=mask_state::UNALLOCATED, rmm::cuda_stream_view stream=rmm::cuda_stream_default, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Construct column with sufficient uninitialized storage to hold size elements of the specified timestamp data_type with an optional null mask. More...
 
template<typename B >
std::unique_ptr< columnmake_timestamp_column (data_type type, size_type size, B &&null_mask, size_type null_count=cudf::UNKNOWN_NULL_COUNT, rmm::cuda_stream_view stream=rmm::cuda_stream_default, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Construct column with sufficient uninitialized storage to hold size elements of the specified timestamp data_type with a null mask. More...
 
std::unique_ptr< columnmake_duration_column (data_type type, size_type size, mask_state state=mask_state::UNALLOCATED, rmm::cuda_stream_view stream=rmm::cuda_stream_default, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Construct column with sufficient uninitialized storage to hold size elements of the specified duration data_type with an optional null mask. More...
 
template<typename B >
std::unique_ptr< columnmake_duration_column (data_type type, size_type size, B &&null_mask, size_type null_count=cudf::UNKNOWN_NULL_COUNT, rmm::cuda_stream_view stream=rmm::cuda_stream_default, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Construct column with sufficient uninitialized storage to hold size elements of the specified duration data_type with a null mask. More...
 
std::unique_ptr< columnmake_fixed_width_column (data_type type, size_type size, mask_state state=mask_state::UNALLOCATED, rmm::cuda_stream_view stream=rmm::cuda_stream_default, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Construct column with sufficient uninitialized storage to hold size elements of the specified fixed width data_type with an optional null mask. More...
 
template<typename B >
std::unique_ptr< columnmake_fixed_width_column (data_type type, size_type size, B &&null_mask, size_type null_count=cudf::UNKNOWN_NULL_COUNT, rmm::cuda_stream_view stream=rmm::cuda_stream_default, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Construct column with sufficient uninitialized storage to hold size elements of the specified fixed width data_type with a null mask. More...
 
std::unique_ptr< columnmake_strings_column (const rmm::device_vector< thrust::pair< const char *, size_type >> &strings, rmm::cuda_stream_view stream=rmm::cuda_stream_default, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Construct STRING type column given a device vector of pointer/size pairs. The total number of char bytes must not exceed the maximum size of size_type. The string characters are expected to be UTF-8 encoded sequence of char bytes. Use the strings_column_view class to perform strings operations on this type of column. More...
 
std::unique_ptr< columnmake_strings_column (const rmm::device_vector< string_view > &string_views, const string_view null_placeholder, rmm::cuda_stream_view stream=rmm::cuda_stream_default, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Construct STRING type column given a device vector of string_view. The total number of char bytes must not exceed the maximum size of size_type. The string characters are expected to be UTF-8 encoded sequence of char bytes. Use the strings_column_view class to perform strings operations on this type of column. More...
 
std::unique_ptr< columnmake_strings_column (const rmm::device_vector< char > &strings, const rmm::device_vector< size_type > &offsets, const rmm::device_vector< bitmask_type > &null_mask={}, size_type null_count=cudf::UNKNOWN_NULL_COUNT, rmm::cuda_stream_view stream=rmm::cuda_stream_default, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Construct STRING type column given a device vector of chars encoded as UTF-8, a device vector of byte offsets identifying individual strings within the char vector, and an optional null bitmask. More...
 
std::unique_ptr< columnmake_strings_column (const std::vector< char > &strings, const std::vector< size_type > &offsets, const std::vector< bitmask_type > &null_mask={}, size_type null_count=cudf::UNKNOWN_NULL_COUNT, rmm::cuda_stream_view stream=rmm::cuda_stream_default, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Construct STRING type column given a host vector of chars encoded as UTF-8, a host vector of byte offsets identifying individual strings within the char vector, and an optional null bitmask. More...
 
std::unique_ptr< columnmake_strings_column (size_type num_strings, std::unique_ptr< column > offsets_column, std::unique_ptr< column > chars_column, size_type null_count, rmm::device_buffer &&null_mask, rmm::cuda_stream_view stream=rmm::cuda_stream_default, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Constructs a STRING type column given offsets column, chars columns, and null mask and null count. The columns and mask are moved into the resulting strings column. More...
 
std::unique_ptr< cudf::columnmake_lists_column (size_type num_lists, std::unique_ptr< column > offsets_column, std::unique_ptr< column > child_column, size_type null_count, rmm::device_buffer &&null_mask, rmm::cuda_stream_view stream=rmm::cuda_stream_default, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Constructs a LIST type column given offsets column, child column, and null mask and null count. More...
 
std::unique_ptr< cudf::columnmake_structs_column (size_type num_rows, std::vector< std::unique_ptr< column >> &&child_columns, size_type null_count, rmm::device_buffer &&null_mask, rmm::cuda_stream_view stream=rmm::cuda_stream_default, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Constructs a STRUCT column using specified child columns as members. More...
 
std::unique_ptr< columnmake_column_from_scalar (scalar const &s, size_type size, rmm::cuda_stream_view stream=rmm::cuda_stream_default, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Return a column with size elements that are all equal to the given scalar. More...
 
std::unique_ptr< columnmake_dictionary_from_scalar (scalar const &s, size_type size, rmm::cuda_stream_view stream=rmm::cuda_stream_default, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Return a dictionary column with size elements that are all equal to the given scalar. More...
 
size_type count_descendants (column_view parent)
 Counts the number of descendants of the specified parent. More...
 
column_view logical_cast (column_view const &input, data_type type)
 Zero-copy cast between types with the same underlying representation. More...
 
mutable_column_view logical_cast (mutable_column_view const &input, data_type type)
 Zero-copy cast between types with the same underlying representation. More...
 
rmm::device_buffer concatenate_masks (std::vector< column_view > const &views, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Concatenates views[i]'s bitmask from the bits [views[i].offset(), views[i].offset() + views[i].size()) for all elements views[i] in views into a device_buffer More...
 
std::unique_ptr< columnconcatenate (std::vector< column_view > const &columns_to_concat, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Concatenates multiple columns into a single column. More...
 
std::unique_ptr< tableconcatenate (std::vector< table_view > const &tables_to_concat, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Columns of tables_to_concat are concatenated vertically to return a single table_view. More...
 
std::unique_ptr< tablegather (table_view const &source_table, column_view const &gather_map, out_of_bounds_policy bounds_policy=out_of_bounds_policy::DONT_CHECK, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Gathers the specified rows (including null values) of a set of columns. More...
 
std::unique_ptr< tablescatter (table_view const &source, column_view const &scatter_map, table_view const &target, bool check_bounds=false, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Scatters the rows of the source table into a copy of the target table according to a scatter map. More...
 
std::unique_ptr< tablescatter (std::vector< std::reference_wrapper< const scalar >> const &source, column_view const &indices, table_view const &target, bool check_bounds=false, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Scatters a row of scalar values into a copy of the target table according to a scatter map. More...
 
std::unique_ptr< columnempty_like (column_view const &input)
 Initializes and returns an empty column of the same type as the input. More...
 
std::unique_ptr< columnallocate_like (column_view const &input, mask_allocation_policy mask_alloc=mask_allocation_policy::RETAIN, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Creates an uninitialized new column of the same size and type as the input. Supports only fixed-width types. More...
 
std::unique_ptr< columnallocate_like (column_view const &input, size_type size, mask_allocation_policy mask_alloc=mask_allocation_policy::RETAIN, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Creates an uninitialized new column of the specified size and same type as the input. Supports only fixed-width types. More...
 
std::unique_ptr< tableempty_like (table_view const &input_table)
 Creates a table of empty columns with the same types as the input_table More...
 
void copy_range_in_place (column_view const &source, mutable_column_view &target, size_type source_begin, size_type source_end, size_type target_begin)
 Copies a range of elements in-place from one column to another. More...
 
std::unique_ptr< columncopy_range (column_view const &source, column_view const &target, size_type source_begin, size_type source_end, size_type target_begin, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Copies a range of elements out-of-place from one column to another. More...
 
std::unique_ptr< columnshift (column_view const &input, size_type offset, scalar const &fill_value, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Creates a new column by shifting all values by an offset. More...
 
std::vector< column_viewslice (column_view const &input, std::vector< size_type > const &indices)
 Slices a column_view into a set of column_views according to a set of indices. More...
 
std::vector< table_viewslice (table_view const &input, std::vector< size_type > const &indices)
 Slices a table_view into a set of table_views according to a set of indices. More...
 
std::vector< column_viewsplit (column_view const &input, std::vector< size_type > const &splits)
 Splits a column_view into a set of column_views according to a set of indices derived from expected splits. More...
 
std::vector< table_viewsplit (table_view const &input, std::vector< size_type > const &splits)
 Splits a table_view into a set of table_views according to a set of indices derived from expected splits. More...
 
std::vector< packed_tablecontiguous_split (cudf::table_view const &input, std::vector< size_type > const &splits, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Performs a deep-copy split of a table_view into a set of table_views into a single contiguous block of memory. More...
 
packed_columns pack (cudf::table_view const &input, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Deep-copy a table_view into a serialized contiguous memory format. More...
 
packed_columns::metadata pack_metadata (table_view const &table, uint8_t const *contiguous_buffer, size_t buffer_size)
 Produce the metadata used for packing a table stored in a contiguous buffer. More...
 
table_view unpack (packed_columns const &input)
 Deserialize the result of cudf::pack More...
 
table_view unpack (uint8_t const *metadata, uint8_t const *gpu_data)
 Deserialize the result of cudf::pack More...
 
std::unique_ptr< columncopy_if_else (column_view const &lhs, column_view const &rhs, column_view const &boolean_mask, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Returns a new column, where each element is selected from either lhs or rhs based on the value of the corresponding element in boolean_mask. More...
 
std::unique_ptr< columncopy_if_else (scalar const &lhs, column_view const &rhs, column_view const &boolean_mask, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Returns a new column, where each element is selected from either lhs or rhs based on the value of the corresponding element in boolean_mask. More...
 
std::unique_ptr< columncopy_if_else (column_view const &lhs, scalar const &rhs, column_view const &boolean_mask, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Returns a new column, where each element is selected from either lhs or rhs based on the value of the corresponding element in boolean_mask. More...
 
std::unique_ptr< columncopy_if_else (scalar const &lhs, scalar const &rhs, column_view const &boolean_mask, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Returns a new column, where each element is selected from either lhs or rhs based on the value of the corresponding element in boolean_mask. More...
 
std::unique_ptr< tableboolean_mask_scatter (table_view const &input, table_view const &target, column_view const &boolean_mask, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Scatters rows from the input table to rows of the output corresponding to true values in a boolean mask. More...
 
std::unique_ptr< tableboolean_mask_scatter (std::vector< std::reference_wrapper< const scalar >> const &input, table_view const &target, column_view const &boolean_mask, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Scatters scalar values to rows of the output corresponding to true values in a boolean mask. More...
 
std::unique_ptr< scalarget_element (column_view const &input, size_type index, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Get the element at specified index from a column. More...
 
std::unique_ptr< tablesample (table_view const &input, size_type const n, sample_with_replacement replacement=sample_with_replacement::FALSE, int64_t const seed=0, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Gather n samples from given input randomly. More...
 
std::unique_ptr< columnmake_dictionary_column (column_view const &keys_column, column_view const &indices_column, rmm::cuda_stream_view stream=rmm::cuda_stream_default, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Construct a dictionary column by copying the provided keys and indices. More...
 
std::unique_ptr< columnmake_dictionary_column (std::unique_ptr< column > keys_column, std::unique_ptr< column > indices_column, rmm::device_buffer &&null_mask, size_type null_count)
 Construct a dictionary column by taking ownership of the provided keys and indices columns. More...
 
std::unique_ptr< columnmake_dictionary_column (std::unique_ptr< column > keys_column, std::unique_ptr< column > indices_column, rmm::cuda_stream_view stream=rmm::cuda_stream_default, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Construct a dictionary column by taking ownership of the provided keys and indices columns. More...
 
void fill_in_place (mutable_column_view &destination, size_type begin, size_type end, scalar const &value)
 Fills a range of elements in-place in a column with a scalar value. More...
 
std::unique_ptr< columnfill (column_view const &input, size_type begin, size_type end, scalar const &value, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Fills a range of elements in a column out-of-place with a scalar value. More...
 
std::unique_ptr< tablerepeat (table_view const &input_table, column_view const &count, bool check_count=false, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Repeat rows of a Table. More...
 
std::unique_ptr< tablerepeat (table_view const &input_table, size_type count, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Repeat rows of a Table. More...
 
std::unique_ptr< columnsequence (size_type size, scalar const &init, scalar const &step, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Fills a column with a sequence of value specified by an initial value and a step. More...
 
std::unique_ptr< columnsequence (size_type size, scalar const &init, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Fills a column with a sequence of value specified by an initial value and a step of 1. More...
 
std::unique_ptr< columnhash (table_view const &input, hash_id hash_function=hash_id::HASH_MURMUR3, std::vector< uint32_t > const &initial_hash={}, uint32_t seed=0, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Computes the hash value of each row in the input set of columns. More...
 
std::unique_ptr< tablefrom_dlpack (DLManagedTensor const *managed_tensor, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Convert a DLPack DLTensor into a cudf table. More...
 
DLManagedTensor * to_dlpack (table_view const &input, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Convert a cudf table into a DLPack DLTensor. More...
 
std::shared_ptr< arrow::Table > to_arrow (table_view input, std::vector< column_metadata > const &metadata={}, arrow::MemoryPool *ar_mr=arrow::default_memory_pool())
 Create arrow::Table from cudf table input More...
 
std::unique_ptr< tablefrom_arrow (arrow::Table const &input, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Create cudf::table from given arrow Table input. More...
 
std::unique_ptr< cudf::tableinner_join (cudf::table_view const &left, cudf::table_view const &right, std::vector< cudf::size_type > const &left_on, std::vector< cudf::size_type > const &right_on, std::vector< std::pair< cudf::size_type, cudf::size_type >> const &columns_in_common, null_equality compare_nulls=null_equality::EQUAL, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Performs an inner join on the specified columns of two tables (left, right) More...
 
std::unique_ptr< cudf::tableleft_join (cudf::table_view const &left, cudf::table_view const &right, std::vector< cudf::size_type > const &left_on, std::vector< cudf::size_type > const &right_on, std::vector< std::pair< cudf::size_type, cudf::size_type >> const &columns_in_common, null_equality compare_nulls=null_equality::EQUAL, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Performs a left join (also known as left outer join) on the specified columns of two tables (left, right) More...
 
std::unique_ptr< cudf::tablefull_join (cudf::table_view const &left, cudf::table_view const &right, std::vector< cudf::size_type > const &left_on, std::vector< cudf::size_type > const &right_on, std::vector< std::pair< cudf::size_type, cudf::size_type >> const &columns_in_common, null_equality compare_nulls=null_equality::EQUAL, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Performs a full join (also known as full outer join) on the specified columns of two tables (left, right) More...
 
std::unique_ptr< cudf::tableleft_semi_join (cudf::table_view const &left, cudf::table_view const &right, std::vector< cudf::size_type > const &left_on, std::vector< cudf::size_type > const &right_on, std::vector< cudf::size_type > const &return_columns, null_equality compare_nulls=null_equality::EQUAL, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Performs a left semi join on the specified columns of two tables (left, right) More...
 
std::unique_ptr< cudf::tableleft_anti_join (cudf::table_view const &left, cudf::table_view const &right, std::vector< cudf::size_type > const &left_on, std::vector< cudf::size_type > const &right_on, std::vector< cudf::size_type > const &return_columns, null_equality compare_nulls=null_equality::EQUAL, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Performs a left anti join on the specified columns of two tables (left, right) More...
 
std::unique_ptr< cudf::tablecross_join (cudf::table_view const &left, cudf::table_view const &right, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Performs a cross join on two tables (left, right) More...
 
std::unique_ptr< cudf::tablemerge (std::vector< table_view > const &tables_to_merge, std::vector< cudf::size_type > const &key_cols, std::vector< cudf::order > const &column_order, std::vector< cudf::null_order > const &null_precedence={}, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Merge a set of sorted tables. More...
 
size_type state_null_count (mask_state state, size_type size)
 Returns the null count for a null mask of the specified state representing size elements. More...
 
std::size_t bitmask_allocation_size_bytes (size_type number_of_bits, std::size_t padding_boundary=64)
 Computes the required bytes necessary to represent the specified number of bits with a given padding boundary. More...
 
size_type num_bitmask_words (size_type number_of_bits)
 Returns the number of bitmask_type words required to represent the specified number of bits. More...
 
rmm::device_buffer create_null_mask (size_type size, mask_state state, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Creates a device_buffer for use as a null value indicator bitmask of a column. More...
 
void set_null_mask (bitmask_type *bitmask, size_type begin_bit, size_type end_bit, bool valid)
 Sets a pre-allocated bitmask buffer to a given state in the range [begin_bit, end_bit) More...
 
cudf::size_type count_set_bits (bitmask_type const *bitmask, size_type start, size_type stop)
 Given a bitmask, counts the number of set (1) bits in the range [start, stop) More...
 
cudf::size_type count_unset_bits (bitmask_type const *bitmask, size_type start, size_type stop)
 Given a bitmask, counts the number of unset (0) bits in the range [start, stop). More...
 
std::vector< size_type > segmented_count_set_bits (bitmask_type const *bitmask, std::vector< cudf::size_type > const &indices)
 Given a bitmask, counts the number of set (1) bits in every range [indices[2*i], indices[(2*i)+1]) (where 0 <= i < indices.size() / 2). More...
 
std::vector< size_type > segmented_count_unset_bits (bitmask_type const *bitmask, std::vector< cudf::size_type > const &indices)
 Given a bitmask, counts the number of unset (0) bits in every range [indices[2*i], indices[(2*i)+1]) (where 0 <= i < indices.size() / 2). More...
 
rmm::device_buffer copy_bitmask (bitmask_type const *mask, size_type begin_bit, size_type end_bit, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Creates a device_buffer from a slice of bitmask defined by a range of indices [begin_bit, end_bit). More...
 
rmm::device_buffer copy_bitmask (column_view const &view, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Copies view's bitmask from the bits [view.offset(), view.offset() + view.size()) into a device_buffer More...
 
rmm::device_buffer bitmask_and (table_view const &view, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Returns a bitwise AND of the bitmasks of columns of a table. More...
 
std::pair< std::unique_ptr< table >, std::vector< size_type > > partition (table_view const &t, column_view const &partition_map, size_type num_partitions, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Partitions rows of t according to the mapping specified by partition_map. More...
 
std::pair< std::unique_ptr< table >, std::vector< size_type > > hash_partition (table_view const &input, std::vector< size_type > const &columns_to_hash, int num_partitions, hash_id hash_function=hash_id::HASH_MURMUR3, rmm::cuda_stream_view stream=rmm::cuda_stream_default, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Partitions rows from the input table into multiple output tables. More...
 
std::pair< std::unique_ptr< cudf::table >, std::vector< cudf::size_type > > round_robin_partition (table_view const &input, cudf::size_type num_partitions, cudf::size_type start_partition=0, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Round-robin partition. More...
 
std::unique_ptr< columnquantile (column_view const &input, std::vector< double > const &q, interpolation interp=interpolation::LINEAR, column_view const &ordered_indices={}, bool exact=true, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Computes quantiles with interpolation. More...
 
std::unique_ptr< tablequantiles (table_view const &input, std::vector< double > const &q, interpolation interp=interpolation::NEAREST, cudf::sorted is_input_sorted=sorted::NO, std::vector< order > const &column_order={}, std::vector< null_order > const &null_precedence={}, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Returns the rows of the input corresponding to the requested quantiles. More...
 
std::unique_ptr< scalarreduce (column_view const &col, std::unique_ptr< aggregation > const &agg, data_type output_dtype, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Computes the reduction of the values in all rows of a column. More...
 
std::unique_ptr< columnscan (const column_view &input, std::unique_ptr< aggregation > const &agg, scan_type inclusive, null_policy null_handling=null_policy::EXCLUDE, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Computes the scan of a column. More...
 
std::pair< std::unique_ptr< scalar >, std::unique_ptr< scalar > > minmax (column_view const &col, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Determines the minimum and maximum values of a column. More...
 
std::unique_ptr< columnreplace_nulls (column_view const &input, column_view const &replacement, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Replaces all null values in a column with corresponding values of another column. More...
 
std::unique_ptr< columnreplace_nulls (column_view const &input, scalar const &replacement, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Replaces all null values in a column with a scalar. More...
 
std::unique_ptr< columnreplace_nulls (column_view const &input, replace_policy const &replace_policy, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Replaces all null values in a column with the first non-null value that precedes/follows. More...
 
std::unique_ptr< columnreplace_nans (column_view const &input, column_view const &replacement, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Replaces all NaN values in a column with corresponding values from another column. More...
 
std::unique_ptr< columnreplace_nans (column_view const &input, scalar const &replacement, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Replaces all NaN values in a column with a scalar. More...
 
std::unique_ptr< columnfind_and_replace_all (column_view const &input_col, column_view const &values_to_replace, column_view const &replacement_values, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Return a copy of input_col replacing any values_to_replace[i] found with replacement_values[i]. More...
 
std::unique_ptr< columnclamp (column_view const &input, scalar const &lo, scalar const &lo_replace, scalar const &hi, scalar const &hi_replace, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Replaces values less than lo in input with lo_replace, and values greater than hi with hi_replace. More...
 
std::unique_ptr< columnclamp (column_view const &input, scalar const &lo, scalar const &hi, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Replaces values less than lo in input with lo, and values greater than hi with hi. More...
 
std::unique_ptr< columnnormalize_nans_and_zeros (column_view const &input, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Copies from a column of floating-point elements and replaces -NaN and -0.0 with +NaN and +0.0, respectively. More...
 
void normalize_nans_and_zeros (mutable_column_view &in_out)
 Modifies a column of floating-point elements to replace all -NaN and -0.0 with +NaN and +0.0, respectively. More...
 
std::unique_ptr< columninterleave_columns (table_view const &input, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Interleave columns of a table into a single column. More...
 
std::unique_ptr< tabletile (table_view const &input, size_type count, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Repeats the rows from input table count times to form a new table. More...
 
std::unique_ptr< columnbyte_cast (column_view const &input_column, flip_endianness endian_configuration, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Converts a column's elements to lists of bytes. More...
 
std::unique_ptr< tableexplode (table_view const &input_table, size_type explode_column_idx, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Explodes a list column's elements. More...
 
std::unique_ptr< columnrolling_window (column_view const &input, size_type preceding_window, size_type following_window, size_type min_periods, std::unique_ptr< aggregation > const &agg, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Applies a fixed-size rolling window function to the values in a column. More...
 
std::unique_ptr< columnrolling_window (column_view const &input, column_view const &default_outputs, size_type preceding_window, size_type following_window, size_type min_periods, std::unique_ptr< aggregation > const &agg, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 rolling_window( More...
 
std::unique_ptr< columngrouped_rolling_window (table_view const &group_keys, column_view const &input, size_type preceding_window, size_type following_window, size_type min_periods, std::unique_ptr< aggregation > const &aggr, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Applies a grouping-aware, fixed-size rolling window function to the values in a column. More...
 
std::unique_ptr< columngrouped_rolling_window (table_view const &group_keys, column_view const &input, window_bounds preceding_window, window_bounds following_window, size_type min_periods, std::unique_ptr< aggregation > const &aggr, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 grouped_rolling_window( More...
 
std::unique_ptr< columngrouped_rolling_window (table_view const &group_keys, column_view const &input, column_view const &default_outputs, size_type preceding_window, size_type following_window, size_type min_periods, std::unique_ptr< aggregation > const &aggr, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 grouped_rolling_window( More...
 
std::unique_ptr< columngrouped_rolling_window (table_view const &group_keys, column_view const &input, column_view const &default_outputs, window_bounds preceding_window, window_bounds following_window, size_type min_periods, std::unique_ptr< aggregation > const &aggr, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 grouped_rolling_window( More...
 
std::unique_ptr< columngrouped_time_range_rolling_window (table_view const &group_keys, column_view const &timestamp_column, cudf::order const &timestamp_order, column_view const &input, size_type preceding_window_in_days, size_type following_window_in_days, size_type min_periods, std::unique_ptr< aggregation > const &aggr, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Applies a grouping-aware, timestamp-based rolling window function to the values in a column. More...
 
std::unique_ptr< columngrouped_time_range_rolling_window (table_view const &group_keys, column_view const &timestamp_column, cudf::order const &timestamp_order, column_view const &input, window_bounds preceding_window_in_days, window_bounds following_window_in_days, size_type min_periods, std::unique_ptr< aggregation > const &aggr, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 grouped_time_range_rolling_window( More...
 
std::unique_ptr< columnrolling_window (column_view const &input, column_view const &preceding_window, column_view const &following_window, size_type min_periods, std::unique_ptr< aggregation > const &agg, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Applies a variable-size rolling window function to the values in a column. More...
 
std::unique_ptr< columnround (column_view const &input, int32_t decimal_places=0, rounding_method method=rounding_method::HALF_UP, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Rounds all the values in a column to the specified number of decimal places. More...
 
template<typename T >
auto get_scalar_device_view (numeric_scalar< T > &s)
 Get the device view of a numeric_scalar.
 
auto get_scalar_device_view (string_scalar &s)
 Get the device view of a string_scalar.
 
template<typename T >
auto get_scalar_device_view (timestamp_scalar< T > &s)
 Get the device view of a timestamp_scalar.
 
template<typename T >
auto get_scalar_device_view (duration_scalar< T > &s)
 Get the device view of a duration_scalar.
 
template<typename T >
auto get_scalar_device_view (fixed_point_scalar< T > &s)
 Get the device view of a fixed_point_scalar.
 
std::unique_ptr< scalarmake_numeric_scalar (data_type type, rmm::cuda_stream_view stream=rmm::cuda_stream_default, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Construct scalar with uninitialized storage to hold a value of the specified numeric data_type. More...
 
std::unique_ptr< scalarmake_timestamp_scalar (data_type type, rmm::cuda_stream_view stream=rmm::cuda_stream_default, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Construct scalar with uninitialized storage to hold a value of the specified timestamp data_type. More...
 
std::unique_ptr< scalarmake_duration_scalar (data_type type, rmm::cuda_stream_view stream=rmm::cuda_stream_default, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Construct scalar with uninitialized storage to hold a value of the specified duration data_type. More...
 
std::unique_ptr< scalarmake_fixed_width_scalar (data_type type, rmm::cuda_stream_view stream=rmm::cuda_stream_default, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Construct scalar with uninitialized storage to hold a value of the specified fixed-width data_type. More...
 
std::unique_ptr< scalarmake_string_scalar (std::string const &string, rmm::cuda_stream_view stream=rmm::cuda_stream_default, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Construct STRING type scalar given a std::string. The size of the std::string must not exceed the maximum size of size_type. The string characters are expected to be UTF-8 encoded sequence of char bytes. More...
 
std::unique_ptr< scalarmake_default_constructed_scalar (data_type type)
 Constructs default constructed scalar of type type More...
 
template<typename T >
std::unique_ptr< scalarmake_fixed_width_scalar (T value, rmm::cuda_stream_view stream=rmm::cuda_stream_default, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Construct scalar using the given value of fixed width type. More...
 
template<typename T >
std::unique_ptr< scalarmake_fixed_point_scalar (typename T::rep value, numeric::scale_type scale, rmm::cuda_stream_view stream=rmm::cuda_stream_default, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Construct scalar using the given value of fixed_point type. More...
 
std::unique_ptr< columnlower_bound (table_view const &t, table_view const &values, std::vector< order > const &column_order, std::vector< null_order > const &null_precedence, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Find smallest indices in a sorted table where values should be inserted to maintain order. More...
 
std::unique_ptr< columnupper_bound (table_view const &t, table_view const &values, std::vector< order > const &column_order, std::vector< null_order > const &null_precedence, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Find largest indices in a sorted table where values should be inserted to maintain order. More...
 
bool contains (column_view const &col, scalar const &value)
 Find if the value is present in the col More...
 
std::unique_ptr< columncontains (column_view const &haystack, column_view const &needles, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Returns a new column of type bool identifying for each element of haystack column, if that element is contained in needles column. More...
 
std::unique_ptr< columnsorted_order (table_view input, std::vector< order > const &column_order={}, std::vector< null_order > const &null_precedence={}, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Computes the row indices that would produce input in a lexicographical sorted order. More...
 
std::unique_ptr< columnstable_sorted_order (table_view input, std::vector< order > const &column_order={}, std::vector< null_order > const &null_precedence={}, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Computes the row indices that would produce input in a stable lexicographical sorted order. More...
 
bool is_sorted (cudf::table_view const &table, std::vector< order > const &column_order, std::vector< null_order > const &null_precedence)
 Checks whether the rows of a table are sorted in a lexicographical order. More...
 
std::unique_ptr< tablesort (table_view input, std::vector< order > const &column_order={}, std::vector< null_order > const &null_precedence={}, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Performs a lexicographic sort of the rows of a table. More...
 
std::unique_ptr< tablesort_by_key (table_view const &values, table_view const &keys, std::vector< order > const &column_order={}, std::vector< null_order > const &null_precedence={}, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Performs a key-value sort. More...
 
std::unique_ptr< columnrank (column_view const &input, rank_method method, order column_order, null_policy null_handling, null_order null_precedence, bool percentage, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Computes the ranks of input column in sorted order. More...
 
std::unique_ptr< columnsegmented_sorted_order (table_view const &keys, column_view const &segment_offsets, std::vector< order > const &column_order={}, std::vector< null_order > const &null_precedence={}, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Returns sorted order after sorting each segment in the table. More...
 
std::unique_ptr< tablesegmented_sort_by_key (table_view const &values, table_view const &keys, column_view const &segment_offsets, std::vector< order > const &column_order={}, std::vector< null_order > const &null_precedence={}, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Performs a lexicographic segmented sort of a table. More...
 
std::unique_ptr< tabledrop_nulls (table_view const &input, std::vector< size_type > const &keys, cudf::size_type keep_threshold, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Filters a table to remove null elements with threshold count. More...
 
std::unique_ptr< tabledrop_nulls (table_view const &input, std::vector< size_type > const &keys, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Filters a table to remove null elements. More...
 
std::unique_ptr< tabledrop_nans (table_view const &input, std::vector< size_type > const &keys, cudf::size_type keep_threshold, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Filters a table to remove NANs with threshold count. More...
 
std::unique_ptr< tabledrop_nans (table_view const &input, std::vector< size_type > const &keys, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Filters a table to remove NANs. More...
 
std::unique_ptr< tableapply_boolean_mask (table_view const &input, column_view const &boolean_mask, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Filters input using boolean_mask of boolean values as a mask. More...
 
std::unique_ptr< tabledrop_duplicates (table_view const &input, std::vector< size_type > const &keys, duplicate_keep_option keep, null_equality nulls_equal=null_equality::EQUAL, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Create a new table without duplicate rows. More...
 
cudf::size_type distinct_count (column_view const &input, null_policy null_handling, nan_policy nan_handling)
 Count the unique elements in the column_view. More...
 
cudf::size_type distinct_count (table_view const &input, null_equality nulls_equal=null_equality::EQUAL)
 Count the unique rows in a table. More...
 
template<typename Element , std::enable_if_t< std::is_floating_point< Element >::value > * = nullptr>
__device__ weak_ordering relational_compare (Element lhs, Element rhs)
 A specialization for non-floating-point Element type relational comparison to derive the order of the elements with respect to lhs. More...
 
template<typename Element , std::enable_if_t< std::is_floating_point< Element >::value > * = nullptr>
__device__ bool equality_compare (Element lhs, Element rhs)
 A specialization for floating-point Element type to check if lhs is equivalent to rhs. nan == nan. More...
 
template<typename ColumnDeviceView , typename HostTableView >
auto contiguous_copy_column_device_views (HostTableView source_view, rmm::cuda_stream_view stream)
 
bool has_nulls (table_view view)
 
bool have_same_types (table_view const &lhs, table_view const &rhs)
 Checks if two table_views have columns of same types. More...
 
table_view scatter_columns (table_view const &source, std::vector< size_type > const &map, table_view const &target)
 Copy column_views from a table_view into another table_view according to a column indices map. More...
 
std::unique_ptr< columntransform (column_view const &input, std::string const &unary_udf, data_type output_type, bool is_ptx, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Creates a new column by applying a unary function against every element of an input column. More...
 
std::pair< std::unique_ptr< rmm::device_buffer >, size_type > nans_to_nulls (column_view const &input, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Creates a null_mask from input by converting NaN to null and preserving existing null values and also returns new null_count. More...
 
std::pair< std::unique_ptr< rmm::device_buffer >, cudf::size_type > bools_to_mask (column_view const &input, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Creates a bitmask from a column of boolean elements. More...
 
std::pair< std::unique_ptr< cudf::table >, std::unique_ptr< cudf::column > > encode (cudf::table_view const &input, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Encode the rows of the given table as integers. More...
 
std::unique_ptr< columnmask_to_bools (bitmask_type const *bitmask, size_type begin_bit, size_type end_bit, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Creates a boolean column from given bitmask. More...
 
std::pair< std::unique_ptr< column >, table_viewtranspose (table_view const &input, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Transposes a table. More...
 
template<typename T >
size_type distance (T f, T l)
 Similar to std::distance but returns cudf::size_type and performs static_cast More...
 
bool operator== (data_type const &lhs, data_type const &rhs)
 Compares two data_type objects for equality. More...
 
bool operator!= (data_type const &lhs, data_type const &rhs)
 Compares two data_type objects for inequality. More...
 
std::size_t size_of (data_type t)
 Returns the size in bytes of elements of the specified data_type More...
 
std::unique_ptr< cudf::columnunary_operation (cudf::column_view const &input, cudf::unary_operator op, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Performs unary op on all values in column. More...
 
std::unique_ptr< cudf::columnis_null (cudf::column_view const &input, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Creates a column of type_id::BOOL8 elements where for every element in input true indicates the value is null and false indicates the value is valid. More...
 
std::unique_ptr< cudf::columnis_valid (cudf::column_view const &input, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Creates a column of type_id::BOOL8 elements where for every element in input true indicates the value is valid and false indicates the value is null. More...
 
std::unique_ptr< columncast (column_view const &input, data_type out_type, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Casts data from dtype specified in input to dtype specified in output. More...
 
std::unique_ptr< columnis_nan (cudf::column_view const &input, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Creates a column of type_id::BOOL8 elements indicating the presence of NaN values in a column of floating point values. The output element at row i is true if the element in input at row i is NAN, else false More...
 
std::unique_ptr< columnis_not_nan (cudf::column_view const &input, rmm::mr::device_memory_resource *mr=rmm::mr::get_current_device_resource())
 Creates a column of type_id::BOOL8 elements indicating the absence of NaN values in a column of floating point values. The output element at row i is false if the element in input at row i is NAN, else true More...
 
constexpr CUDA_HOST_DEVICE_CALLABLE size_type word_index (size_type bit_index)
 Returns the index of the word containing the specified bit.
 
constexpr CUDA_HOST_DEVICE_CALLABLE size_type intra_word_index (size_type bit_index)
 Returns the position within a word of the specified bit.
 
CUDA_HOST_DEVICE_CALLABLE void set_bit_unsafe (bitmask_type *bitmask, size_type bit_index)
 Sets the specified bit to 1 More...
 
CUDA_HOST_DEVICE_CALLABLE void clear_bit_unsafe (bitmask_type *bitmask, size_type bit_index)
 Sets the specified bit to 0 More...
 
CUDA_HOST_DEVICE_CALLABLE bool bit_is_set (bitmask_type const *bitmask, size_type bit_index)
 Indicates whether the specified bit is set to 1 More...
 
constexpr CUDA_HOST_DEVICE_CALLABLE bitmask_type set_least_significant_bits (size_type n)
 Returns a bitmask word with the n least significant bits set. More...
 
constexpr CUDA_HOST_DEVICE_CALLABLE bitmask_type set_most_significant_bits (size_type n)
 Returns a bitmask word with the n most significant bits set. More...
 
bool is_ptds_enabled ()
 Check if per-thread default stream is enabled. More...
 
template<typename L , typename R >
constexpr bool is_relationally_comparable ()
 Indicates whether objects of types L and R can be relationally compared. More...
 
template<typename L , typename R >
constexpr bool is_equality_comparable ()
 Indicates whether objects of types L and R can be compared for equality. More...
 
template<typename T >
constexpr bool is_numeric ()
 Indicates whether the type T is a numeric type. More...
 
constexpr bool is_numeric (data_type type)
 Indicates whether type is a numeric data_type. More...
 
template<typename T >
constexpr bool is_index_type ()
 Indicates whether the type T is a index type. More...
 
constexpr bool is_index_type (data_type type)
 Indicates whether the type type is a index type. More...
 
template<typename T >
constexpr bool is_unsigned ()
 Indicates whether the type T is a unsigned numeric type. More...
 
constexpr bool is_unsigned (data_type type)
 Indicates whether type is a unsigned numeric data_type. More...
 
template<typename T >
constexpr bool is_floating_point ()
 Indicates whether the type T is a floating point type. More...
 
constexpr bool is_floating_point (data_type type)
 Indicates whether type is a floating point data_type. More...
 
template<typename T >
constexpr bool is_boolean ()
 Indicates whether T is a Boolean type. More...
 
constexpr bool is_boolean (data_type type)
 Indicates whether type is a Boolean data_type. More...
 
template<typename T >
constexpr bool is_timestamp ()
 Indicates whether the type T is a timestamp type. More...
 
constexpr bool is_timestamp (data_type type)
 Indicates whether type is a timestamp data_type. More...
 
template<typename T >
constexpr bool is_fixed_point ()
 Indicates whether the type T is a fixed-point type. More...
 
constexpr bool is_fixed_point (data_type type)
 Indicates whether type is a fixed point data_type. More...
 
template<typename T >
constexpr bool is_duration ()
 Indicates whether the type T is a duration type. More...
 
constexpr bool is_duration (data_type type)
 Indicates whether type is a duration data_type. More...
 
template<typename T >
constexpr bool is_chrono ()
 Indicates whether the type T is a chrono type. More...
 
constexpr bool is_chrono (data_type type)
 Indicates whether type is a chrono data_type. More...
 
template<typename T >
constexpr bool is_dictionary ()
 Indicates whether the type T is a dictionary type. More...
 
constexpr bool is_dictionary (data_type type)
 Indicates whether type is a dictionary data_type. More...
 
template<typename T >
constexpr bool is_fixed_width ()
 Indicates whether elements of type T are fixed-width. More...
 
constexpr bool is_fixed_width (data_type type)
 Indicates whether elements of type are fixed-width. More...
 
template<typename T >
constexpr bool is_compound ()
 Indicates whether the type T is a compound type. More...
 
constexpr bool is_compound (data_type type)
 Indicates whether elements of type are compound. More...
 
template<typename T >
constexpr bool is_nested ()
 Indicates whether T is a nested type. More...
 
constexpr bool is_nested (data_type type)
 Indicates whether type is a nested type. More...
 
 MAP_CASTABLE_TYPES (cudf::timestamp_D, cudf::timestamp_D::duration::rep)
 
 MAP_CASTABLE_TYPES (cudf::timestamp_s, cudf::timestamp_s::duration::rep)
 
 MAP_CASTABLE_TYPES (cudf::timestamp_ms, cudf::timestamp_ms::duration::rep)
 
 MAP_CASTABLE_TYPES (cudf::timestamp_us, cudf::timestamp_us::duration::rep)
 
 MAP_CASTABLE_TYPES (cudf::timestamp_ns, cudf::timestamp_ns::duration::rep)
 
 MAP_CASTABLE_TYPES (cudf::duration_D, cudf::duration_D::rep)
 
 MAP_CASTABLE_TYPES (cudf::duration_s, cudf::duration_s::rep)
 
 MAP_CASTABLE_TYPES (cudf::duration_ms, cudf::duration_ms::rep)
 
 MAP_CASTABLE_TYPES (cudf::duration_us, cudf::duration_us::rep)
 
 MAP_CASTABLE_TYPES (cudf::duration_ns, cudf::duration_ns::rep)
 
 MAP_CASTABLE_TYPES (numeric::decimal32, numeric::decimal32::rep)
 
constexpr bool is_logically_castable (data_type from, data_type to)
 Indicates whether from is logically castable to to. More...
 
template<typename T >
constexpr type_id type_to_id ()
 Maps a C++ type to it's corresponding cudf::type_id More...
 
type_id device_storage_type_id (type_id id)
 Returns the corresponding type_id of type stored on device for a given type_id More...
 
template<typename T >
bool type_id_matches_device_storage_type (type_id id)
 Checks if fixed_point-like types have template type T matching the column's stored type id. More...
 
 CUDF_TYPE_MAPPING (bool, type_id::BOOL8)
 Defines all of the mappings between C++ types and their corresponding cudf::type_id values.
 
 CUDF_TYPE_MAPPING (int8_t, type_id::INT8)
 
 CUDF_TYPE_MAPPING (int16_t, type_id::INT16)
 
 CUDF_TYPE_MAPPING (int32_t, type_id::INT32)
 
 CUDF_TYPE_MAPPING (int64_t, type_id::INT64)
 
 CUDF_TYPE_MAPPING (uint8_t, type_id::UINT8)
 
 CUDF_TYPE_MAPPING (uint16_t, type_id::UINT16)
 
 CUDF_TYPE_MAPPING (uint32_t, type_id::UINT32)
 
 CUDF_TYPE_MAPPING (uint64_t, type_id::UINT64)
 
 CUDF_TYPE_MAPPING (float, type_id::FLOAT32)
 
 CUDF_TYPE_MAPPING (double, type_id::FLOAT64)
 
 CUDF_TYPE_MAPPING (cudf::string_view, type_id::STRING)
 
 CUDF_TYPE_MAPPING (cudf::timestamp_D, type_id::TIMESTAMP_DAYS)
 
 CUDF_TYPE_MAPPING (cudf::timestamp_s, type_id::TIMESTAMP_SECONDS)
 
 CUDF_TYPE_MAPPING (cudf::timestamp_ms, type_id::TIMESTAMP_MILLISECONDS)
 
 CUDF_TYPE_MAPPING (cudf::timestamp_us, type_id::TIMESTAMP_MICROSECONDS)
 
 CUDF_TYPE_MAPPING (cudf::timestamp_ns, type_id::TIMESTAMP_NANOSECONDS)
 
 CUDF_TYPE_MAPPING (cudf::duration_D, type_id::DURATION_DAYS)
 
 CUDF_TYPE_MAPPING (cudf::duration_s, type_id::DURATION_SECONDS)
 
 CUDF_TYPE_MAPPING (cudf::duration_ms, type_id::DURATION_MILLISECONDS)
 
 CUDF_TYPE_MAPPING (cudf::duration_us, type_id::DURATION_MICROSECONDS)
 
 CUDF_TYPE_MAPPING (cudf::duration_ns, type_id::DURATION_NANOSECONDS)
 
 CUDF_TYPE_MAPPING (dictionary32, type_id::DICTIONARY32)
 
 CUDF_TYPE_MAPPING (cudf::list_view, type_id::LIST)
 
 CUDF_TYPE_MAPPING (numeric::decimal32, type_id::DECIMAL32)
 
 CUDF_TYPE_MAPPING (numeric::decimal64, type_id::DECIMAL64)
 
 CUDF_TYPE_MAPPING (cudf::struct_view, type_id::STRUCT)
 
 MAP_NUMERIC_SCALAR (bool)
 
template<template< cudf::type_id > typename IdTypeMap = id_to_type_impl, typename Functor , typename... Ts>
constexpr decltype(auto) CUDA_HOST_DEVICE_CALLABLE type_dispatcher (cudf::data_type dtype, Functor f, Ts &&... args)
 Invokes an operator() template with the type instantiation based on the specified cudf::data_type's id(). More...
 
template<template< cudf::type_id > typename IdTypeMap = id_to_type_impl, typename F , typename... Ts>
constexpr decltype(auto) CUDA_HOST_DEVICE_CALLABLE double_type_dispatcher (cudf::data_type type1, cudf::data_type type2, F &&f, Ts &&... args)
 Dispatches two type template parameters to a callable. More...
 
template<typename Integer >
CUDA_HOST_DEVICE_CALLABLE bool operator== (dictionary_wrapper< Integer > const &lhs, dictionary_wrapper< Integer > const &rhs)
 
template<typename Integer >
CUDA_HOST_DEVICE_CALLABLE bool operator!= (dictionary_wrapper< Integer > const &lhs, dictionary_wrapper< Integer > const &rhs)
 
template<typename Integer >
CUDA_HOST_DEVICE_CALLABLE bool operator<= (dictionary_wrapper< Integer > const &lhs, dictionary_wrapper< Integer > const &rhs)
 
template<typename Integer >
CUDA_HOST_DEVICE_CALLABLE bool operator>= (dictionary_wrapper< Integer > const &lhs, dictionary_wrapper< Integer > const &rhs)
 
template<typename Integer >
constexpr CUDA_HOST_DEVICE_CALLABLE bool operator< (dictionary_wrapper< Integer > const &lhs, dictionary_wrapper< Integer > const &rhs)
 
template<typename Integer >
CUDA_HOST_DEVICE_CALLABLE bool operator> (dictionary_wrapper< Integer > const &lhs, dictionary_wrapper< Integer > const &rhs)
 

Variables

constexpr cudf::size_type UNKNOWN_STRING_LENGTH {-1}
 The string length is initialized to this value as a place-holder. More...
 
constexpr int8_t UNKNOWN_CHAR_WIDTH {-1}
 The char width is initialized to this value as a place-holder. More...
 
constexpr int8_t VARIABLE_CHAR_WIDTH {0}
 This value is assigned to the _char_width member if the string contains characters of different widths.
 

Detailed Description

cuDF interfaces

Provides centralized type lists for use in Google Test type-parameterized tests.

@filename type_lists.hpp

These lists should be used for consistency across tests as well as future-proofing against the addition of any new types in the future.

Enumeration Type Documentation

◆ weak_ordering

enum cudf::weak_ordering
strong

Result type of the element_relational_comparator function object.

Indicates how two elements a and b compare with one and another.

Equivalence is defined as not (a<b) and not (b<a). Elements that are EQUIVALENT may not necessarily be equal.

Enumerator
LESS 

Indicates a is less than (ordered before) b

EQUIVALENT 

Indicates a is ordered neither before nor after b

GREATER 

Indicates a is greater than (ordered after) b

Definition at line 41 of file row_operators.cuh.

Function Documentation

◆ column_device_view::element< numeric::decimal32 >()

template<>
__device__ numeric::decimal32 const cudf::column_device_view::element< numeric::decimal32 > ( size_type  element_index) const
inlinenoexcept

Returns a numeric::decimal32 element at the specified index for a fixed_point column.

If the element at the specified index is NULL, i.e., is_null(element_index) == true, then any attempt to use the result will lead to undefined behavior.

Parameters
element_indexPosition of the desired element
Returns
numeric::decimal32 representing the element at this index

Definition at line 770 of file column_device_view.cuh.

◆ column_device_view::element< numeric::decimal64 >()

template<>
__device__ numeric::decimal64 const cudf::column_device_view::element< numeric::decimal64 > ( size_type  element_index) const
inlinenoexcept

Returns a numeric::decimal64 element at the specified index for a fixed_point column.

If the element at the specified index is NULL, i.e., is_null(element_index) == true, then any attempt to use the result will lead to undefined behavior.

Parameters
element_indexPosition of the desired element
Returns
numeric::decimal64 representing the element at this index

Definition at line 788 of file column_device_view.cuh.

◆ count_descendants()

size_type cudf::count_descendants ( column_view  parent)

Counts the number of descendants of the specified parent.

Parameters
parentThe parent whose descendants will be counted
Returns
size_type The number of descendants of the parent

◆ equality_compare()

template<typename Element , std::enable_if_t< std::is_floating_point< Element >::value > * = nullptr>
__device__ bool cudf::equality_compare ( Element  lhs,
Element  rhs 
)

A specialization for floating-point Element type to check if lhs is equivalent to rhs. nan == nan.

A specialization for non-floating-point Element type to check if lhs is equivalent to rhs.

Parameters
[in]lhsfirst element
[in]rhssecond element
Returns
bool true if lhs == rhs else false.

Definition at line 118 of file row_operators.cuh.

◆ have_same_types()

bool cudf::have_same_types ( table_view const &  lhs,
table_view const &  rhs 
)
inline

Checks if two table_views have columns of same types.

Parameters
lhsleft-side table_view operand
rhsright-side table_view operand
Returns
boolean comparison result

Definition at line 248 of file table_view.hpp.

◆ is_ptds_enabled()

bool cudf::is_ptds_enabled ( )

Check if per-thread default stream is enabled.

Returns
true if PTDS is enabled, false otherwise.

◆ logical_cast() [1/2]

column_view cudf::logical_cast ( column_view const &  input,
data_type  type 
)

Zero-copy cast between types with the same underlying representation.

This is similar to reinterpret_cast or bit_cast in that it gives a view of the same raw bits as a different type. Unlike reinterpret_cast however, this cast is only allowed on types that have the same width and underlying representation. For example, the way timestamp types are laid out in memory is equivalent to an integer representing a duration since a fixed epoch; logically casting to the same integer type (INT32 for days, INT64 for others) results in a raw view of the duration count. However, an INT32 column cannot be logically cast to INT64 as the sizes differ, nor can an INT32 columm be logically cast to a FLOAT32 since what the bits represent differs.

The validity of the conversion can be checked with cudf::is_logically_castable().

Exceptions
cudf::logic_errorif the specified cast is not possible, i.e., is_logically_castable(input.type(), type) is false.
Parameters
inputThe column_view to cast from
typeThe data_type to cast to
Returns
New column_view wrapping the same data as input but cast to type

◆ logical_cast() [2/2]

mutable_column_view cudf::logical_cast ( mutable_column_view const &  input,
data_type  type 
)

Zero-copy cast between types with the same underlying representation.

This is similar to reinterpret_cast or bit_cast in that it gives a view of the same raw bits as a different type. Unlike reinterpret_cast however, this cast is only allowed on types that have the same width and underlying representation. For example, the way timestamp types are laid out in memory is equivalent to an integer representing a duration since a fixed epoch; logically casting to the same integer type (INT32 for days, INT64 for others) results in a raw view of the duration count. However, an INT32 column cannot be logically cast to INT64 as the sizes differ, nor can an INT32 columm be logically cast to a FLOAT32 since what the bits represent differs.

The validity of the conversion can be checked with cudf::is_logically_castable().

Exceptions
cudf::logic_errorif the specified cast is not possible, i.e., is_logically_castable(input.type(), type) is false.
Parameters
inputThe mutable_column_view to cast from
typeThe data_type to cast to
Returns
New mutable_column_view wrapping the same data as input but cast to type

◆ relational_compare()

template<typename Element , std::enable_if_t< std::is_floating_point< Element >::value > * = nullptr>
__device__ weak_ordering cudf::relational_compare ( Element  lhs,
Element  rhs 
)

A specialization for non-floating-point Element type relational comparison to derive the order of the elements with respect to lhs.

Parameters
[in]lhsfirst element
[in]rhssecond element
Returns
weak_ordering Indicates the relationship between the elements in the lhs and rhs columns.

Definition at line 81 of file row_operators.cuh.

◆ scatter_columns()

table_view cudf::scatter_columns ( table_view const &  source,
std::vector< size_type > const &  map,
table_view const &  target 
)

Copy column_views from a table_view into another table_view according to a column indices map.

The output table view, out_table is a copy of the target table_view but with elements updated according to out_table[map[i]] = source[i] where i is [0,source.size())

Parameters
sourceTable of new columns to scatter into the output table view.
mapThe indices where each new_column should be copied into the output.
targetTable to receive the updated column views.
Returns
New table_view.

Variable Documentation

◆ UNKNOWN_CHAR_WIDTH

constexpr int8_t cudf::UNKNOWN_CHAR_WIDTH {-1}
constexpr

The char width is initialized to this value as a place-holder.

The byte-width of the characters in a string is computed on-demand.

Definition at line 44 of file string_view.hpp.

◆ UNKNOWN_STRING_LENGTH

constexpr cudf::size_type cudf::UNKNOWN_STRING_LENGTH {-1}
constexpr

The string length is initialized to this value as a place-holder.

The number of characters in a string computed on-demand.

Definition at line 37 of file string_view.hpp.