[/===========================================================================
 Copyright (c) 2013-2015 Kyle Lutz <kyle.r.lutz@gmail.com>

 Distributed under the Boost Software License, Version 1.0
 See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt
=============================================================================/]

[section:reference Reference]

[section API Overview]

[h3 Core Library]

Header: `<boost/compute/core.hpp>`

* [classref boost::compute::buffer buffer]
* [classref boost::compute::command_queue command_queue]
* [classref boost::compute::context context]
* [classref boost::compute::device device]
* [classref boost::compute::event event]
* [classref boost::compute::kernel kernel]
* [classref boost::compute::memory_object memory_object]
* [classref boost::compute::pipe pipe]
* [classref boost::compute::platform platform]
* [classref boost::compute::program program]
* [classref boost::compute::system system]
* [classref boost::compute::user_event user_event]

[h3 Utilities]

Header: `<boost/compute/utility.hpp>`

* [funcref boost::compute::dim dim()]
* [classref boost::compute::extents extents<N>]
* [classref boost::compute::program_cache program_cache]
* [classref boost::compute::wait_list wait_list]

[h3 Algorithms]

Header: `<boost/compute/algorithm.hpp>`

* [funcref boost::compute::accumulate accumulate()]
* [funcref boost::compute::adjacent_difference adjacent_difference()]
* [funcref boost::compute::adjacent_find adjacent_find()]
* [funcref boost::compute::all_of all_of()]
* [funcref boost::compute::any_of any_of()]
* [funcref boost::compute::binary_search binary_search()]
* [funcref boost::compute::copy copy()]
* [funcref boost::compute::copy_if copy_if()]
* [funcref boost::compute::copy_n copy_n()]
* [funcref boost::compute::count count()]
* [funcref boost::compute::count_if count_if()]
* [funcref boost::compute::equal equal()]
* [funcref boost::compute::equal_range equal_range()]
* [funcref boost::compute::exclusive_scan exclusive_scan()]
* [funcref boost::compute::fill fill()]
* [funcref boost::compute::fill_n fill_n()]
* [funcref boost::compute::find find()]
* [funcref boost::compute::find_end find_end()]
* [funcref boost::compute::find_if find_if()]
* [funcref boost::compute::find_if_not find_if_not()]
* [funcref boost::compute::for_each for_each()]
* [funcref boost::compute::for_each_n for_each_n()]
* [funcref boost::compute::gather gather()]
* [funcref boost::compute::generate generate()]
* [funcref boost::compute::generate_n generate_n()]
* [funcref boost::compute::includes includes()]
* [funcref boost::compute::inclusive_scan inclusive_scan()]
* [funcref boost::compute::inner_product inner_product()]
* [funcref boost::compute::inplace_merge inplace_merge()]
* [funcref boost::compute::iota iota()]
* [funcref boost::compute::is_partitioned is_partitioned()]
* [funcref boost::compute::is_permutation is_permutation()]
* [funcref boost::compute::is_sorted is_sorted()]
* [funcref boost::compute::lower_bound lower_bound()]
* [funcref boost::compute::lexicographical_compare lexicographical_compare()]
* [funcref boost::compute::max_element max_element()]
* [funcref boost::compute::merge merge()]
* [funcref boost::compute::min_element min_element()]
* [funcref boost::compute::minmax_element minmax_element()]
* [funcref boost::compute::mismatch mismatch()]
* [funcref boost::compute::next_permutation next_permutation()]
* [funcref boost::compute::none_of none_of()]
* [funcref boost::compute::nth_element nth_element()]
* [funcref boost::compute::partial_sum partial_sum()]
* [funcref boost::compute::partition partition()]
* [funcref boost::compute::partition_copy partition_copy()]
* [funcref boost::compute::partition_point partition_point()]
* [funcref boost::compute::prev_permutation prev_permutation()]
* [funcref boost::compute::random_shuffle random_shuffle()]
* [funcref boost::compute::reduce reduce()]
* [funcref boost::compute::remove remove()]
* [funcref boost::compute::remove_if remove_if()]
* [funcref boost::compute::replace replace()]
* [funcref boost::compute::replace_copy replace_copy()]
* [funcref boost::compute::reverse reverse()]
* [funcref boost::compute::reverse_copy reverse_copy()]
* [funcref boost::compute::rotate rotate()]
* [funcref boost::compute::rotate_copy rotate_copy()]
* [funcref boost::compute::scatter scatter()]
* [funcref boost::compute::search search()]
* [funcref boost::compute::search_n search_n()]
* [funcref boost::compute::set_difference set_difference()]
* [funcref boost::compute::set_intersection set_intersection()]
* [funcref boost::compute::set_symmetric_difference set_symmetric_difference()]
* [funcref boost::compute::set_union set_union()]
* [funcref boost::compute::sort sort()]
* [funcref boost::compute::sort_by_key sort_by_key()]
* [funcref boost::compute::stable_partition stable_partition()]
* [funcref boost::compute::stable_sort stable_sort()]
* [funcref boost::compute::swap_ranges swap_ranges()]
* [funcref boost::compute::transform transform()]
* [funcref boost::compute::transform_reduce transform_reduce()]
* [funcref boost::compute::unique unique()]
* [funcref boost::compute::unique_copy unique_copy()]
* [funcref boost::compute::upper_bound upper_bound()]

[h3 Async]

Header: `<boost/compute/async.hpp>`

* [classref boost::compute::future future<T>]
* [funcref boost::compute::wait_for_all wait_for_all()]
* [classref boost::compute::wait_guard wait_guard<Waitable>]

[h3 Containers]

Header: `<boost/compute/container.hpp>`

* [classref boost::compute::array array<T, N>]
* [classref boost::compute::basic_string basic_string<CharT>]
* [classref boost::compute::dynamic_bitset dynamic_bitset<>]
* [classref boost::compute::flat_map flat_map<Key, T>]
* [classref boost::compute::flat_set flat_set<T>]
* [classref boost::compute::mapped_view mapped_view<T>]
* [classref boost::compute::stack stack<T>]
* [classref boost::compute::string string]
* [classref boost::compute::valarray valarray<T>]
* [classref boost::compute::vector vector<T>]

[h3 Exceptions]

Header: `<boost/compute/exception.hpp>`

* [classref boost::compute::context_error context_error]
* [classref boost::compute::no_device_found no_device_found]
* [classref boost::compute::opencl_error opencl_error]
* [classref boost::compute::unsupported_extension_error unsupported_extension_error]

[h3 Iterators]

Header: `<boost/compute/iterators.hpp>`

* [classref boost::compute::buffer_iterator buffer_iterator<T>]
* [classref boost::compute::constant_buffer_iterator constant_buffer_iterator<T>]
* [classref boost::compute::constant_iterator constant_iterator<T>]
* [classref boost::compute::counting_iterator counting_iterator<T>]
* [classref boost::compute::discard_iterator discard_iterator]
* [classref boost::compute::function_input_iterator function_input_iterator<Function>]
* [classref boost::compute::permutation_iterator permutation_iterator<ElementIterator, IndexIterator>]
* [classref boost::compute::transform_iterator transform_iterator<InputIterator, UnaryFunction>]
* [classref boost::compute::zip_iterator zip_iterator<IteratorTuple>]

[h3 Images]

Header: `<boost/compute/image.hpp>`

* [classref boost::compute::image1d image1d]
* [classref boost::compute::image2d image2d]
* [classref boost::compute::image3d image3d]
* [classref boost::compute::image_format image_format]
* [classref boost::compute::image_object image_object]
* [classref boost::compute::image_sampler image_sampler]

[h3 Shared Virtual Memory]

* [classref boost::compute::svm_ptr svm_ptr<T>]
* [funcref boost::compute::svm_alloc svm_alloc<T>()]
* [funcref boost::compute::svm_free svm_free<T>()]

[h3 Macros]

* [macroref BOOST_COMPUTE_ADAPT_STRUCT BOOST_COMPUTE_ADAPT_STRUCT()]
* [macroref BOOST_COMPUTE_FUNCTION BOOST_COMPUTE_FUNCTION()]
* [macroref BOOST_COMPUTE_STRINGIZE_SOURCE BOOST_COMPUTE_STRINGIZE_SOURCE()]

[h3 OpenGL Sharing]

Header: `<boost/compute/interop/opengl.hpp>`

* [classref boost::compute::opengl_buffer opengl_buffer]
* [funcref boost::compute::opengl_create_shared_context opengl_create_shared_context()]
* [funcref boost::compute::opengl_enqueue_acquire_buffer opengl_enqueue_acquire_buffer()]
* [funcref boost::compute::opengl_enqueue_acquire_gl_objects opengl_enqueue_acquire_gl_objects()]
* [funcref boost::compute::opengl_enqueue_release_buffer opengl_enqueue_release_buffer()]
* [funcref boost::compute::opengl_enqueue_release_gl_objects opengl_enqueue_acquire_gl_objects()]
* [classref boost::compute::opengl_renderbuffer opengl_renderbuffer]
* [classref boost::compute::opengl_texture opengl_texture]

[h3 Random Number Generators]

Header: `<boost/compute/random.hpp>`

* [classref boost::compute::bernoulli_distribution bernoulli_distribution]
* [classref boost::compute::default_random_engine default_random_engine]
* [classref boost::compute::discrete_distribution discrete_distribution]
* [classref boost::compute::linear_congruential_engine linear_congruential_engine]
* [classref boost::compute::mersenne_twister_engine mersenne_twister_engine]
* [classref boost::compute::normal_distribution normal_distribution]
* [classref boost::compute::uniform_int_distribution uniform_int_distribution]
* [classref boost::compute::uniform_real_distribution uniform_real_distribution]

[h3 Type Traits]

Header: `<boost/compute/type_traits.hpp>`

* [classref boost::compute::is_device_iterator is_device_iterator<Iterator>]
* [classref boost::compute::is_fundamental is_fundamental<T>]
* [classref boost::compute::is_vector_type is_vector_type<T>]
* [classref boost::compute::make_vector_type make_vector_type<T, N>]
* [classref boost::compute::result_of result_of<F(Args...)>]
* [classref boost::compute::scalar_type scalar_type<T>]
* [funcref boost::compute::type_name type_name<T>()]

[endsect] [/ overview]

[xinclude autodoc.xml]

[endsect] [/ reference ]
