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

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

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

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 {
    class buffer;
  }
}

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

namespace boost {
  namespace compute {
    class command_queue;
  }
}

BOOST_COMPUTE_CL_CALLBACK
BOOST_COMPUTE_MAX_ARITY

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

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

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

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

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

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

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 {
    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 for buffer at index. 
    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 with value at index. 
    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 for iterator with transform. 
    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;
  }
}

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

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

namespace boost {
  namespace compute {
    class memory_object;
  }
}

namespace boost {
  namespace compute {
    class pipe;
     BOOST_COMPUTE_DETAIL_DEFINE_GET_INFO_SPECIALIZATIONS(pipe, 
                                                          ((cl_uint, CL_PIPE_PACKET_SIZE))((cl_uint, CL_PIPE_MAX_PACKETS)));
  }
}

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 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 IntType = uint_> class uniform_int_distribution;
  }
}

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

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

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 Signature> struct result_of;
  }
}

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

namespace boost {
  namespace compute {

    // Returns the OpenCL type definition for T. 
    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;
  }
}

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

BOOST_COMPUTE_ADAPT_STRUCT(type, name, members)

namespace boost {
  namespace compute {
    class user_event;
  }
}

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

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

namespace boost {
  namespace compute {
    class program_cache;
  }
}

BOOST_COMPUTE_STRINGIZE_SOURCE(source)

namespace boost {
  namespace compute {
    class wait_list;
  }
}

BOOST_COMPUTE_VERSION_MAJOR
BOOST_COMPUTE_VERSION_MINOR
BOOST_COMPUTE_VERSION_PATCH