...one of the most highly
regarded and expertly designed C++ library projects in the
world.
— Herb Sutter and Andrei
Alexandrescu, C++
Coding Standards
Header: <boost/compute/core.hpp>
buffer
command_queue
context
device
event
kernel
memory_object
pipe
platform
program
system
user_event
Header: <boost/compute/utility.hpp>
Header: <boost/compute/algorithm.hpp>
accumulate()
adjacent_difference()
adjacent_find()
all_of()
any_of()
binary_search()
copy()
copy_if()
copy_n()
count()
count_if()
equal()
equal_range()
exclusive_scan()
fill()
fill_n()
find()
find_end()
find_if()
find_if_not()
for_each()
for_each_n()
gather()
generate()
generate_n()
includes()
inclusive_scan()
inner_product()
inplace_merge()
iota()
is_partitioned()
is_permutation()
is_sorted()
lower_bound()
lexicographical_compare()
max_element()
merge()
min_element()
minmax_element()
mismatch()
next_permutation()
none_of()
nth_element()
partial_sum()
partition()
partition_copy()
partition_point()
prev_permutation()
random_shuffle()
reduce()
reduce_by_key()
remove()
remove_if()
replace()
replace_copy()
reverse()
reverse_copy()
rotate()
rotate_copy()
scatter()
search()
search_n()
set_difference()
set_intersection()
set_symmetric_difference()
set_union()
sort()
sort_by_key()
stable_partition()
stable_sort()
swap_ranges()
transform()
transform_reduce()
unique()
unique_copy()
upper_bound()
Header: <boost/compute/async.hpp>
Header: <boost/compute/container.hpp>
Header: <boost/compute/exception.hpp>
Header: <boost/compute/iterators.hpp>
Header: <boost/compute/image.hpp>
svm_ptr<T>
svm_alloc<T>()
svm_free<T>()
BOOST_COMPUTE_ADAPT_STRUCT
BOOST_COMPUTE_FUNCTION
BOOST_COMPUTE_STRINGIZE_SOURCE()
Header: <boost/compute/interop/opengl.hpp>
Header: <boost/compute/random.hpp>
Header: <boost/compute/type_traits.hpp>
namespace boost { namespace compute { template<typename InputIterator, typename T, typename BinaryFunction> T accumulate(InputIterator, InputIterator, T, BinaryFunction, command_queue & = system::default_queue()); template<typename InputIterator, typename T> T accumulate(InputIterator, InputIterator, T, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename OutputIterator, typename BinaryFunction> OutputIterator adjacent_difference(InputIterator, InputIterator, OutputIterator, BinaryFunction, command_queue & = system::default_queue()); template<typename InputIterator, typename OutputIterator> OutputIterator adjacent_difference(InputIterator, InputIterator, OutputIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename Compare> InputIterator adjacent_find(InputIterator, InputIterator, Compare, command_queue & = system::default_queue()); template<typename InputIterator> InputIterator adjacent_find(InputIterator, InputIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename UnaryPredicate> bool all_of(InputIterator, InputIterator, UnaryPredicate, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename UnaryPredicate> bool any_of(InputIterator, InputIterator, UnaryPredicate, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename T> bool binary_search(InputIterator, InputIterator, const T &, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename OutputIterator> OutputIterator copy(InputIterator, InputIterator, OutputIterator, command_queue & = system::default_queue()); template<typename InputIterator, typename OutputIterator> future< OutputIterator > copy_async(InputIterator, InputIterator, OutputIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename OutputIterator, typename Predicate> OutputIterator copy_if(InputIterator, InputIterator, OutputIterator, Predicate, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename Size, typename OutputIterator> OutputIterator copy_n(InputIterator, Size, OutputIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename T> size_t count(InputIterator, InputIterator, const T &, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename Predicate> size_t count_if(InputIterator, InputIterator, Predicate, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator1, typename InputIterator2> bool equal(InputIterator1, InputIterator1, InputIterator2, command_queue & = system::default_queue()); template<typename InputIterator1, typename InputIterator2> bool equal(InputIterator1, InputIterator1, InputIterator2, InputIterator2, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename T> std::pair< InputIterator, InputIterator > equal_range(InputIterator, InputIterator, const T &, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename OutputIterator, typename T, typename BinaryOperator> OutputIterator exclusive_scan(InputIterator, InputIterator, OutputIterator, T, BinaryOperator, command_queue & = system::default_queue()); template<typename InputIterator, typename OutputIterator, typename T> OutputIterator exclusive_scan(InputIterator, InputIterator, OutputIterator, T, command_queue & = system::default_queue()); template<typename InputIterator, typename OutputIterator> OutputIterator exclusive_scan(InputIterator, InputIterator, OutputIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename BufferIterator, typename T> void fill(BufferIterator, BufferIterator, const T &, command_queue & = system::default_queue()); template<typename BufferIterator, typename T> future< void > fill_async(BufferIterator first, BufferIterator last, const T & value, command_queue & queue = system::default_queue()); } }
namespace boost { namespace compute { template<typename BufferIterator, typename Size, typename T> void fill_n(BufferIterator, Size, const T &, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename T> InputIterator find(InputIterator, InputIterator, const T &, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename TextIterator, typename PatternIterator> TextIterator find_end(TextIterator, TextIterator, PatternIterator, PatternIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename UnaryPredicate> InputIterator find_if(InputIterator, InputIterator, UnaryPredicate, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename UnaryPredicate> InputIterator find_if_not(InputIterator, InputIterator, UnaryPredicate, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename UnaryFunction> UnaryFunction for_each(InputIterator, InputIterator, UnaryFunction, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename Size, typename UnaryFunction> UnaryFunction for_each_n(InputIterator, Size, UnaryFunction, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename MapIterator, typename OutputIterator> void gather(MapIterator, MapIterator, InputIterator, OutputIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename OutputIterator, typename Generator> void generate(OutputIterator, OutputIterator, Generator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename OutputIterator, typename Size, typename Generator> void generate_n(OutputIterator, Size, Generator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator1, typename InputIterator2> bool includes(InputIterator1, InputIterator1, InputIterator2, InputIterator2, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename OutputIterator, typename BinaryOperator> OutputIterator inclusive_scan(InputIterator, InputIterator, OutputIterator, BinaryOperator, command_queue & = system::default_queue()); template<typename InputIterator, typename OutputIterator> OutputIterator inclusive_scan(InputIterator, InputIterator, OutputIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator1, typename InputIterator2, typename T> T inner_product(InputIterator1, InputIterator1, InputIterator2, T, command_queue & = system::default_queue()); template<typename InputIterator1, typename InputIterator2, typename T, typename BinaryAccumulateFunction, typename BinaryTransformFunction> T inner_product(InputIterator1, InputIterator1, InputIterator2, T, BinaryAccumulateFunction, BinaryTransformFunction, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename Iterator> void inplace_merge(Iterator, Iterator, Iterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename BufferIterator, typename T> void iota(BufferIterator, BufferIterator, const T &, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename UnaryPredicate> bool is_partitioned(InputIterator, InputIterator, UnaryPredicate, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator1, typename InputIterator2> bool is_permutation(InputIterator1, InputIterator1, InputIterator2, InputIterator2, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename Compare> bool is_sorted(InputIterator, InputIterator, Compare, command_queue & = system::default_queue()); template<typename InputIterator> bool is_sorted(InputIterator, InputIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator1, typename InputIterator2> bool lexicographical_compare(InputIterator1, InputIterator1, InputIterator2, InputIterator2, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename T> InputIterator lower_bound(InputIterator, InputIterator, const T &, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename Compare> InputIterator max_element(InputIterator, InputIterator, Compare, command_queue & = system::default_queue()); template<typename InputIterator> InputIterator max_element(InputIterator, InputIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Compare> OutputIterator merge(InputIterator1, InputIterator1, InputIterator2, InputIterator2, OutputIterator, Compare, command_queue & = system::default_queue()); template<typename InputIterator1, typename InputIterator2, typename OutputIterator> OutputIterator merge(InputIterator1, InputIterator1, InputIterator2, InputIterator2, OutputIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename Compare> InputIterator min_element(InputIterator, InputIterator, Compare, command_queue & = system::default_queue()); template<typename InputIterator> InputIterator min_element(InputIterator, InputIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename Compare> std::pair< InputIterator, InputIterator > minmax_element(InputIterator, InputIterator, Compare, command_queue & = system::default_queue()); template<typename InputIterator, typename Compare> std::pair< InputIterator, InputIterator > minmax_element(InputIterator, InputIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator1, typename InputIterator2> std::pair< InputIterator1, InputIterator2 > mismatch(InputIterator1, InputIterator1, InputIterator2, command_queue & = system::default_queue()); template<typename InputIterator1, typename InputIterator2> std::pair< InputIterator1, InputIterator2 > mismatch(InputIterator1, InputIterator1, InputIterator2, InputIterator2, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator> bool next_permutation(InputIterator, InputIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename UnaryPredicate> bool none_of(InputIterator, InputIterator, UnaryPredicate, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename Iterator, typename Compare> void nth_element(Iterator, Iterator, Iterator, Compare, command_queue & = system::default_queue()); template<typename Iterator> void nth_element(Iterator, Iterator, Iterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename OutputIterator> OutputIterator partial_sum(InputIterator, InputIterator, OutputIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename Iterator, typename UnaryPredicate> Iterator partition(Iterator, Iterator, UnaryPredicate, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename OutputIterator1, typename OutputIterator2, typename UnaryPredicate> std::pair< OutputIterator1, OutputIterator2 > partition_copy(InputIterator, InputIterator, OutputIterator1, OutputIterator2, UnaryPredicate, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename UnaryPredicate> InputIterator partition_point(InputIterator, InputIterator, UnaryPredicate, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator> bool prev_permutation(InputIterator, InputIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename Iterator> void random_shuffle(Iterator, Iterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename OutputIterator, typename BinaryFunction> void reduce(InputIterator, InputIterator, OutputIterator, BinaryFunction, command_queue & = system::default_queue()); template<typename InputIterator, typename OutputIterator> void reduce(InputIterator, InputIterator, OutputIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputKeyIterator, typename InputValueIterator, typename OutputKeyIterator, typename OutputValueIterator, typename BinaryFunction, typename BinaryPredicate> std::pair< OutputKeyIterator, OutputValueIterator > reduce_by_key(InputKeyIterator, InputKeyIterator, InputValueIterator, OutputKeyIterator, OutputValueIterator, BinaryFunction, BinaryPredicate, command_queue & = system::default_queue()); template<typename InputKeyIterator, typename InputValueIterator, typename OutputKeyIterator, typename OutputValueIterator, typename BinaryFunction> std::pair< OutputKeyIterator, OutputValueIterator > reduce_by_key(InputKeyIterator, InputKeyIterator, InputValueIterator, OutputKeyIterator, OutputValueIterator, BinaryFunction, command_queue & = system::default_queue()); template<typename InputKeyIterator, typename InputValueIterator, typename OutputKeyIterator, typename OutputValueIterator> std::pair< OutputKeyIterator, OutputValueIterator > reduce_by_key(InputKeyIterator, InputKeyIterator, InputValueIterator, OutputKeyIterator, OutputValueIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename Iterator, typename T> Iterator remove(Iterator, Iterator, const T &, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename Iterator, typename Predicate> Iterator remove_if(Iterator, Iterator, Predicate, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename Iterator, typename T> void replace(Iterator, Iterator, const T &, const T &, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename OutputIterator, typename T> OutputIterator replace_copy(InputIterator, InputIterator, OutputIterator, const T &, const T &, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename Iterator> void reverse(Iterator, Iterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename OutputIterator> OutputIterator reverse_copy(InputIterator, InputIterator, OutputIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator> void rotate(InputIterator, InputIterator, InputIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename OutputIterator> void rotate_copy(InputIterator, InputIterator, InputIterator, OutputIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename MapIterator, typename OutputIterator> void scatter(InputIterator, InputIterator, MapIterator, OutputIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename MapIterator, typename StencilIterator, typename OutputIterator, typename Predicate> void scatter_if(InputIterator, InputIterator, MapIterator, StencilIterator, OutputIterator, Predicate, command_queue & = system::default_queue()); template<typename InputIterator, typename MapIterator, typename StencilIterator, typename OutputIterator> void scatter_if(InputIterator first, InputIterator last, MapIterator map, StencilIterator stencil, OutputIterator result, command_queue & queue = system::default_queue()); } }
namespace boost { namespace compute { template<typename TextIterator, typename PatternIterator> TextIterator search(TextIterator, TextIterator, PatternIterator, PatternIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename TextIterator, typename ValueType> TextIterator search_n(TextIterator, TextIterator, size_t, ValueType, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator1, typename InputIterator2, typename OutputIterator> OutputIterator set_difference(InputIterator1, InputIterator1, InputIterator2, InputIterator2, OutputIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator1, typename InputIterator2, typename OutputIterator> OutputIterator set_intersection(InputIterator1, InputIterator1, InputIterator2, InputIterator2, OutputIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator1, typename InputIterator2, typename OutputIterator> OutputIterator set_symmetric_difference(InputIterator1, InputIterator1, InputIterator2, InputIterator2, OutputIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator1, typename InputIterator2, typename OutputIterator> OutputIterator set_union(InputIterator1, InputIterator1, InputIterator2, InputIterator2, OutputIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename Iterator, typename Compare> void sort(Iterator, Iterator, Compare, command_queue & = system::default_queue()); template<typename Iterator> void sort(Iterator, Iterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename KeyIterator, typename ValueIterator, typename Compare> void sort_by_key(KeyIterator, KeyIterator, ValueIterator, Compare, command_queue & = system::default_queue()); template<typename KeyIterator, typename ValueIterator> void sort_by_key(KeyIterator, KeyIterator, ValueIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename Iterator, typename UnaryPredicate> Iterator stable_partition(Iterator, Iterator, UnaryPredicate, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename Iterator, typename Compare> void stable_sort(Iterator, Iterator, Compare, command_queue & = system::default_queue()); template<typename Iterator> void stable_sort(Iterator, Iterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename KeyIterator, typename ValueIterator, typename Compare> void stable_sort_by_key(KeyIterator, KeyIterator, ValueIterator, Compare, command_queue & = system::default_queue()); template<typename KeyIterator, typename ValueIterator> void stable_sort_by_key(KeyIterator, KeyIterator, ValueIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename Iterator1, typename Iterator2> Iterator2 swap_ranges(Iterator1, Iterator1, Iterator2, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename OutputIterator, typename UnaryOperator> OutputIterator transform(InputIterator, InputIterator, OutputIterator, UnaryOperator, command_queue & = system::default_queue()); template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename BinaryOperator> OutputIterator transform(InputIterator1, InputIterator1, InputIterator2, OutputIterator, BinaryOperator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename OutputIterator, typename UnaryFunction, typename Predicate> OutputIterator transform_if(InputIterator, InputIterator, OutputIterator, UnaryFunction, Predicate, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename OutputIterator, typename UnaryTransformFunction, typename BinaryReduceFunction> void transform_reduce(InputIterator, InputIterator, OutputIterator, UnaryTransformFunction, BinaryReduceFunction, command_queue & = system::default_queue()); template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename BinaryTransformFunction, typename BinaryReduceFunction> void transform_reduce(InputIterator1, InputIterator1, InputIterator2, OutputIterator, BinaryTransformFunction, BinaryReduceFunction, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename BinaryPredicate> InputIterator unique(InputIterator, InputIterator, BinaryPredicate, command_queue & = system::default_queue()); template<typename InputIterator> InputIterator unique(InputIterator, InputIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename OutputIterator, typename BinaryPredicate> OutputIterator unique_copy(InputIterator, InputIterator, OutputIterator, BinaryPredicate, command_queue & = system::default_queue()); template<typename InputIterator, typename OutputIterator> OutputIterator unique_copy(InputIterator, InputIterator, OutputIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator, typename T> InputIterator upper_bound(InputIterator, InputIterator, const T &, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename T> class buffer_allocator; } }
namespace boost { namespace compute { template<typename T> class pinned_allocator; } }
namespace boost { namespace compute { template<typename T> class future; } }
namespace boost { namespace compute { template<class... Events> void wait_for_all(Events &&...); } }
namespace boost { namespace compute { template<typename Waitable> class wait_guard; } }
namespace boost { namespace compute { template<typename T, std::size_t N> class array; } }
namespace boost { namespace compute { template<typename CharT, typename Traits = std::char_traits<CharT> > class basic_string; template<typename CharT, typename Traits> std::ostream & operator<<(std::ostream & stream, boost::compute::basic_string< CharT, Traits >const & outStr); } }
namespace boost { namespace compute { template<typename Block = ulong_, typename Alloc = buffer_allocator<Block> > class dynamic_bitset; } }
namespace boost { namespace compute { template<typename Key, typename T> class flat_map; } }
namespace boost { namespace compute { template<typename T> class flat_set; } }
namespace boost { namespace compute { template<typename T> class mapped_view; } }
namespace boost { namespace compute { template<typename T> class stack; } }
namespace boost { namespace compute { typedef basic_string< char_ > string; } }
BOOST_COMPUTE_DEFINE_VALARRAY_BINARY_OPERATOR(op, op_name, assert) BOOST_COMPUTE_DEFINE_VALARRAY_BINARY_OPERATOR_ANY(op, op_name) BOOST_COMPUTE_DEFINE_VALARRAY_BINARY_OPERATOR_NO_FP(op, op_name) BOOST_COMPUTE_DEFINE_VALARRAY_COMPARISON_OPERATOR(op, op_name) BOOST_COMPUTE_DEFINE_VALARRAY_LOGICAL_OPERATOR(op, op_name)
namespace boost { namespace compute { template<typename T> class valarray; } }
namespace boost { namespace compute { template<typename T, typename Alloc = buffer_allocator<T> > class vector; } }
namespace boost { namespace compute { class context_error; } }
namespace boost { namespace compute { class no_device_found; } }
namespace boost { namespace compute { class opencl_error; } }
namespace boost { namespace compute { class unsupported_extension_error; } }
namespace boost { namespace compute { template<typename T> struct as; } }
namespace boost { namespace compute { template<typename T> class atomic_add; template<typename T> class atomic_sub; template<typename T> class atomic_xchg; template<typename T> class atomic_inc; template<typename T> class atomic_dec; template<typename T> class atomic_cmpxchg; template<typename T> class atomic_max; template<typename T> class atomic_min; template<typename T> class atomic_and; template<typename T> class atomic_or; template<typename T> class atomic_xor; } }
namespace boost { namespace compute { template<typename T> struct is_placeholder; template<typename F, class... Args> unspecified bind(F, Args...); namespace placeholders { placeholder< 0 > const _1; placeholder< 1 > const _2; } } }
namespace boost { namespace compute { template<typename T> struct convert; } }
namespace boost { namespace compute { template<typename T> class field; } }
namespace boost { namespace compute { template<size_t N> struct get; } }
namespace boost { namespace compute { template<typename T> class identity; } }
namespace boost { namespace compute { template<typename Predicate> class unary_negate; template<typename Predicate> class binary_negate; template<typename T> struct logical_not; template<typename Predicate> unary_negate< Predicate > not1(const Predicate &); template<typename Predicate> binary_negate< Predicate > not2(const Predicate &); } }
namespace boost { namespace compute { template<typename T> class popcount; } }
namespace boost { namespace compute { class image1d; } }
namespace boost { namespace compute { class image2d; } }
namespace boost { namespace compute { class image3d; } }
namespace boost { namespace compute { class image_format; } }
namespace boost { namespace compute { class image_object; } }
namespace boost { namespace compute { class image_sampler; } }
namespace boost { namespace compute { event opengl_enqueue_acquire_gl_objects(size_t, const cl_mem *, command_queue &, const wait_list & = wait_list()); event opengl_enqueue_release_gl_objects(size_t, const cl_mem *, command_queue &, const wait_list & = wait_list()); event opengl_enqueue_acquire_buffer(const opengl_buffer &, command_queue &, const wait_list & = wait_list()); event opengl_enqueue_release_buffer(const opengl_buffer &, command_queue &, const wait_list & = wait_list()); } }
namespace boost { namespace compute { context opengl_create_shared_context(); } }
namespace boost { namespace compute { class opengl_buffer; } }
namespace boost { namespace compute { class opengl_renderbuffer; } }
namespace boost { namespace compute { class opengl_texture; } }
namespace boost { namespace compute { template<typename T> class buffer_iterator; template<typename T> buffer_iterator< T > make_buffer_iterator(const buffer &, size_t = 0); } }
namespace boost { namespace compute { template<typename T> class constant_buffer_iterator; template<typename T> constant_buffer_iterator< T > make_constant_buffer_iterator(const buffer &, size_t = 0); } }
namespace boost { namespace compute { template<typename T> class constant_iterator; template<typename T> constant_iterator< T > make_constant_iterator(const T &, size_t = 0); } }
namespace boost { namespace compute { template<typename T> class counting_iterator; template<typename T> counting_iterator< T > make_counting_iterator(const T &); } }
namespace boost { namespace compute { class discard_iterator; template<> struct is_device_iterator<discard_iterator>; discard_iterator make_discard_iterator(size_t = 0); } }
namespace boost { namespace compute { template<typename Function> class function_input_iterator; template<typename Function> function_input_iterator< Function > make_function_input_iterator(const Function &, size_t = 0); } }
namespace boost { namespace compute { template<typename ElementIterator, typename IndexIterator> class permutation_iterator; template<typename ElementIterator, typename IndexIterator> permutation_iterator< ElementIterator, IndexIterator > make_permutation_iterator(ElementIterator, IndexIterator); } }
namespace boost { namespace compute { template<typename Iterator> class strided_iterator; template<typename Iterator> strided_iterator< Iterator > make_strided_iterator(Iterator, typename std::iterator_traits< Iterator >::difference_type); template<typename Iterator> strided_iterator< Iterator > make_strided_iterator_end(Iterator, Iterator, typename std::iterator_traits< Iterator >::difference_type); } }
namespace boost { namespace compute { template<typename InputIterator, typename UnaryFunction> class transform_iterator; template<typename InputIterator, typename UnaryFunction> transform_iterator< InputIterator, UnaryFunction > make_transform_iterator(InputIterator, UnaryFunction); } }
namespace boost { namespace compute { template<typename IteratorTuple> class zip_iterator; template<typename IteratorTuple> zip_iterator< IteratorTuple > make_zip_iterator(IteratorTuple); } }
namespace boost { namespace compute { template<typename T> class local_buffer; } }
namespace boost { namespace compute { template<typename T> class svm_ptr; } }
namespace boost { namespace compute { template<typename RealType = float> class bernoulli_distribution; } }
namespace boost { namespace compute { typedef mt19937 default_random_engine; } }
namespace boost { namespace compute { template<typename IntType = uint_> class discrete_distribution; } }
namespace boost { namespace compute { template<typename T = uint_> class linear_congruential_engine; } }
namespace boost { namespace compute { template<typename T> class mersenne_twister_engine; typedef mersenne_twister_engine< uint_ > mt19937; } }
namespace boost { namespace compute { template<typename RealType = float> class normal_distribution; } }
namespace boost { namespace compute { template<typename T = uint_> class threefry_engine; } }
namespace boost { namespace compute { template<typename IntType = uint_> class uniform_int_distribution; } }
namespace boost { namespace compute { template<typename RealType = float> class uniform_real_distribution; } }
namespace boost { namespace compute { template<typename Iterator> struct is_device_iterator; } }
namespace boost { namespace compute { template<typename T> struct is_fundamental; } }
namespace boost { namespace compute { template<typename T> struct is_vector_type; } }
namespace boost { namespace compute { template<typename Scalar, size_t Size> struct make_vector_type; } }
namespace boost { namespace compute { template<typename Signature> struct result_of; } }
namespace boost { namespace compute { template<typename Vector> struct scalar_type; } }
namespace boost { namespace compute { template<typename T> std::string type_definition(); } }
BOOST_COMPUTE_TYPE_NAME(type, name)
namespace boost { namespace compute { template<typename T> const char * type_name(); } }
namespace boost { namespace compute { template<typename T> struct vector_size; } }
namespace boost { namespace compute { template<class... Args> extents< sizeof...(Args)> dim(Args...); } }
namespace boost { namespace compute { template<size_t N> class extents; } }
BOOST_COMPUTE_DETAIL_INVOKE_ARG(z, n, unused) BOOST_COMPUTE_DETAIL_INVOKE_ADD_ARG(z, n, unused) BOOST_COMPUTE_DETAIL_DEFINE_INVOKE(z, n, unused)
namespace boost { namespace compute { template<typename Function, class... Args> result_of< Function(Args...)>::type invoke(const Function &, command_queue &, const Args &...); } }
namespace boost { namespace compute { class program_cache; } }
BOOST_COMPUTE_STRINGIZE_SOURCE(source)
namespace boost { namespace compute { class wait_list; } }