Reference

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());
 }
}

Header <boost/compute/algorithm/adjacent_difference.hpp>

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());
 }
}

Header <boost/compute/algorithm/adjacent_find.hpp>

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());
 }
}

Header <boost/compute/algorithm/all_of.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator, typename UnaryPredicate> 
 bool all_of (InputIterator, InputIterator, UnaryPredicate, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/any_of.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator, typename UnaryPredicate> 
 bool any_of (InputIterator, InputIterator, UnaryPredicate, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/binary_search.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator, typename T> 
 bool binary_search (InputIterator, InputIterator, const T &, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/copy.hpp>

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());
 }
}

Header <boost/compute/algorithm/copy_if.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator, typename OutputIterator, 
 typename Predicate> 
 OutputIterator 
 copy_if (InputIterator, InputIterator, OutputIterator, Predicate, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/copy_n.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator, typename Size, typename OutputIterator> 
 OutputIterator 
 copy_n (InputIterator, Size, OutputIterator, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/count.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator, typename T> 
 size_t count (InputIterator, InputIterator, const T &, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/count_if.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator, typename Predicate> 
 size_t count_if (InputIterator, InputIterator, Predicate, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/equal.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator1, typename InputIterator2> 
 bool equal (InputIterator1, InputIterator1, InputIterator2, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/equal_range.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator, typename T> 
 std::pair< InputIterator, InputIterator > 
 equal_range (InputIterator, InputIterator, const T &, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/exclusive_scan.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator, typename OutputIterator> 
 OutputIterator 
 exclusive_scan (InputIterator, InputIterator, OutputIterator, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/fill.hpp>

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());
 }
}

Header <boost/compute/algorithm/fill_n.hpp>

namespace boost {
 namespace compute {
 template<typename BufferIterator, typename Size, typename T> 
 void fill_n (BufferIterator, Size, const T &, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/find.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator, typename T> 
 InputIterator 
 find (InputIterator, InputIterator, const T &, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/find_end.hpp>

namespace boost {
 namespace compute {
 template<typename TextIterator, typename PatternIterator> 
 TextIterator 
 find_end (TextIterator, TextIterator, PatternIterator, PatternIterator, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/find_if.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator, typename UnaryPredicate> 
 InputIterator 
 find_if (InputIterator, InputIterator, UnaryPredicate, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/find_if_not.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator, typename UnaryPredicate> 
 InputIterator 
 find_if_not (InputIterator, InputIterator, UnaryPredicate, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/for_each.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator, typename UnaryFunction> 
 UnaryFunction 
 for_each (InputIterator, InputIterator, UnaryFunction, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/gather.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator, typename MapIterator, 
 typename OutputIterator> 
 void gather (MapIterator, MapIterator, InputIterator, OutputIterator, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/generate.hpp>

namespace boost {
 namespace compute {
 template<typename OutputIterator, typename Generator> 
 void generate (OutputIterator, OutputIterator, Generator, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/generate_n.hpp>

namespace boost {
 namespace compute {
 template<typename OutputIterator, typename Size, typename Generator> 
 void generate_n (OutputIterator, Size, Generator, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/includes.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator1, typename InputIterator2> 
 bool includes (InputIterator1, InputIterator1, InputIterator2, 
 InputIterator2, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/inclusive_scan.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator, typename OutputIterator> 
 OutputIterator 
 inclusive_scan (InputIterator, InputIterator, OutputIterator, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/inner_product.hpp>

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());
 }
}

Header <boost/compute/algorithm/inplace_merge.hpp>

namespace boost {
 namespace compute {
 template<typename Iterator> 
 void inplace_merge (Iterator, Iterator, Iterator, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/iota.hpp>

namespace boost {
 namespace compute {
 template<typename BufferIterator, typename T> 
 void iota (BufferIterator, BufferIterator, const T &, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/is_partitioned.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator, typename UnaryPredicate> 
 bool is_partitioned (InputIterator, InputIterator, UnaryPredicate, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/is_permutation.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator1, typename InputIterator2> 
 bool is_permutation (InputIterator1, InputIterator1, InputIterator2, 
 InputIterator2, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/is_sorted.hpp>

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());
 }
}

Header <boost/compute/algorithm/lexicographical_compare.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator1, typename InputIterator2> 
 bool lexicographical_compare (InputIterator1, InputIterator1, 
 InputIterator2, InputIterator2, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/lower_bound.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator, typename T> 
 InputIterator 
 lower_bound (InputIterator, InputIterator, const T &, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/max_element.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator> 
 InputIterator 
 max_element (InputIterator, InputIterator, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/merge.hpp>

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());
 }
}

Header <boost/compute/algorithm/min_element.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator> 
 InputIterator 
 min_element (InputIterator, InputIterator, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/minmax_element.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator> 
 std::pair< InputIterator, InputIterator > 
 minmax_element (InputIterator, InputIterator, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/mismatch.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator1, typename InputIterator2> 
 std::pair< InputIterator1, InputIterator2 > 
 mismatch (InputIterator1, InputIterator1, InputIterator2, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/next_permutation.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator> 
 bool next_permutation (InputIterator, InputIterator, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/none_of.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator, typename UnaryPredicate> 
 bool none_of (InputIterator, InputIterator, UnaryPredicate, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/nth_element.hpp>

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());
 }
}

Header <boost/compute/algorithm/partial_sum.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator, typename OutputIterator> 
 OutputIterator 
 partial_sum (InputIterator, InputIterator, OutputIterator, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/partition.hpp>

namespace boost {
 namespace compute {
 template<typename Iterator, typename UnaryPredicate> 
 Iterator partition (Iterator, Iterator, UnaryPredicate, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/partition_copy.hpp>

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());
 }
}

Header <boost/compute/algorithm/partition_point.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator, typename UnaryPredicate> 
 InputIterator 
 partition_point (InputIterator, InputIterator, UnaryPredicate, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/prev_permutation.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator> 
 bool prev_permutation (InputIterator, InputIterator, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/random_shuffle.hpp>

namespace boost {
 namespace compute {
 template<typename Iterator> 
 void random_shuffle (Iterator, Iterator, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/reduce.hpp>

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());
 }
}

Header <boost/compute/algorithm/remove.hpp>

namespace boost {
 namespace compute {
 template<typename Iterator, typename T> 
 Iterator remove (Iterator, Iterator, const T &, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/remove_if.hpp>

namespace boost {
 namespace compute {
 template<typename Iterator, typename Predicate> 
 Iterator remove_if (Iterator, Iterator, Predicate, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/replace.hpp>

namespace boost {
 namespace compute {
 template<typename Iterator, typename T> 
 void replace (Iterator, Iterator, const T &, const T &, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/replace_copy.hpp>

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());
 }
}

Header <boost/compute/algorithm/reverse.hpp>

namespace boost {
 namespace compute {
 template<typename Iterator> 
 void reverse (Iterator, Iterator, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/reverse_copy.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator, typename OutputIterator> 
 OutputIterator 
 reverse_copy (InputIterator, InputIterator, OutputIterator, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/rotate.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator> 
 void rotate (InputIterator, InputIterator, InputIterator, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/rotate_copy.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator, typename OutputIterator> 
 void rotate_copy (InputIterator, InputIterator, InputIterator, 
 OutputIterator, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/scatter.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator, typename MapIterator, 
 typename OutputIterator> 
 void scatter (InputIterator, InputIterator, MapIterator, OutputIterator, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/search.hpp>

namespace boost {
 namespace compute {
 template<typename TextIterator, typename PatternIterator> 
 TextIterator 
 search (TextIterator, TextIterator, PatternIterator, PatternIterator, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/search_n.hpp>

namespace boost {
 namespace compute {
 template<typename TextIterator, typename ValueType> 
 TextIterator 
 search_n (TextIterator, TextIterator, size_t, ValueType, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/set_difference.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator1, typename InputIterator2, 
 typename OutputIterator> 
 OutputIterator 
 set_difference (InputIterator1, InputIterator1, InputIterator2, 
 InputIterator2, OutputIterator, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/set_intersection.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator1, typename InputIterator2, 
 typename OutputIterator> 
 OutputIterator 
 set_intersection (InputIterator1, InputIterator1, InputIterator2, 
 InputIterator2, OutputIterator, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/set_symmetric_difference.hpp>

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());
 }
}

Header <boost/compute/algorithm/set_union.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator1, typename InputIterator2, 
 typename OutputIterator> 
 OutputIterator 
 set_union (InputIterator1, InputIterator1, InputIterator2, 
 InputIterator2, OutputIterator, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/sort.hpp>

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());
 }
}

Header <boost/compute/algorithm/sort_by_key.hpp>

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());
 }
}

Header <boost/compute/algorithm/stable_partition.hpp>

namespace boost {
 namespace compute {
 template<typename Iterator, typename UnaryPredicate> 
 Iterator stable_partition (Iterator, Iterator, UnaryPredicate, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/stable_sort.hpp>

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());
 }
}

Header <boost/compute/algorithm/swap_ranges.hpp>

namespace boost {
 namespace compute {
 template<typename Iterator1, typename Iterator2> 
 Iterator2 swap_ranges (Iterator1, Iterator1, Iterator2, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/algorithm/transform.hpp>

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());
 }
}

Header <boost/compute/algorithm/transform_reduce.hpp>

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());
 }
}

Header <boost/compute/algorithm/unique.hpp>

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());
 }
}

Header <boost/compute/algorithm/unique_copy.hpp>

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());
 }
}

Header <boost/compute/algorithm/upper_bound.hpp>

namespace boost {
 namespace compute {
 template<typename InputIterator, typename T> 
 InputIterator 
 upper_bound (InputIterator, InputIterator, const T &, 
 command_queue & = system::default_queue());
 }
}

Header <boost/compute/allocator.hpp>

Meta-header to include all Boost.Compute allocator headers.

Header <boost/compute/allocator/buffer_allocator.hpp>

namespace boost {
 namespace compute {
 template<typename T> class buffer_allocator ;
 }
}

Header <boost/compute/allocator/pinned_allocator.hpp>

namespace boost {
 namespace compute {
 template<typename T> class pinned_allocator ;
 }
}

Header <boost/compute/async.hpp>

Meta-header to include all Boost.Compute async headers.

Header <boost/compute/async/future.hpp>

namespace boost {
 namespace compute {
 template<typename T> class future ;
 }
}

Header <boost/compute/async/wait.hpp>

namespace boost {
 namespace compute {
 template<class... Events> void wait_for_all (Events &&...);
 }
}

Header <boost/compute/buffer.hpp>

namespace boost {
 namespace compute {
 class buffer ;
 }
}

Header <boost/compute/closure.hpp>

BOOST_COMPUTE_CLOSURE(return_type, name, arguments, capture, source)

Header <boost/compute/command_queue.hpp>

namespace boost {
 namespace compute {
 class command_queue ;
 }
}

Header <boost/compute/config.hpp>

BOOST_COMPUTE_CL_CALLBACK
BOOST_COMPUTE_MAX_ARITY

Header <boost/compute/container.hpp>

Meta-header to include all Boost.Compute container headers.

Header <boost/compute/container/array.hpp>

namespace boost {
 namespace compute {
 template<typename T, std::size_t N> class array ;
 }
}

Header <boost/compute/container/basic_string.hpp>

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);
 }
}

Header <boost/compute/container/dynamic_bitset.hpp>

namespace boost {
 namespace compute {
 template<typename Block = ulong_, 
 typename Alloc = buffer_allocator <Block> > 
 class dynamic_bitset ;
 }
}

Header <boost/compute/container/flat_map.hpp>

namespace boost {
 namespace compute {
 template<typename Key, typename T> class flat_map ;
 }
}

Header <boost/compute/container/flat_set.hpp>

namespace boost {
 namespace compute {
 template<typename T> class flat_set ;
 }
}

Header <boost/compute/container/mapped_view.hpp>

namespace boost {
 namespace compute {
 template<typename T> class mapped_view ;
 }
}

Header <boost/compute/container/stack.hpp>

namespace boost {
 namespace compute {
 template<typename T> class stack ;
 }
}

Header <boost/compute/container/string.hpp>

namespace boost {
 namespace compute {
 typedef basic_string < char_ > string;
 }
}

Header <boost/compute/container/valarray.hpp>

namespace boost {
 namespace compute {
 template<typename T> class valarray ;
 }
}

Header <boost/compute/container/vector.hpp>

namespace boost {
 namespace compute {
 template<typename T, typename Alloc = buffer_allocator <T> > class vector ;
 }
}

Header <boost/compute/context.hpp>

namespace boost {
 namespace compute {
 class context ;
 }
}

Header <boost/compute/interop/opengl/context.hpp>

namespace boost {
 namespace compute {
 context opengl_create_shared_context ();
 }
}

Header <boost/compute/core.hpp>

Meta-header to include all Boost.Compute core headers.

Header <boost/compute/device.hpp>

namespace boost {
 namespace compute {
 class device ;
 }
}

Header <boost/compute/event.hpp>

namespace boost {
 namespace compute {
 class event ;
 }
}

Header <boost/compute/exception.hpp>

Meta-header to include all Boost.Compute exception headers.

Header <boost/compute/exception/context_error.hpp>

namespace boost {
 namespace compute {
 class context_error ;
 }
}

Header <boost/compute/exception/opencl_error.hpp>

namespace boost {
 namespace compute {
 class opencl_error ;
 }
}

Header <boost/compute/exception/unsupported_extension_error.hpp>

namespace boost {
 namespace compute {
 class unsupported_extension_error ;
 }
}

Header <boost/compute/function.hpp>

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 &);
 }
}

Header <boost/compute/functional.hpp>

Meta-header to include all Boost.Compute functional headers.

Header <boost/compute/functional/as.hpp>

namespace boost {
 namespace compute {
 template<typename T> struct as ;
 }
}

Header <boost/compute/functional/atomic.hpp>

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 ;
 }
}

Header <boost/compute/functional/bind.hpp>

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 ;
 }
 }
}

Header <boost/compute/functional/common.hpp>

Header <boost/compute/functional/convert.hpp>

namespace boost {
 namespace compute {
 template<typename T> struct convert ;
 }
}

Header <boost/compute/functional/field.hpp>

namespace boost {
 namespace compute {
 template<typename T> class field ;
 }
}

Header <boost/compute/functional/geometry.hpp>

Header <boost/compute/functional/get.hpp>

namespace boost {
 namespace compute {
 template<size_t N> struct get ;
 }
}

Header <boost/compute/functional/hash.hpp>

namespace boost {
 namespace compute {
 template<typename Key> struct hash ;
 }
}

Header <boost/compute/functional/identity.hpp>

namespace boost {
 namespace compute {
 template<typename T> class identity ;
 }
}

Header <boost/compute/functional/integer.hpp>

Header <boost/compute/functional/logical.hpp>

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 &);
 }
}

Header <boost/compute/functional/math.hpp>

Header <boost/compute/functional/operator.hpp>

Header <boost/compute/functional/popcount.hpp>

namespace boost {
 namespace compute {
 template<typename T> class popcount ;
 }
}

Header <boost/compute/functional/relational.hpp>

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

Meta-header to include all Boost.Compute OpenGL interop headers.

Header <boost/compute/interop/opengl/acquire.hpp>

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 ());
 }
}

Header <boost/compute/interop/opengl/opengl_buffer.hpp>

namespace boost {
 namespace compute {
 class opengl_buffer ;
 }
}

Header <boost/compute/interop/opengl/opengl_renderbuffer.hpp>

namespace boost {
 namespace compute {
 class opengl_renderbuffer ;
 }
}

Header <boost/compute/interop/opengl/opengl_texture.hpp>

namespace boost {
 namespace compute {
 class opengl_texture ;
 }
}

Header <boost/compute/iterator.hpp>

Meta-header to include all Boost.Compute iterator headers.

Header <boost/compute/iterator/buffer_iterator.hpp>

namespace boost {
 namespace compute {
 template<typename T> class buffer_iterator ;
 template<typename T> 
 buffer_iterator < T > make_buffer_iterator (const buffer &, size_t = 0);
 }
}

Header <boost/compute/iterator/constant_buffer_iterator.hpp>

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);
 }
}

Header <boost/compute/iterator/constant_iterator.hpp>

namespace boost {
 namespace compute {
 template<typename T> class constant_iterator ;
 template<typename T> 
 constant_iterator < T > make_constant_iterator (const T &, size_t = 0);
 }
}

Header <boost/compute/iterator/counting_iterator.hpp>

namespace boost {
 namespace compute {
 template<typename T> class counting_iterator ;
 template<typename T> 
 counting_iterator < T > make_counting_iterator (const T &);
 }
}

Header <boost/compute/iterator/discard_iterator.hpp>

namespace boost {
 namespace compute {
 class discard_iterator ;
 discard_iterator make_discard_iterator (size_t = 0);
 }
}

Header <boost/compute/iterator/function_input_iterator.hpp>

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);
 }
}

Header <boost/compute/iterator/permutation_iterator.hpp>

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);
 }
}

Header <boost/compute/iterator/transform_iterator.hpp>

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);
 }
}

Header <boost/compute/iterator/zip_iterator.hpp>

namespace boost {
 namespace compute {
 template<typename IteratorTuple> class zip_iterator ;
 template<typename IteratorTuple> 
 zip_iterator < IteratorTuple > make_zip_iterator (IteratorTuple);
 }
}

Header <boost/compute/kernel.hpp>

namespace boost {
 namespace compute {
 class kernel ;
 }
}

Header <boost/compute/memory.hpp>

Meta-header to include all Boost.Compute memory headers.

Header <boost/compute/memory/svm_ptr.hpp>

namespace boost {
 namespace compute {
 template<typename T> class svm_ptr ;
 }
}

Header <boost/compute/memory_object.hpp>

namespace boost {
 namespace compute {
 class memory_object ;
 }
}

Header <boost/compute/pipe.hpp>

namespace boost {
 namespace compute {
 class pipe ;
 }
}

Header <boost/compute/platform.hpp>

namespace boost {
 namespace compute {
 class platform ;
 }
}

Header <boost/compute/program.hpp>

namespace boost {
 namespace compute {
 class program ;
 }
}

Header <boost/compute/random.hpp>

Meta-header to include all Boost.Compute random headers.

Header <boost/compute/random/bernoulli_distribution.hpp>

namespace boost {
 namespace compute {
 template<typename RealType = float> class bernoulli_distribution ;
 }
}

Header <boost/compute/random/default_random_engine.hpp>

namespace boost {
 namespace compute {
 typedef mt19937 default_random_engine;
 }
}

Header <boost/compute/random/discrete_distribution.hpp>

namespace boost {
 namespace compute {
 template<typename IntType = uint_> class discrete_distribution ;
 }
}

Header <boost/compute/random/linear_congruential_engine.hpp>

namespace boost {
 namespace compute {
 template<typename T = uint_> class linear_congruential_engine ;
 }
}

Header <boost/compute/random/mersenne_twister_engine.hpp>

namespace boost {
 namespace compute {
 template<typename T> class mersenne_twister_engine ;
 typedef mersenne_twister_engine < uint_ > mt19937;
 }
}

Header <boost/compute/random/normal_distribution.hpp>

namespace boost {
 namespace compute {
 template<typename RealType = float> class normal_distribution ;
 }
}

Header <boost/compute/random/uniform_int_distribution.hpp>

namespace boost {
 namespace compute {
 template<typename IntType = uint_> class uniform_int_distribution ;
 }
}

Header <boost/compute/random/uniform_real_distribution.hpp>

namespace boost {
 namespace compute {
 template<typename RealType = float> class uniform_real_distribution ;
 }
}

Header <boost/compute/svm.hpp>

namespace boost {
 namespace compute {
 template<typename T> 
 svm_ptr< T > 
 svm_alloc (const context &, size_t, cl_svm_mem_flags = CL_MEM_READ_WRITE, 
 unsigned int = 0);
 template<typename T> void svm_free (const context &, svm_ptr< T >);
 }
}

Header <boost/compute/system.hpp>

namespace boost {
 namespace compute {
 class system ;
 }
}

Header <boost/compute/type_traits/common_type.hpp>

Header <boost/compute/type_traits/is_fundamental.hpp>

namespace boost {
 namespace compute {
 template<typename T> struct is_fundamental ;
 }
}

Header <boost/compute/type_traits/is_vector_type.hpp>

namespace boost {
 namespace compute {
 template<typename T> struct is_vector_type ;
 }
}

Header <boost/compute/type_traits/make_vector_type.hpp>

namespace boost {
 namespace compute {
 template<typename Scalar, size_t Size> struct make_vector_type ;
 }
}

Header <boost/compute/type_traits/result_of.hpp>

namespace boost {
 namespace compute {
 template<typename Signature> struct result_of ;
 }
}

Header <boost/compute/type_traits/scalar_type.hpp>

namespace boost {
 namespace compute {
 template<typename Vector> struct scalar_type ;
 }
}

Header <boost/compute/type_traits/type_definition.hpp>

namespace boost {
 namespace compute {
 template<typename T> std::string type_definition ();
 }
}

Header <boost/compute/type_traits/type_name.hpp>

BOOST_COMPUTE_TYPE_NAME(type, name)

namespace boost {
 namespace compute {
 template<typename T> const char * type_name ();
 }
}

Header <boost/compute/type_traits/vector_size.hpp>

namespace boost {
 namespace compute {
 template<typename T> struct vector_size ;
 }
}

Header <boost/compute/types.hpp>

Meta-header to include all Boost.Compute types headers.

Header <boost/compute/types/struct.hpp>

BOOST_COMPUTE_ADAPT_STRUCT(type, name, members)

Header <boost/compute/user_event.hpp>

namespace boost {
 namespace compute {
 class user_event ;
 }
}

Header <boost/compute/utility/dim.hpp>

namespace boost {
 namespace compute {
 template<class... Args> extents < sizeof...(Args)> dim (Args...);
 }
}

Header <boost/compute/utility/extents.hpp>

namespace boost {
 namespace compute {
 template<size_t N> class extents ;
 }
}

Header <boost/compute/utility/program_cache.hpp>

namespace boost {
 namespace compute {
 class program_cache ;
 }
}

Header <boost/compute/utility/source.hpp>

BOOST_COMPUTE_STRINGIZE_SOURCE(source)

Header <boost/compute/utility/wait_list.hpp>

namespace boost {
 namespace compute {
 class wait_list ;
 }
}

Header <boost/compute/version.hpp>

BOOST_COMPUTE_VERSION_MAJOR
BOOST_COMPUTE_VERSION_MINOR
BOOST_COMPUTE_VERSION_PATCH

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)

Prev Up Home Next