copying.hpp

转到此文件的文档。

/*
 * Copyright (c) 2018-2024, NVIDIA CORPORATION.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * https://apache.ac.cn/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#pragma once

#include <cudf/column/column_view.hpp>
#include <cudf/lists/lists_column_view.hpp>
#include <cudf/scalar/scalar.hpp>
#include <cudf/strings/strings_column_view.hpp>
#include <cudf/structs/structs_column_view.hpp>
#include <cudf/table/table.hpp>
#include <cudf/types.hpp>
#include <cudf/utilities/export.hpp>
#include <cudf/utilities/memory_resource.hpp>

#include <memory>
#include <vector>

namespace CUDF_EXPORT cudf {

enum class out_of_bounds_policy : bool {
 NULLIFY,
 DONT_CHECK
};

std::unique_ptr<table> gather(
 table_view const& source_table,
 column_view const& gather_map,
 out_of_bounds_policy bounds_policy = out_of_bounds_policy::DONT_CHECK,
 rmm::cuda_stream_view stream = cudf::get_default_stream(),
 rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());

std::unique_ptr<table> reverse(
 table_view const& source_table,
 rmm::cuda_stream_view stream = cudf::get_default_stream(),
 rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());

std::unique_ptr<column> reverse(
 column_view const& source_column,
 rmm::cuda_stream_view stream = cudf::get_default_stream(),
 rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());

std::unique_ptr<table> scatter(
 table_view const& source,
 column_view const& scatter_map,
 table_view const& target,
 rmm::cuda_stream_view stream = cudf::get_default_stream(),
 rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());

std::unique_ptr<table> scatter(
 std::vector<std::reference_wrapper<scalar const>> const& source,
 column_view const& indices,
 table_view const& target,
 rmm::cuda_stream_view stream = cudf::get_default_stream(),
 rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());

enum class mask_allocation_policy : int32_t {
 NEVER,
 RETAIN,
 ALWAYS
};

std::unique_ptr<column> empty_like(column_view const& input);

std::unique_ptr<column> empty_like(scalar const& input);

std::unique_ptr<column> allocate_like(
 column_view const& input,
 mask_allocation_policy mask_alloc = mask_allocation_policy::RETAIN,
 rmm::cuda_stream_view stream = cudf::get_default_stream(),
 rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());

std::unique_ptr<column> allocate_like(
 column_view const& input,
 size_type size,
 mask_allocation_policy mask_alloc = mask_allocation_policy::RETAIN,
 rmm::cuda_stream_view stream = cudf::get_default_stream(),
 rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());

std::unique_ptr<table> empty_like(table_view const& input_table);

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,
 rmm::cuda_stream_view stream = cudf::get_default_stream());

std::unique_ptr<column> copy_range(
 column_view const& source,
 column_view const& target,
 size_type source_begin,
 size_type source_end,
 size_type target_begin,
 rmm::cuda_stream_view stream = cudf::get_default_stream(),
 rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());

std::unique_ptr<column> shift(
 column_view const& input,
 size_type offset,
 scalar const& fill_value,
 rmm::cuda_stream_view stream = cudf::get_default_stream(),
 rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());

std::vector<column_view> slice(column_view const& input,
 host_span<size_type const> indices,
 rmm::cuda_stream_view stream = cudf::get_default_stream());
std::vector<column_view> slice(column_view const& input,
 std::initializer_list<size_type> indices,
 rmm::cuda_stream_view stream = cudf::get_default_stream());

std::vector<table_view> slice(table_view const& input,
 host_span<size_type const> indices,
 rmm::cuda_stream_view stream = cudf::get_default_stream());
std::vector<table_view> slice(table_view const& input,
 std::initializer_list<size_type> indices,
 rmm::cuda_stream_view stream = cudf::get_default_stream());

std::vector<column_view> split(column_view const& input,
 host_span<size_type const> splits,
 rmm::cuda_stream_view stream = cudf::get_default_stream());
std::vector<column_view> split(column_view const& input,
 std::initializer_list<size_type> splits,
 rmm::cuda_stream_view stream = cudf::get_default_stream());

std::vector<table_view> split(table_view const& input,
 host_span<size_type const> splits,
 rmm::cuda_stream_view stream = cudf::get_default_stream());
std::vector<table_view> split(table_view const& input,
 std::initializer_list<size_type> splits,
 rmm::cuda_stream_view stream = cudf::get_default_stream());

std::unique_ptr<column> copy_if_else(
 column_view const& lhs,
 column_view const& rhs,
 column_view const& boolean_mask,
 rmm::cuda_stream_view stream = cudf::get_default_stream(),
 rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());

std::unique_ptr<column> copy_if_else(
 scalar const& lhs,
 column_view const& rhs,
 column_view const& boolean_mask,
 rmm::cuda_stream_view stream = cudf::get_default_stream(),
 rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());

std::unique_ptr<column> copy_if_else(
 column_view const& lhs,
 scalar const& rhs,
 column_view const& boolean_mask,
 rmm::cuda_stream_view stream = cudf::get_default_stream(),
 rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());

std::unique_ptr<column> copy_if_else(
 scalar const& lhs,
 scalar const& rhs,
 column_view const& boolean_mask,
 rmm::cuda_stream_view stream = cudf::get_default_stream(),
 rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());

std::unique_ptr<table> boolean_mask_scatter(
 table_view const& input,
 table_view const& target,
 column_view const& boolean_mask,
 rmm::cuda_stream_view stream = cudf::get_default_stream(),
 rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());

std::unique_ptr<table> boolean_mask_scatter(
 std::vector<std::reference_wrapper<scalar const>> const& input,
 table_view const& target,
 column_view const& boolean_mask,
 rmm::cuda_stream_view stream = cudf::get_default_stream(),
 rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());

std::unique_ptr<scalar> get_element(
 column_view const& input,
 size_type index,
 rmm::cuda_stream_view stream = cudf::get_default_stream(),
 rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());

enum class sample_with_replacement : bool {
 FALSE,
 TRUE
};

std::unique_ptr<table> sample(
 table_view const& input,
 size_type const n,
 sample_with_replacement replacement = sample_with_replacement::FALSE,
 int64_t const seed = 0,
 rmm::cuda_stream_view stream = cudf::get_default_stream(),
 rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());

bool has_nonempty_nulls(column_view const& input,
 rmm::cuda_stream_view stream = cudf::get_default_stream());

bool may_have_nonempty_nulls(column_view const& input);

std::unique_ptr<column> purge_nonempty_nulls(
 column_view const& input,
 rmm::cuda_stream_view stream = cudf::get_default_stream(),
 rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());

} // namespace CUDF_EXPORT cudf