Meta-header to include all Boost.Compute algorithm headers.
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> OutputIterator adjacent_difference(InputIterator, InputIterator, OutputIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { 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()); } }
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> 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 PatternIterator, typename TextIterator> TextIterator find_end(PatternIterator, PatternIterator, TextIterator, TextIterator, 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 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> 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> bool is_sorted(InputIterator, InputIterator, 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> InputIterator max_element(InputIterator, InputIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator1, typename InputIterator2, typename OutputIterator> OutputIterator merge(InputIterator1, InputIterator1, InputIterator2, InputIterator2, OutputIterator, command_queue & = system::default_queue()); template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Compare> OutputIterator merge(InputIterator1, InputIterator1, InputIterator2, InputIterator2, OutputIterator, Compare, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator> InputIterator min_element(InputIterator, InputIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename InputIterator> 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()); } }
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 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 PatternIterator, typename TextIterator> TextIterator search(PatternIterator, PatternIterator, TextIterator, TextIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { template<typename TextIterator, typename ValueType> TextIterator search_n(TextIterator, TextIterator, ValueType, size_t, 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 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 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> InputIterator unique(InputIterator, InputIterator, command_queue & = system::default_queue()); } }
namespace boost { namespace compute { 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()); } }
Meta-header to include all Boost.Compute async headers.
namespace boost { namespace compute { template<class... Events> void wait_for_all(Events &&...); } }
namespace boost { namespace compute { class buffer; } }
BOOST_COMPUTE_CLOSURE(return_type, name, arguments, capture, source)
namespace boost { namespace compute { class command_queue; } }
Meta-header to include all Boost.Compute container headers.
namespace boost { namespace compute { template<typename T> class allocator; } }
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; } }
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 pinned_allocator; } }
namespace boost { namespace compute { template<typename T> class stack; } }
namespace boost { namespace compute { typedef basic_string< char_ > string; } }
namespace boost { namespace compute { template<typename T> class valarray; } }
namespace boost { namespace compute { template<typename T, typename Alloc = allocator<T> > class vector; } }
namespace boost { namespace compute { class context; } }
namespace boost { namespace compute { context opengl_create_shared_context(); } }
Meta-header to include all Boost.Compute core headers.
namespace boost { namespace compute { class device; } }
namespace boost { namespace compute { class event; } }
Meta-header to include all Boost.Compute exception headers.
namespace boost { namespace compute { class context_error; } }
namespace boost { namespace compute { class opencl_error; } }
namespace boost { namespace compute { class unsupported_extension_error; } }
BOOST_COMPUTE_FUNCTION(return_type, name, arguments, source)
namespace boost { namespace compute { template<typename Signature> class function; template<typename Signature> function< Signature > make_function_from_source(const std::string &, const std::string &); } }
Meta-header to include all Boost.Compute functional headers.
namespace boost { namespace compute { template<typename T> class field; } }
namespace boost { namespace compute { template<size_t N> struct get; } }
Meta-header to include all Boost.Compute OpenGL interop headers.
namespace boost { namespace compute { void opengl_enqueue_acquire_gl_objects(size_t, const cl_mem *, command_queue &); void opengl_enqueue_release_gl_objects(size_t, const cl_mem *, command_queue &); void opengl_enqueue_acquire_buffer(const opengl_buffer &, command_queue &); void opengl_enqueue_release_buffer(const opengl_buffer &, command_queue &); } }
namespace boost { namespace compute { class opengl_buffer; } }
namespace boost { namespace compute { class opengl_renderbuffer; } }
namespace boost { namespace compute { class opengl_texture; } }
Meta-header to include all Boost.Compute iterator headers.
namespace boost { namespace compute { template<typename T> class buffer_iterator; // Creates a new buffer_iterator forbuffer
atindex
. template<typename T> buffer_iterator< T > make_buffer_iterator(const buffer & buffer, size_t index = 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 & buffer, size_t index = 0); } }
namespace boost { namespace compute { template<typename T> class constant_iterator; // Returns a new constant iterator withvalue
atindex
. template<typename T> constant_iterator< T > make_constant_iterator(const T & value, size_t index = 0); } }
namespace boost { namespace compute { template<typename T> class counting_iterator; template<typename T> counting_iterator< T > make_counting_iterator(const T & init); } }
namespace boost {
namespace compute {
class discard_iterator;
// Returns a new discard iterator with index
.
discard_iterator make_discard_iterator(size_t index = 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 & function, size_t index = 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 e, IndexIterator i); } }
namespace boost { namespace compute { template<typename InputIterator, typename UnaryFunction> class transform_iterator; // Returns a transform iterator foriterator
withtransform
. template<typename InputIterator, typename UnaryFunction> transform_iterator< InputIterator, UnaryFunction > make_transform_iterator(InputIterator iterator, UnaryFunction transform); } }
namespace boost { namespace compute { template<typename IteratorTuple> class zip_iterator; template<typename IteratorTuple> zip_iterator< IteratorTuple > make_zip_iterator(IteratorTuple iterators); } }
namespace boost { namespace compute { class kernel; } }
namespace boost { namespace compute { class memory_object; } }
namespace boost { namespace compute { class platform; } }
namespace boost { namespace compute { class program; } }
Meta-header to include all Boost.Compute random headers.
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 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 RealType = float> class uniform_real_distribution; } }
BOOST_COMPUTE_STRINGIZE_SOURCE(source)
namespace boost { namespace compute { class system; } }
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 Vector> struct scalar_type; } }
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; } }
Meta-header to include all Boost.Compute types headers.
BOOST_COMPUTE_ADAPT_STRUCT(type, name, members)
namespace boost { namespace compute { class user_event; } }
BOOST_COMPUTE_VERSION_MAJOR BOOST_COMPUTE_VERSION_MINOR BOOST_COMPUTE_VERSION_PATCH
namespace boost { namespace compute { template<typename T> class future; class wait_list; } }