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