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

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/program_build_failure.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());

    // This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. 
    template<typename InputIterator, typename T> 
      T accumulate(InputIterator first, InputIterator last, T init, 
                   command_queue & 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());

    // This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. 
    template<typename InputIterator, typename OutputIterator> 
      OutputIterator 
      adjacent_difference(InputIterator first, InputIterator last, 
                          OutputIterator result, 
                          command_queue & queue = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename Compare> 
      InputIterator 
      adjacent_find(InputIterator, InputIterator, Compare, 
                    command_queue & = system::default_queue());

    // This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. 
    template<typename InputIterator> 
      InputIterator 
      adjacent_find(InputIterator first, InputIterator last, 
                    command_queue & 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(), 
           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());
  }
}
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(), 
             const wait_list & = wait_list());
  }
}
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());

    // This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. 
    template<typename InputIterator1, typename InputIterator2> 
      bool equal(InputIterator1 first1, InputIterator1 last1, 
                 InputIterator2 first2, InputIterator2 last2, 
                 command_queue & 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());

    // This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. 
    template<typename InputIterator, typename OutputIterator, typename T> 
      OutputIterator 
      exclusive_scan(InputIterator first, InputIterator last, 
                     OutputIterator result, T init, 
                     command_queue & queue = system::default_queue());

    // This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. 
    template<typename InputIterator, typename OutputIterator> 
      OutputIterator 
      exclusive_scan(InputIterator first, InputIterator last, 
                     OutputIterator result, 
                     command_queue & 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());

    // This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. 
    template<typename InputIterator, typename OutputIterator> 
      OutputIterator 
      inclusive_scan(InputIterator first, InputIterator last, 
                     OutputIterator result, 
                     command_queue & 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());

    // This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. 
    template<typename InputIterator1, typename InputIterator2, typename T, 
             typename BinaryAccumulateFunction, 
             typename BinaryTransformFunction> 
      T inner_product(InputIterator1 first1, InputIterator1 last1, 
                      InputIterator2 first2, T init, 
                      BinaryAccumulateFunction accumulate_function, 
                      BinaryTransformFunction transform_function, 
                      command_queue & 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());

    // This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. 
    template<typename InputIterator> 
      bool is_sorted(InputIterator first, InputIterator last, 
                     command_queue & 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());

    // This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. 
    template<typename InputIterator> 
      InputIterator 
      max_element(InputIterator first, InputIterator last, 
                  command_queue & 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());

    // This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. 
    template<typename InputIterator1, typename InputIterator2, 
             typename OutputIterator> 
      OutputIterator 
      merge(InputIterator1 first1, InputIterator1 last1, 
            InputIterator2 first2, InputIterator2 last2, 
            OutputIterator result, 
            command_queue & queue = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename Compare> 
      InputIterator 
      min_element(InputIterator, InputIterator, Compare, 
                  command_queue & = system::default_queue());

    // This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. 
    template<typename InputIterator> 
      InputIterator 
      min_element(InputIterator first, InputIterator last, 
                  command_queue & 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());

    // This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. 
    template<typename InputIterator> 
      std::pair< InputIterator, InputIterator > 
      minmax_element(InputIterator first, InputIterator last, 
                     command_queue & 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());

    // This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. 
    template<typename InputIterator1, typename InputIterator2> 
      std::pair< InputIterator1, InputIterator2 > 
      mismatch(InputIterator1 first1, InputIterator1 last1, 
               InputIterator2 first2, InputIterator2 last2, 
               command_queue & 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());

    // This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. 
    template<typename Iterator> 
      void nth_element(Iterator first, Iterator nth, Iterator last, 
                       command_queue & 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());

    // This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. 
    template<typename InputIterator, typename OutputIterator> 
      void reduce(InputIterator first, InputIterator last, 
                  OutputIterator result, 
                  command_queue & 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());

    // This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. 
    template<typename InputKeyIterator, typename InputValueIterator, 
             typename OutputKeyIterator, typename OutputValueIterator, 
             typename BinaryFunction> 
      std::pair< OutputKeyIterator, OutputValueIterator > 
      reduce_by_key(InputKeyIterator keys_first, InputKeyIterator keys_last, 
                    InputValueIterator values_first, 
                    OutputKeyIterator keys_result, 
                    OutputValueIterator values_result, 
                    BinaryFunction function, 
                    command_queue & queue = system::default_queue());

    // This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. 
    template<typename InputKeyIterator, typename InputValueIterator, 
             typename OutputKeyIterator, typename OutputValueIterator> 
      std::pair< OutputKeyIterator, OutputValueIterator > 
      reduce_by_key(InputKeyIterator keys_first, InputKeyIterator keys_last, 
                    InputValueIterator values_first, 
                    OutputKeyIterator keys_result, 
                    OutputValueIterator values_result, 
                    command_queue & 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());

    // This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. 
    template<typename Iterator> 
      void sort(Iterator first, Iterator last, 
                command_queue & 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());

    // This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. 
    template<typename KeyIterator, typename ValueIterator> 
      void sort_by_key(KeyIterator keys_first, KeyIterator keys_last, 
                       ValueIterator values_first, 
                       command_queue & 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());

    // This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. 
    template<typename Iterator> 
      void stable_sort(Iterator first, Iterator last, 
                       command_queue & 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());

    // This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. 
    template<typename KeyIterator, typename ValueIterator> 
      void stable_sort_by_key(KeyIterator keys_first, KeyIterator keys_last, 
                              ValueIterator values_first, 
                              command_queue & 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());

    // This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. 
    template<typename InputIterator1, typename InputIterator2, 
             typename OutputIterator, typename BinaryOperator> 
      OutputIterator 
      transform(InputIterator1 first1, InputIterator1 last1, 
                InputIterator2 first2, OutputIterator result, 
                BinaryOperator op, 
                command_queue & 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());

    // This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. 
    template<typename InputIterator1, typename InputIterator2, 
             typename OutputIterator, typename BinaryTransformFunction, 
             typename BinaryReduceFunction> 
      void transform_reduce(InputIterator1 first1, InputIterator1 last1, 
                            InputIterator2 first2, OutputIterator result, 
                            BinaryTransformFunction transform_function, 
                            BinaryReduceFunction reduce_function, 
                            command_queue & queue = system::default_queue());
  }
}
namespace boost {
  namespace compute {
    template<typename InputIterator, typename BinaryPredicate> 
      InputIterator 
      unique(InputIterator, InputIterator, BinaryPredicate, 
             command_queue & = system::default_queue());

    // This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. 
    template<typename InputIterator> 
      InputIterator 
      unique(InputIterator first, InputIterator last, 
             command_queue & 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());

    // This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. 
    template<typename InputIterator, typename OutputIterator> 
      OutputIterator 
      unique_copy(InputIterator first, InputIterator last, 
                  OutputIterator result, 
                  command_queue & 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 program_build_failure;
  }
}
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_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;
  }
}
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 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 &);
  }
}
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