| Home | Libraries | People | FAQ | More

## Reference

### API Overview

#### Core Library

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

- `buffer`
- `command_queue`
- `context`
- `device`
- `event`
- `kernel`
- `memory_object`
- `pipe`
- `platform`
- `program`
- `system`
- `user_event`

#### Utilities

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

- `dim()`
- `extents<N>`
- `program_cache`
- `wait_list`

#### Algorithms

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

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

#### Async

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

- `future<T>`
- `wait_for_all()`
- `wait_guard<Waitable>`

#### Containers

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

- `array<T, N>`
- `basic_string<CharT>`
- `dynamic_bitset<>`
- `flat_map<Key, T>`
- `flat_set<T>`
- `mapped_view<T>`
- `stack<T>`
- `string`
- `valarray<T>`
- `vector<T>`

#### Exceptions

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

- `context_error`
- `no_device_found`
- `opencl_error`
- `unsupported_extension_error`

#### Iterators

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

- `buffer_iterator<T>`
- `constant_buffer_iterator<T>`
- `constant_iterator<T>`
- `counting_iterator<T>`
- `discard_iterator`
- `function_input_iterator<Function>`
- `permutation_iterator<ElementIterator, IndexIterator>`
- `strided_iterator<Iterator>`
- `transform_iterator<InputIterator, UnaryFunction>`
- `zip_iterator<IteratorTuple>`

#### Images

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

- `image1d`
- `image2d`
- `image3d`
- `image_format`
- `image_object`
- `image_sampler`

#### Shared Virtual Memory

- `svm_ptr<T>`
- `svm_alloc<T>()`
- `svm_free<T>()`

#### Macros

- `BOOST_COMPUTE_ADAPT_STRUCT`
- `BOOST_COMPUTE_FUNCTION`
- `BOOST_COMPUTE_STRINGIZE_SOURCE()`

#### OpenGL Sharing

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

- `opengl_buffer`
- `opengl_create_shared_context()`
- `opengl_enqueue_acquire_buffer()`
- `opengl_enqueue_acquire_gl_objects()`
- `opengl_enqueue_release_buffer()`
- `opengl_enqueue_acquire_gl_objects()`
- `opengl_renderbuffer`
- `opengl_texture`

#### Random Number Generators

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

- `bernoulli_distribution`
- `default_random_engine`
- `discrete_distribution`
- `linear_congruential_engine`
- `mersenne_twister_engine`
- `normal_distribution`
- `uniform_int_distribution`
- `uniform_real_distribution`

#### Type Traits

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

- `is_device_iterator<Iterator>`
- `is_fundamental<T>`
- `is_vector_type<T>`
- `make_vector_type<T, N>`
- `result_of<F(Args...)>`
- `scalar_type<T>`
- `type_name<T>()`

### Header Reference

#### Header <boost/compute/algorithm/accumulate.hpp>

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

#### 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(),
               const wait_list & = wait_list());
        template<typename InputIterator, typename OutputIterator>
          future< OutputIterator >
          copy_async(InputIterator, InputIterator, OutputIterator,
                     command_queue & = system::default_queue(),
                     const wait_list & = wait_list());
      }
    }

#### 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(),
                 const wait_list & = wait_list());
      }
    }

#### 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());
        template<typename InputIterator1, typename InputIterator2>
          bool equal(InputIterator1, InputIterator1, InputIterator2,
                     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, typename T,
                 typename BinaryOperator>
          OutputIterator
          exclusive_scan(InputIterator, InputIterator, OutputIterator, T,
                         BinaryOperator,
                         command_queue & = system::default_queue());
        template<typename InputIterator, typename OutputIterator, typename T>
          OutputIterator
          exclusive_scan(InputIterator, InputIterator, OutputIterator, T,
                         command_queue & = system::default_queue());
        template<typename InputIterator, typename OutputIterator>
          OutputIterator
          exclusive_scan(InputIterator, InputIterator, OutputIterator,
                         command_queue & = system::default_queue());
      }
    }

#### 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/for_each_n.hpp>

    namespace boost {
      namespace compute {
        template<typename InputIterator, typename Size, typename UnaryFunction>
          UnaryFunction
          for_each_n(InputIterator, Size, 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,
                 typename BinaryOperator>
          OutputIterator
          inclusive_scan(InputIterator, InputIterator, OutputIterator,
                         BinaryOperator,
                         command_queue & = system::default_queue());
        template<typename InputIterator, typename OutputIterator>
          OutputIterator
          inclusive_scan(InputIterator, InputIterator, OutputIterator,
                         command_queue & = system::default_queue());
      }
    }

#### 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, typename Compare>
          InputIterator
          max_element(InputIterator, InputIterator, Compare,
                      command_queue & = system::default_queue());
        template<typename InputIterator>
          InputIterator
          max_element(InputIterator, InputIterator,
                      command_queue & = system::default_queue());
      }
    }

#### 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, typename Compare>
          InputIterator
          min_element(InputIterator, InputIterator, Compare,
                      command_queue & = system::default_queue());
        template<typename InputIterator>
          InputIterator
          min_element(InputIterator, InputIterator,
                      command_queue & = system::default_queue());
      }
    }

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

    namespace boost {
      namespace compute {
        template<typename InputIterator, typename Compare>
          std::pair< InputIterator, InputIterator >
          minmax_element(InputIterator, InputIterator, Compare,
                         command_queue & = system::default_queue());
        template<typename InputIterator>
          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());
        template<typename InputIterator1, typename InputIterator2>
          std::pair< InputIterator1, InputIterator2 >
          mismatch(InputIterator1, InputIterator1, InputIterator2, 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/reduce_by_key.hpp>

    namespace boost {
      namespace compute {
        template<typename InputKeyIterator, typename InputValueIterator,
                 typename OutputKeyIterator, typename OutputValueIterator,
                 typename BinaryFunction, typename BinaryPredicate>
          std::pair< OutputKeyIterator, OutputValueIterator >
          reduce_by_key(InputKeyIterator, InputKeyIterator, InputValueIterator,
                        OutputKeyIterator, OutputValueIterator, BinaryFunction,
                        BinaryPredicate,
                        command_queue & = system::default_queue());
        template<typename InputKeyIterator, typename InputValueIterator,
                 typename OutputKeyIterator, typename OutputValueIterator,
                 typename BinaryFunction>
          std::pair< OutputKeyIterator, OutputValueIterator >
          reduce_by_key(InputKeyIterator, InputKeyIterator, InputValueIterator,
                        OutputKeyIterator, OutputValueIterator, BinaryFunction,
                        command_queue & = system::default_queue());
        template<typename InputKeyIterator, typename InputValueIterator,
                 typename OutputKeyIterator, typename OutputValueIterator>
          std::pair< OutputKeyIterator, OutputValueIterator >
          reduce_by_key(InputKeyIterator, InputKeyIterator, InputValueIterator,
                        OutputKeyIterator, OutputValueIterator,
                        command_queue & = system::default_queue());
      }
    }

#### 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/scatter_if.hpp>

    namespace boost {
      namespace compute {
        template<typename InputIterator, typename MapIterator,
                 typename StencilIterator, typename OutputIterator,
                 typename Predicate>
          void scatter_if(InputIterator, InputIterator, MapIterator,
                          StencilIterator, OutputIterator, Predicate,
                          command_queue & = system::default_queue());
        template<typename InputIterator, typename MapIterator,
                 typename StencilIterator, typename OutputIterator>
          void scatter_if(InputIterator first, InputIterator last,
                          MapIterator map, StencilIterator stencil,
                          OutputIterator result,
                          command_queue & queue = system::default_queue());
      }
    }

#### 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/stable_sort_by_key.hpp>

    namespace boost {
      namespace compute {
        template<typename KeyIterator, typename ValueIterator, typename Compare>
          void stable_sort_by_key(KeyIterator, KeyIterator, ValueIterator,
                                  Compare,
                                  command_queue & = system::default_queue());
        template<typename KeyIterator, typename ValueIterator>
          void stable_sort_by_key(KeyIterator, KeyIterator, ValueIterator,
                                  command_queue & = system::default_queue());
      }
    }

#### 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_if.hpp>

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

#### 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/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/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/async/wait_guard.hpp>

    namespace boost {
      namespace compute {
        template<typename Waitable> class wait_guard;
      }
    }

#### 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>

    BOOST_COMPUTE_DEFINE_VALARRAY_BINARY_OPERATOR(op, op_name, assert)
    BOOST_COMPUTE_DEFINE_VALARRAY_BINARY_OPERATOR_ANY(op, op_name)
    BOOST_COMPUTE_DEFINE_VALARRAY_BINARY_OPERATOR_NO_FP(op, op_name)
    BOOST_COMPUTE_DEFINE_VALARRAY_COMPARISON_OPERATOR(op, op_name)
    BOOST_COMPUTE_DEFINE_VALARRAY_LOGICAL_OPERATOR(op, op_name)

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

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

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

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

    namespace boost {
      namespace compute {
        class context_error;
      }
    }

#### Header <boost/compute/exception/no_device_found.hpp>

    namespace boost {
      namespace compute {
        class no_device_found;
      }
    }

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

    namespace boost {
      namespace compute {
        class opencl_error;
      }
    }

#### Header <boost/compute/exception/program_build_failure.hpp>

    namespace boost {
      namespace compute {
        class program_build_failure;
      }
    }

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

    namespace boost {
      namespace compute {
        class unsupported_extension_error;
      }
    }

#### 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_and;
        template<typename T> class atomic_cmpxchg;
        template<typename T> class atomic_dec;
        template<typename T> class atomic_inc;
        template<typename T> class atomic_max;
        template<typename T> class atomic_min;
        template<typename T> class atomic_or;
        template<typename T> class atomic_sub;
        template<typename T> class atomic_xchg;
        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 binary_negate;

        template<typename T> struct logical_not;

        template<typename Predicate> class unary_negate;
        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/image/image1d.hpp>

    namespace boost {
      namespace compute {
        class image1d;
      }
    }

#### Header <boost/compute/image/image2d.hpp>

    namespace boost {
      namespace compute {
        class image2d;
      }
    }

#### Header <boost/compute/image/image3d.hpp>

    namespace boost {
      namespace compute {
        class image3d;
      }
    }

#### Header <boost/compute/image/image_format.hpp>

    namespace boost {
      namespace compute {
        class image_format;
      }
    }

#### Header <boost/compute/image/image_object.hpp>

    namespace boost {
      namespace compute {
        class image_object;
      }
    }

#### Header <boost/compute/image/image_sampler.hpp>

    namespace boost {
      namespace compute {
        class image_sampler;
      }
    }

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

    namespace boost {
      namespace compute {
        event opengl_enqueue_acquire_gl_objects(const uint_, const cl_mem *,
                                                command_queue &,
                                                const wait_list & = wait_list());
        event opengl_enqueue_release_gl_objects(const uint_, 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/context.hpp>

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

#### 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/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;

        template<> struct is_device_iterator<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/strided_iterator.hpp>

    namespace boost {
      namespace compute {
        template<typename Iterator> class strided_iterator;
        template<typename Iterator>
          strided_iterator< Iterator >
          make_strided_iterator(Iterator,
                                typename std::iterator_traits< Iterator >::difference_type);
        template<typename Iterator>
          strided_iterator< Iterator >
          make_strided_iterator_end(Iterator, Iterator,
                                    typename std::iterator_traits< Iterator >::difference_type);
      }
    }

#### 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/memory/local_buffer.hpp>

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

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

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

#### 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/threefry_engine.hpp>

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

#### 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/type_traits/common_type.hpp>

#### Header <boost/compute/type_traits/is_device_iterator.hpp>

    namespace boost {
      namespace compute {
        template<typename Iterator> struct is_device_iterator;
      }
    }

#### 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/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/invoke.hpp>

    BOOST_COMPUTE_DETAIL_INVOKE_ARG(z, n, unused)
    BOOST_COMPUTE_DETAIL_INVOKE_ADD_ARG(z, n, unused)
    BOOST_COMPUTE_DETAIL_DEFINE_INVOKE(z, n, unused)

    namespace boost {
      namespace compute {
        template<typename Function, class... Args>
          result_of< Function(Args...)>::type
          invoke(const Function &, command_queue &, const Args &...);
      }
    }

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