Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

This is the documentation for an old version of Boost. Click here to view this page for the latest version.
PrevUpHomeNext

Reference

API Overview
Header Reference

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>

Algorithms

Header: <boost/compute/algorithm.hpp>

Async

Header: <boost/compute/async.hpp>

Containers

Header: <boost/compute/container.hpp>

Exceptions

Header: <boost/compute/exception.hpp>

Iterators

Header: <boost/compute/iterators.hpp>

Images

Header: <boost/compute/image.hpp>

Shared Virtual Memory

Macros

OpenGL Sharing

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

Random Number Generators

Header: <boost/compute/random.hpp>

Type Traits

Header: <boost/compute/type_traits.hpp>

Header Reference

Header <boost/compute/algorithm/accumulate.hpp>
Header <boost/compute/algorithm/adjacent_difference.hpp>
Header <boost/compute/algorithm/adjacent_find.hpp>
Header <boost/compute/algorithm/all_of.hpp>
Header <boost/compute/algorithm/any_of.hpp>
Header <boost/compute/algorithm/binary_search.hpp>
Header <boost/compute/algorithm/copy.hpp>
Header <boost/compute/algorithm/copy_if.hpp>
Header <boost/compute/algorithm/copy_n.hpp>
Header <boost/compute/algorithm/count.hpp>
Header <boost/compute/algorithm/count_if.hpp>
Header <boost/compute/algorithm/equal.hpp>
Header <boost/compute/algorithm/equal_range.hpp>
Header <boost/compute/algorithm/exclusive_scan.hpp>
Header <boost/compute/algorithm/fill.hpp>
Header <boost/compute/algorithm/fill_n.hpp>
Header <boost/compute/algorithm/find.hpp>
Header <boost/compute/algorithm/find_end.hpp>
Header <boost/compute/algorithm/find_if.hpp>
Header <boost/compute/algorithm/find_if_not.hpp>
Header <boost/compute/algorithm/for_each.hpp>
Header <boost/compute/algorithm/for_each_n.hpp>
Header <boost/compute/algorithm/gather.hpp>
Header <boost/compute/algorithm/generate.hpp>
Header <boost/compute/algorithm/generate_n.hpp>
Header <boost/compute/algorithm/includes.hpp>
Header <boost/compute/algorithm/inclusive_scan.hpp>
Header <boost/compute/algorithm/inner_product.hpp>
Header <boost/compute/algorithm/inplace_merge.hpp>
Header <boost/compute/algorithm/iota.hpp>
Header <boost/compute/algorithm/is_partitioned.hpp>
Header <boost/compute/algorithm/is_permutation.hpp>
Header <boost/compute/algorithm/is_sorted.hpp>
Header <boost/compute/algorithm/lexicographical_compare.hpp>
Header <boost/compute/algorithm/lower_bound.hpp>
Header <boost/compute/algorithm/max_element.hpp>
Header <boost/compute/algorithm/merge.hpp>
Header <boost/compute/algorithm/min_element.hpp>
Header <boost/compute/algorithm/minmax_element.hpp>
Header <boost/compute/algorithm/mismatch.hpp>
Header <boost/compute/algorithm/next_permutation.hpp>
Header <boost/compute/algorithm/none_of.hpp>
Header <boost/compute/algorithm/nth_element.hpp>
Header <boost/compute/algorithm/partial_sum.hpp>
Header <boost/compute/algorithm/partition.hpp>
Header <boost/compute/algorithm/partition_copy.hpp>
Header <boost/compute/algorithm/partition_point.hpp>
Header <boost/compute/algorithm/prev_permutation.hpp>
Header <boost/compute/algorithm/random_shuffle.hpp>
Header <boost/compute/algorithm/reduce.hpp>
Header <boost/compute/algorithm/reduce_by_key.hpp>
Header <boost/compute/algorithm/remove.hpp>
Header <boost/compute/algorithm/remove_if.hpp>
Header <boost/compute/algorithm/replace.hpp>
Header <boost/compute/algorithm/replace_copy.hpp>
Header <boost/compute/algorithm/reverse.hpp>
Header <boost/compute/algorithm/reverse_copy.hpp>
Header <boost/compute/algorithm/rotate.hpp>
Header <boost/compute/algorithm/rotate_copy.hpp>
Header <boost/compute/algorithm/scatter.hpp>
Header <boost/compute/algorithm/scatter_if.hpp>
Header <boost/compute/algorithm/search.hpp>
Header <boost/compute/algorithm/search_n.hpp>
Header <boost/compute/algorithm/set_difference.hpp>
Header <boost/compute/algorithm/set_intersection.hpp>
Header <boost/compute/algorithm/set_symmetric_difference.hpp>
Header <boost/compute/algorithm/set_union.hpp>
Header <boost/compute/algorithm/sort.hpp>
Header <boost/compute/algorithm/sort_by_key.hpp>
Header <boost/compute/algorithm/stable_partition.hpp>
Header <boost/compute/algorithm/stable_sort.hpp>
Header <boost/compute/algorithm/stable_sort_by_key.hpp>
Header <boost/compute/algorithm/swap_ranges.hpp>
Header <boost/compute/algorithm/transform.hpp>
Header <boost/compute/algorithm/transform_if.hpp>
Header <boost/compute/algorithm/transform_reduce.hpp>
Header <boost/compute/algorithm/unique.hpp>
Header <boost/compute/algorithm/unique_copy.hpp>
Header <boost/compute/algorithm/upper_bound.hpp>
Header <boost/compute/allocator/buffer_allocator.hpp>
Header <boost/compute/allocator/pinned_allocator.hpp>
Header <boost/compute/async/future.hpp>
Header <boost/compute/async/wait.hpp>
Header <boost/compute/async/wait_guard.hpp>
Header <boost/compute/container/array.hpp>
Header <boost/compute/container/basic_string.hpp>
Header <boost/compute/container/dynamic_bitset.hpp>
Header <boost/compute/container/flat_map.hpp>
Header <boost/compute/container/flat_set.hpp>
Header <boost/compute/container/mapped_view.hpp>
Header <boost/compute/container/stack.hpp>
Header <boost/compute/container/string.hpp>
Header <boost/compute/container/valarray.hpp>
Header <boost/compute/container/vector.hpp>
Header <boost/compute/exception/context_error.hpp>
Header <boost/compute/exception/no_device_found.hpp>
Header <boost/compute/exception/opencl_error.hpp>
Header <boost/compute/exception/unsupported_extension_error.hpp>
Header <boost/compute/functional/as.hpp>
Header <boost/compute/functional/atomic.hpp>
Header <boost/compute/functional/bind.hpp>
Header <boost/compute/functional/common.hpp>
Header <boost/compute/functional/convert.hpp>
Header <boost/compute/functional/field.hpp>
Header <boost/compute/functional/geometry.hpp>
Header <boost/compute/functional/get.hpp>
Header <boost/compute/functional/hash.hpp>
Header <boost/compute/functional/identity.hpp>
Header <boost/compute/functional/integer.hpp>
Header <boost/compute/functional/logical.hpp>
Header <boost/compute/functional/math.hpp>
Header <boost/compute/functional/operator.hpp>
Header <boost/compute/functional/popcount.hpp>
Header <boost/compute/functional/relational.hpp>
Header <boost/compute/image/image1d.hpp>
Header <boost/compute/image/image2d.hpp>
Header <boost/compute/image/image3d.hpp>
Header <boost/compute/image/image_format.hpp>
Header <boost/compute/image/image_object.hpp>
Header <boost/compute/image/image_sampler.hpp>
Header <boost/compute/interop/opengl/acquire.hpp>
Header <boost/compute/interop/opengl/context.hpp>
Header <boost/compute/interop/opengl/opengl_buffer.hpp>
Header <boost/compute/interop/opengl/opengl_renderbuffer.hpp>
Header <boost/compute/interop/opengl/opengl_texture.hpp>
Header <boost/compute/iterator/buffer_iterator.hpp>
Header <boost/compute/iterator/constant_buffer_iterator.hpp>
Header <boost/compute/iterator/constant_iterator.hpp>
Header <boost/compute/iterator/counting_iterator.hpp>
Header <boost/compute/iterator/discard_iterator.hpp>
Header <boost/compute/iterator/function_input_iterator.hpp>
Header <boost/compute/iterator/permutation_iterator.hpp>
Header <boost/compute/iterator/strided_iterator.hpp>
Header <boost/compute/iterator/transform_iterator.hpp>
Header <boost/compute/iterator/zip_iterator.hpp>
Header <boost/compute/memory/local_buffer.hpp>
Header <boost/compute/memory/svm_ptr.hpp>
Header <boost/compute/random/bernoulli_distribution.hpp>
Header <boost/compute/random/default_random_engine.hpp>
Header <boost/compute/random/discrete_distribution.hpp>
Header <boost/compute/random/linear_congruential_engine.hpp>
Header <boost/compute/random/mersenne_twister_engine.hpp>
Header <boost/compute/random/normal_distribution.hpp>
Header <boost/compute/random/threefry_engine.hpp>
Header <boost/compute/random/uniform_int_distribution.hpp>
Header <boost/compute/random/uniform_real_distribution.hpp>
Header <boost/compute/type_traits/common_type.hpp>
Header <boost/compute/type_traits/is_device_iterator.hpp>
Header <boost/compute/type_traits/is_fundamental.hpp>
Header <boost/compute/type_traits/is_vector_type.hpp>
Header <boost/compute/type_traits/make_vector_type.hpp>
Header <boost/compute/type_traits/result_of.hpp>
Header <boost/compute/type_traits/scalar_type.hpp>
Header <boost/compute/type_traits/type_definition.hpp>
Header <boost/compute/type_traits/type_name.hpp>
Header <boost/compute/type_traits/vector_size.hpp>
Header <boost/compute/utility/dim.hpp>
Header <boost/compute/utility/extents.hpp>
Header <boost/compute/utility/invoke.hpp>
Header <boost/compute/utility/program_cache.hpp>
Header <boost/compute/utility/source.hpp>
Header <boost/compute/utility/wait_list.hpp>
namespace boost {
  namespace compute {
    template<typename InputIterator, typename T, typename BinaryFunction> 
      T accumulate(InputIterator, InputIterator, T, BinaryFunction, 
                   command_queue & = system::default_queue());
    template<typename InputIterator, typename T> 
      T accumulate(InputIterator, InputIterator, T, 
                   command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename OutputIterator, 
             typename BinaryFunction> 
      OutputIterator 
      adjacent_difference(InputIterator, InputIterator, OutputIterator, 
                          BinaryFunction, 
                          command_queue & = system::default_queue());
    template<typename InputIterator, typename OutputIterator> 
      OutputIterator 
      adjacent_difference(InputIterator, InputIterator, OutputIterator, 
                          command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename Compare> 
      InputIterator 
      adjacent_find(InputIterator, InputIterator, Compare, 
                    command_queue & = system::default_queue());
    template<typename InputIterator> 
      InputIterator 
      adjacent_find(InputIterator, InputIterator, 
                    command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename UnaryPredicate> 
      bool all_of(InputIterator, InputIterator, UnaryPredicate, 
                  command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename UnaryPredicate> 
      bool any_of(InputIterator, InputIterator, UnaryPredicate, 
                  command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename T> 
      bool binary_search(InputIterator, InputIterator, const T &, 
                         command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename OutputIterator> 
      OutputIterator 
      copy(InputIterator, InputIterator, OutputIterator, 
           command_queue & = system::default_queue());
    template<typename InputIterator, typename OutputIterator> 
      future< OutputIterator > 
      copy_async(InputIterator, InputIterator, OutputIterator, 
                 command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename OutputIterator, 
             typename Predicate> 
      OutputIterator 
      copy_if(InputIterator, InputIterator, OutputIterator, Predicate, 
              command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename Size, typename OutputIterator> 
      OutputIterator 
      copy_n(InputIterator, Size, OutputIterator, 
             command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename T> 
      size_t count(InputIterator, InputIterator, const T &, 
                   command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename Predicate> 
      size_t count_if(InputIterator, InputIterator, Predicate, 
                      command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator1, typename InputIterator2> 
      bool equal(InputIterator1, InputIterator1, InputIterator2, 
                 command_queue & = system::default_queue());
    template<typename InputIterator1, typename InputIterator2> 
      bool equal(InputIterator1, InputIterator1, InputIterator2, 
                 InputIterator2, command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename T> 
      std::pair< InputIterator, InputIterator > 
      equal_range(InputIterator, InputIterator, const T &, 
                  command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename OutputIterator, typename T, 
             typename BinaryOperator> 
      OutputIterator 
      exclusive_scan(InputIterator, InputIterator, OutputIterator, T, 
                     BinaryOperator, 
                     command_queue & = system::default_queue());
    template<typename InputIterator, typename OutputIterator, typename T> 
      OutputIterator 
      exclusive_scan(InputIterator, InputIterator, OutputIterator, T, 
                     command_queue & = system::default_queue());
    template<typename InputIterator, typename OutputIterator> 
      OutputIterator 
      exclusive_scan(InputIterator, InputIterator, OutputIterator, 
                     command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename BufferIterator, typename T> 
      void fill(BufferIterator, BufferIterator, const T &, 
                command_queue & = system::default_queue());
    template<typename BufferIterator, typename T> 
      future< void > 
      fill_async(BufferIterator first, BufferIterator last, const T & value, 
                 command_queue & queue = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename BufferIterator, typename Size, typename T> 
      void fill_n(BufferIterator, Size, const T &, 
                  command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename T> 
      InputIterator 
      find(InputIterator, InputIterator, const T &, 
           command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename TextIterator, typename PatternIterator> 
      TextIterator 
      find_end(TextIterator, TextIterator, PatternIterator, PatternIterator, 
               command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename UnaryPredicate> 
      InputIterator 
      find_if(InputIterator, InputIterator, UnaryPredicate, 
              command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename UnaryPredicate> 
      InputIterator 
      find_if_not(InputIterator, InputIterator, UnaryPredicate, 
                  command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename UnaryFunction> 
      UnaryFunction 
      for_each(InputIterator, InputIterator, UnaryFunction, 
               command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename Size, typename UnaryFunction> 
      UnaryFunction 
      for_each_n(InputIterator, Size, UnaryFunction, 
                 command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename MapIterator, 
             typename OutputIterator> 
      void gather(MapIterator, MapIterator, InputIterator, OutputIterator, 
                  command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename OutputIterator, typename Generator> 
      void generate(OutputIterator, OutputIterator, Generator, 
                    command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename OutputIterator, typename Size, typename Generator> 
      void generate_n(OutputIterator, Size, Generator, 
                      command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator1, typename InputIterator2> 
      bool includes(InputIterator1, InputIterator1, InputIterator2, 
                    InputIterator2, 
                    command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename OutputIterator, 
             typename BinaryOperator> 
      OutputIterator 
      inclusive_scan(InputIterator, InputIterator, OutputIterator, 
                     BinaryOperator, 
                     command_queue & = system::default_queue());
    template<typename InputIterator, typename OutputIterator> 
      OutputIterator 
      inclusive_scan(InputIterator, InputIterator, OutputIterator, 
                     command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator1, typename InputIterator2, typename T> 
      T inner_product(InputIterator1, InputIterator1, InputIterator2, T, 
                      command_queue & = system::default_queue());
    template<typename InputIterator1, typename InputIterator2, typename T, 
             typename BinaryAccumulateFunction, 
             typename BinaryTransformFunction> 
      T inner_product(InputIterator1, InputIterator1, InputIterator2, T, 
                      BinaryAccumulateFunction, BinaryTransformFunction, 
                      command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename Iterator> 
      void inplace_merge(Iterator, Iterator, Iterator, 
                         command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename BufferIterator, typename T> 
      void iota(BufferIterator, BufferIterator, const T &, 
                command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename UnaryPredicate> 
      bool is_partitioned(InputIterator, InputIterator, UnaryPredicate, 
                          command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator1, typename InputIterator2> 
      bool is_permutation(InputIterator1, InputIterator1, InputIterator2, 
                          InputIterator2, 
                          command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename Compare> 
      bool is_sorted(InputIterator, InputIterator, Compare, 
                     command_queue & = system::default_queue());
    template<typename InputIterator> 
      bool is_sorted(InputIterator, InputIterator, 
                     command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator1, typename InputIterator2> 
      bool lexicographical_compare(InputIterator1, InputIterator1, 
                                   InputIterator2, InputIterator2, 
                                   command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename T> 
      InputIterator 
      lower_bound(InputIterator, InputIterator, const T &, 
                  command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename Compare> 
      InputIterator 
      max_element(InputIterator, InputIterator, Compare, 
                  command_queue & = system::default_queue());
    template<typename InputIterator> 
      InputIterator 
      max_element(InputIterator, InputIterator, 
                  command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator1, typename InputIterator2, 
             typename OutputIterator, typename Compare> 
      OutputIterator 
      merge(InputIterator1, InputIterator1, InputIterator2, InputIterator2, 
            OutputIterator, Compare, 
            command_queue & = system::default_queue());
    template<typename InputIterator1, typename InputIterator2, 
             typename OutputIterator> 
      OutputIterator 
      merge(InputIterator1, InputIterator1, InputIterator2, InputIterator2, 
            OutputIterator, command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename Compare> 
      InputIterator 
      min_element(InputIterator, InputIterator, Compare, 
                  command_queue & = system::default_queue());
    template<typename InputIterator> 
      InputIterator 
      min_element(InputIterator, InputIterator, 
                  command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename Compare> 
      std::pair< InputIterator, InputIterator > 
      minmax_element(InputIterator, InputIterator, Compare, 
                     command_queue & = system::default_queue());
    template<typename InputIterator> 
      std::pair< InputIterator, InputIterator > 
      minmax_element(InputIterator, InputIterator, 
                     command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator1, typename InputIterator2> 
      std::pair< InputIterator1, InputIterator2 > 
      mismatch(InputIterator1, InputIterator1, InputIterator2, 
               command_queue & = system::default_queue());
    template<typename InputIterator1, typename InputIterator2> 
      std::pair< InputIterator1, InputIterator2 > 
      mismatch(InputIterator1, InputIterator1, InputIterator2, InputIterator2, 
               command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator> 
      bool next_permutation(InputIterator, InputIterator, 
                            command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename UnaryPredicate> 
      bool none_of(InputIterator, InputIterator, UnaryPredicate, 
                   command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename Iterator, typename Compare> 
      void nth_element(Iterator, Iterator, Iterator, Compare, 
                       command_queue & = system::default_queue());
    template<typename Iterator> 
      void nth_element(Iterator, Iterator, Iterator, 
                       command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename OutputIterator> 
      OutputIterator 
      partial_sum(InputIterator, InputIterator, OutputIterator, 
                  command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename Iterator, typename UnaryPredicate> 
      Iterator partition(Iterator, Iterator, UnaryPredicate, 
                         command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename OutputIterator1, 
             typename OutputIterator2, typename UnaryPredicate> 
      std::pair< OutputIterator1, OutputIterator2 > 
      partition_copy(InputIterator, InputIterator, OutputIterator1, 
                     OutputIterator2, UnaryPredicate, 
                     command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename UnaryPredicate> 
      InputIterator 
      partition_point(InputIterator, InputIterator, UnaryPredicate, 
                      command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator> 
      bool prev_permutation(InputIterator, InputIterator, 
                            command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename Iterator> 
      void random_shuffle(Iterator, Iterator, 
                          command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename OutputIterator, 
             typename BinaryFunction> 
      void reduce(InputIterator, InputIterator, OutputIterator, 
                  BinaryFunction, command_queue & = system::default_queue());
    template<typename InputIterator, typename OutputIterator> 
      void reduce(InputIterator, InputIterator, OutputIterator, 
                  command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputKeyIterator, typename InputValueIterator, 
             typename OutputKeyIterator, typename OutputValueIterator, 
             typename BinaryFunction, typename BinaryPredicate> 
      std::pair< OutputKeyIterator, OutputValueIterator > 
      reduce_by_key(InputKeyIterator, InputKeyIterator, InputValueIterator, 
                    OutputKeyIterator, OutputValueIterator, BinaryFunction, 
                    BinaryPredicate, 
                    command_queue & = system::default_queue());
    template<typename InputKeyIterator, typename InputValueIterator, 
             typename OutputKeyIterator, typename OutputValueIterator, 
             typename BinaryFunction> 
      std::pair< OutputKeyIterator, OutputValueIterator > 
      reduce_by_key(InputKeyIterator, InputKeyIterator, InputValueIterator, 
                    OutputKeyIterator, OutputValueIterator, BinaryFunction, 
                    command_queue & = system::default_queue());
    template<typename InputKeyIterator, typename InputValueIterator, 
             typename OutputKeyIterator, typename OutputValueIterator> 
      std::pair< OutputKeyIterator, OutputValueIterator > 
      reduce_by_key(InputKeyIterator, InputKeyIterator, InputValueIterator, 
                    OutputKeyIterator, OutputValueIterator, 
                    command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename Iterator, typename T> 
      Iterator remove(Iterator, Iterator, const T &, 
                      command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename Iterator, typename Predicate> 
      Iterator remove_if(Iterator, Iterator, Predicate, 
                         command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename Iterator, typename T> 
      void replace(Iterator, Iterator, const T &, const T &, 
                   command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename OutputIterator, typename T> 
      OutputIterator 
      replace_copy(InputIterator, InputIterator, OutputIterator, const T &, 
                   const T &, command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename Iterator> 
      void reverse(Iterator, Iterator, 
                   command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename OutputIterator> 
      OutputIterator 
      reverse_copy(InputIterator, InputIterator, OutputIterator, 
                   command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator> 
      void rotate(InputIterator, InputIterator, InputIterator, 
                  command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename OutputIterator> 
      void rotate_copy(InputIterator, InputIterator, InputIterator, 
                       OutputIterator, 
                       command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename MapIterator, 
             typename OutputIterator> 
      void scatter(InputIterator, InputIterator, MapIterator, OutputIterator, 
                   command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename MapIterator, 
             typename StencilIterator, typename OutputIterator, 
             typename Predicate> 
      void scatter_if(InputIterator, InputIterator, MapIterator, 
                      StencilIterator, OutputIterator, Predicate, 
                      command_queue & = system::default_queue());
    template<typename InputIterator, typename MapIterator, 
             typename StencilIterator, typename OutputIterator> 
      void scatter_if(InputIterator first, InputIterator last, 
                      MapIterator map, StencilIterator stencil, 
                      OutputIterator result, 
                      command_queue & queue = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename TextIterator, typename PatternIterator> 
      TextIterator 
      search(TextIterator, TextIterator, PatternIterator, PatternIterator, 
             command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename TextIterator, typename ValueType> 
      TextIterator 
      search_n(TextIterator, TextIterator, size_t, ValueType, 
               command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator1, typename InputIterator2, 
             typename OutputIterator> 
      OutputIterator 
      set_difference(InputIterator1, InputIterator1, InputIterator2, 
                     InputIterator2, OutputIterator, 
                     command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator1, typename InputIterator2, 
             typename OutputIterator> 
      OutputIterator 
      set_intersection(InputIterator1, InputIterator1, InputIterator2, 
                       InputIterator2, OutputIterator, 
                       command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator1, typename InputIterator2, 
             typename OutputIterator> 
      OutputIterator 
      set_symmetric_difference(InputIterator1, InputIterator1, InputIterator2, 
                               InputIterator2, OutputIterator, 
                               command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator1, typename InputIterator2, 
             typename OutputIterator> 
      OutputIterator 
      set_union(InputIterator1, InputIterator1, InputIterator2, 
                InputIterator2, OutputIterator, 
                command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename Iterator, typename Compare> 
      void sort(Iterator, Iterator, Compare, 
                command_queue & = system::default_queue());
    template<typename Iterator> 
      void sort(Iterator, Iterator, command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename KeyIterator, typename ValueIterator, typename Compare> 
      void sort_by_key(KeyIterator, KeyIterator, ValueIterator, Compare, 
                       command_queue & = system::default_queue());
    template<typename KeyIterator, typename ValueIterator> 
      void sort_by_key(KeyIterator, KeyIterator, ValueIterator, 
                       command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename Iterator, typename UnaryPredicate> 
      Iterator stable_partition(Iterator, Iterator, UnaryPredicate, 
                                command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename Iterator, typename Compare> 
      void stable_sort(Iterator, Iterator, Compare, 
                       command_queue & = system::default_queue());
    template<typename Iterator> 
      void stable_sort(Iterator, Iterator, 
                       command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename KeyIterator, typename ValueIterator, typename Compare> 
      void stable_sort_by_key(KeyIterator, KeyIterator, ValueIterator, 
                              Compare, 
                              command_queue & = system::default_queue());
    template<typename KeyIterator, typename ValueIterator> 
      void stable_sort_by_key(KeyIterator, KeyIterator, ValueIterator, 
                              command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename Iterator1, typename Iterator2> 
      Iterator2 swap_ranges(Iterator1, Iterator1, Iterator2, 
                            command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename OutputIterator, 
             typename UnaryOperator> 
      OutputIterator 
      transform(InputIterator, InputIterator, OutputIterator, UnaryOperator, 
                command_queue & = system::default_queue());
    template<typename InputIterator1, typename InputIterator2, 
             typename OutputIterator, typename BinaryOperator> 
      OutputIterator 
      transform(InputIterator1, InputIterator1, InputIterator2, 
                OutputIterator, BinaryOperator, 
                command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename OutputIterator, 
             typename UnaryFunction, typename Predicate> 
      OutputIterator 
      transform_if(InputIterator, InputIterator, OutputIterator, 
                   UnaryFunction, Predicate, 
                   command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename OutputIterator, 
             typename UnaryTransformFunction, typename BinaryReduceFunction> 
      void transform_reduce(InputIterator, InputIterator, OutputIterator, 
                            UnaryTransformFunction, BinaryReduceFunction, 
                            command_queue & = system::default_queue());
    template<typename InputIterator1, typename InputIterator2, 
             typename OutputIterator, typename BinaryTransformFunction, 
             typename BinaryReduceFunction> 
      void transform_reduce(InputIterator1, InputIterator1, InputIterator2, 
                            OutputIterator, BinaryTransformFunction, 
                            BinaryReduceFunction, 
                            command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename BinaryPredicate> 
      InputIterator 
      unique(InputIterator, InputIterator, BinaryPredicate, 
             command_queue & = system::default_queue());
    template<typename InputIterator> 
      InputIterator 
      unique(InputIterator, InputIterator, 
             command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename OutputIterator, 
             typename BinaryPredicate> 
      OutputIterator 
      unique_copy(InputIterator, InputIterator, OutputIterator, 
                  BinaryPredicate, command_queue & = system::default_queue());
    template<typename InputIterator, typename OutputIterator> 
      OutputIterator 
      unique_copy(InputIterator, InputIterator, OutputIterator, 
                  command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename T> 
      InputIterator 
      upper_bound(InputIterator, InputIterator, const T &, 
                  command_queue & = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename T> class buffer_allocator;
  }
}
namespace boost {
  namespace compute {
    template<typename T> class pinned_allocator;
  }
}
namespace boost {
  namespace compute {
    template<typename T> class future;
  }
}
namespace boost {
  namespace compute {
    template<class... Events> void wait_for_all(Events &&...);
  }
}
namespace boost {
  namespace compute {
    template<typename Waitable> class wait_guard;
  }
}
namespace boost {
  namespace compute {
    template<typename T, std::size_t N> class array;
  }
}
namespace boost {
  namespace compute {
    template<typename CharT, typename Traits = std::char_traits<CharT> > 
      class basic_string;
    template<typename CharT, typename Traits> 
      std::ostream & 
      operator<<(std::ostream & stream, 
                 boost::compute::basic_string< CharT, Traits >const & outStr);
  }
}
namespace boost {
  namespace compute {
    template<typename Block = ulong_, 
             typename Alloc = buffer_allocator<Block> > 
      class dynamic_bitset;
  }
}
namespace boost {
  namespace compute {
    template<typename Key, typename T> class flat_map;
  }
}
namespace boost {
  namespace compute {
    template<typename T> class flat_set;
  }
}
namespace boost {
  namespace compute {
    template<typename T> class mapped_view;
  }
}
namespace boost {
  namespace compute {
    template<typename T> class stack;
  }
}
namespace boost {
  namespace compute {
    typedef basic_string< char_ > string;
  }
}
namespace boost {
  namespace compute {
    template<typename T, typename Alloc = buffer_allocator<T> > class vector;
  }
}
namespace boost {
  namespace compute {
    class context_error;
  }
}
namespace boost {
  namespace compute {
    class no_device_found;
  }
}
namespace boost {
  namespace compute {
    class opencl_error;
  }
}
namespace boost {
  namespace compute {
    class unsupported_extension_error;
  }
}
namespace boost {
  namespace compute {
    template<typename T> struct as;
  }
}
namespace boost {
  namespace compute {
    template<typename T> class atomic_add;
    template<typename T> class atomic_sub;
    template<typename T> class atomic_xchg;
    template<typename T> class atomic_inc;
    template<typename T> class atomic_dec;
    template<typename T> class atomic_cmpxchg;
    template<typename T> class atomic_max;
    template<typename T> class atomic_min;
    template<typename T> class atomic_and;
    template<typename T> class atomic_or;
    template<typename T> class atomic_xor;
  }
}
namespace boost {
  namespace compute {
    template<typename T> struct is_placeholder;
    template<typename F, class... Args> unspecified bind(F, Args...);
    namespace placeholders {
      placeholder< 0 > const _1;
      placeholder< 1 > const _2;
    }
  }
}
namespace boost {
  namespace compute {
    template<typename T> struct convert;
  }
}
namespace boost {
  namespace compute {
    template<typename T> class field;
  }
}
namespace boost {
  namespace compute {
    template<size_t N> struct get;
  }
}
namespace boost {
  namespace compute {
    template<typename Key> struct hash;
  }
}
namespace boost {
  namespace compute {
    template<typename T> class identity;
  }
}
namespace boost {
  namespace compute {
    template<typename Predicate> class unary_negate;
    template<typename Predicate> class binary_negate;

    template<typename T> struct logical_not;
    template<typename Predicate> 
      unary_negate< Predicate > not1(const Predicate &);
    template<typename Predicate> 
      binary_negate< Predicate > not2(const Predicate &);
  }
}
namespace boost {
  namespace compute {
    template<typename T> class popcount;
  }
}
namespace boost {
  namespace compute {
    class image1d;
  }
}
namespace boost {
  namespace compute {
    class image2d;
  }
}
namespace boost {
  namespace compute {
    class image3d;
  }
}
namespace boost {
  namespace compute {
    class image_format;
  }
}
namespace boost {
  namespace compute {
    class image_object;
  }
}
namespace boost {
  namespace compute {
    class image_sampler;
  }
}
namespace boost {
  namespace compute {
    event opengl_enqueue_acquire_gl_objects(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());
  }
}
namespace boost {
  namespace compute {
    context opengl_create_shared_context();
  }
}
namespace boost {
  namespace compute {
    class opengl_buffer;
  }
}
namespace boost {
  namespace compute {
    class opengl_renderbuffer;
  }
}
namespace boost {
  namespace compute {
    class opengl_texture;
  }
}
namespace boost {
  namespace compute {
    template<typename T> class buffer_iterator;
    template<typename T> 
      buffer_iterator< T > make_buffer_iterator(const buffer &, size_t = 0);
  }
}
namespace boost {
  namespace compute {
    template<typename T> class constant_buffer_iterator;
    template<typename T> 
      constant_buffer_iterator< T > 
      make_constant_buffer_iterator(const buffer &, size_t = 0);
  }
}
namespace boost {
  namespace compute {
    template<typename T> class constant_iterator;
    template<typename T> 
      constant_iterator< T > make_constant_iterator(const T &, size_t = 0);
  }
}
namespace boost {
  namespace compute {
    template<typename T> class counting_iterator;
    template<typename T> 
      counting_iterator< T > make_counting_iterator(const T &);
  }
}
namespace boost {
  namespace compute {
    class discard_iterator;

    template<> struct is_device_iterator<discard_iterator>;
    discard_iterator make_discard_iterator(size_t = 0);
  }
}
namespace boost {
  namespace compute {
    template<typename Function> class function_input_iterator;
    template<typename Function> 
      function_input_iterator< Function > 
      make_function_input_iterator(const Function &, size_t = 0);
  }
}
namespace boost {
  namespace compute {
    template<typename ElementIterator, typename IndexIterator> 
      class permutation_iterator;
    template<typename ElementIterator, typename IndexIterator> 
      permutation_iterator< ElementIterator, IndexIterator > 
      make_permutation_iterator(ElementIterator, IndexIterator);
  }
}
namespace boost {
  namespace compute {
    template<typename Iterator> class strided_iterator;
    template<typename Iterator> 
      strided_iterator< Iterator > 
      make_strided_iterator(Iterator, 
                            typename std::iterator_traits< Iterator >::difference_type);
    template<typename Iterator> 
      strided_iterator< Iterator > 
      make_strided_iterator_end(Iterator, Iterator, 
                                typename std::iterator_traits< Iterator >::difference_type);
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename UnaryFunction> 
      class transform_iterator;
    template<typename InputIterator, typename UnaryFunction> 
      transform_iterator< InputIterator, UnaryFunction > 
      make_transform_iterator(InputIterator, UnaryFunction);
  }
}
namespace boost {
  namespace compute {
    template<typename IteratorTuple> class zip_iterator;
    template<typename IteratorTuple> 
      zip_iterator< IteratorTuple > make_zip_iterator(IteratorTuple);
  }
}
namespace boost {
  namespace compute {
    template<typename T> class local_buffer;
  }
}
namespace boost {
  namespace compute {
    template<typename T> class svm_ptr;
  }
}
namespace boost {
  namespace compute {
    template<typename RealType = float> class bernoulli_distribution;
  }
}
namespace boost {
  namespace compute {
    typedef mt19937 default_random_engine;
  }
}
namespace boost {
  namespace compute {
    template<typename IntType = uint_> class discrete_distribution;
  }
}
namespace boost {
  namespace compute {
    template<typename T = uint_> class linear_congruential_engine;
  }
}
namespace boost {
  namespace compute {
    template<typename T> class mersenne_twister_engine;

    typedef mersenne_twister_engine< uint_ > mt19937;
  }
}
namespace boost {
  namespace compute {
    template<typename RealType = float> class normal_distribution;
  }
}
namespace boost {
  namespace compute {
    template<typename T = uint_> class threefry_engine;
  }
}
namespace boost {
  namespace compute {
    template<typename IntType = uint_> class uniform_int_distribution;
  }
}
namespace boost {
  namespace compute {
    template<typename RealType = float> class uniform_real_distribution;
  }
}
namespace boost {
  namespace compute {
    template<typename Iterator> struct is_device_iterator;
  }
}
namespace boost {
  namespace compute {
    template<typename T> struct is_fundamental;
  }
}
namespace boost {
  namespace compute {
    template<typename T> struct is_vector_type;
  }
}
namespace boost {
  namespace compute {
    template<typename Scalar, size_t Size> struct make_vector_type;
  }
}
namespace boost {
  namespace compute {
    template<typename Signature> struct result_of;
  }
}
namespace boost {
  namespace compute {
    template<typename Vector> struct scalar_type;
  }
}
namespace boost {
  namespace compute {
    template<typename T> std::string type_definition();
  }
}

BOOST_COMPUTE_TYPE_NAME(type, name)
namespace boost {
  namespace compute {
    template<typename T> const char * type_name();
  }
}
namespace boost {
  namespace compute {
    template<typename T> struct vector_size;
  }
}
namespace boost {
  namespace compute {
    template<class... Args> extents< sizeof...(Args)> dim(Args...);
  }
}
namespace boost {
  namespace compute {
    template<size_t N> class extents;
  }
}

BOOST_COMPUTE_DETAIL_INVOKE_ARG(z, n, unused)
BOOST_COMPUTE_DETAIL_INVOKE_ADD_ARG(z, n, unused)
BOOST_COMPUTE_DETAIL_DEFINE_INVOKE(z, n, unused)
namespace boost {
  namespace compute {
    template<typename Function, class... Args> 
      result_of< Function(Args...)>::type 
      invoke(const Function &, command_queue &, const Args &...);
  }
}
namespace boost {
  namespace compute {
    class program_cache;
  }
}
namespace boost {
  namespace compute {
    class wait_list;
  }
}

PrevUpHomeNext