Bolt  1.3
C++ template library with support for OpenCL
Classes | Functions
bolt::amp Namespace Reference
AMP-TransformIterator

Namespace containing AMP related data types and functions. More...

Classes

class  control
 
struct  device_vector_tag
 
class  create_empty_array
 
class  device_vector
 This defines the AMP version of a device_vector. More...
 
struct  unary_function
 
struct  binary_function
 
struct  square
 
struct  cube
 
struct  negate
 
struct  plus
 
struct  minus
 
struct  multiplies
 
struct  divides
 
struct  maximum
 
struct  minimum
 
struct  modulus
 
struct  bit_and
 
struct  bit_or
 
struct  bit_xor
 
struct  logical_not
 
struct  equal_to
 
struct  not_equal_to
 
struct  greater
 
struct  identity
 
struct  less
 
struct  greater_equal
 
struct  less_equal
 
struct  logical_and
 
struct  logical_or
 
struct  equal_to_value
 
struct  not_pred
 
struct  pair
 
struct  unary_negate
 
struct  tuple_element< 0, pair< T1, T2 > >
 
struct  tuple_element< 1, pair< T1, T2 > >
 
struct  tuple_size< pair< T1, T2 > >
 
struct  constant_unary
 
struct  new_value_if
 
struct  unary_transform_if_functor
 
struct  binary_negate
 
struct  constant_iterator_tag
 
class  constant_iterator
 
struct  counting_iterator_tag
 
class  counting_iterator
 
struct  iterator_traits
 
struct  iterator_traits< T * >
 
struct  iterator_traits< const T * >
 
struct  fancy_iterator_tag
 
struct  permutation_iterator_tag
 
class  permutation_iterator
 
struct  transform_iterator_tag
 
class  transform_iterator
 

Functions

template<typename ForwardIterator , typename T >
bool binary_search (bolt::amp::control &ctl, ForwardIterator first, ForwardIterator last, const T &value)
 This version of binary search returns true if the search value is present within the given input range and false otherwise. The routine requires the elements to be arranged in ascending/descending order. It returns true iff there exists an iterator i in [first, last) such that *i < value and value < *i are both false.
 
template<typename ForwardIterator , typename T >
bool binary_search (ForwardIterator first, ForwardIterator last, const T &value)
 
template<typename ForwardIterator , typename T , typename StrictWeakOrdering >
bool binary_search (bolt::amp::control &ctl, ForwardIterator first, ForwardIterator last, const T &value, StrictWeakOrdering comp)
 This version of binary search returns true if the search value is present within the given input range and false otherwise. The routine requires the elements to be arranged in ascending/descending order. It returns true iff there exists an iterator i in [first, last) such that comp(*i, value) and comp(value, *i) are both false.
 
template<typename ForwardIterator , typename T , typename StrictWeakOrdering >
bool binary_search (ForwardIterator first, ForwardIterator last, const T &value, StrictWeakOrdering comp)
 
void getVersion (unsigned int &major, unsigned int &minor, unsigned int &patch)
 Query the Bolt library for version information.
 
template<typename InputIterator , typename OutputIterator >
OutputIterator copy (const bolt::amp::control &ctl, InputIterator first, InputIterator last, OutputIterator result)
 
template<typename InputIterator , typename OutputIterator >
OutputIterator copy (InputIterator first, InputIterator last, OutputIterator result)
 
template<typename InputIterator , typename Size , typename OutputIterator >
OutputIterator copy_n (const bolt::amp::control &ctl, InputIterator first, Size n, OutputIterator result)
 
template<typename InputIterator , typename Size , typename OutputIterator >
OutputIterator copy_n (InputIterator first, Size n, OutputIterator result)
 
template<typename DerivedPolicy , typename InputIterator , typename OutputIterator , typename Predicate >
OutputIterator copy_if (const bolt::amp::control &ctl, InputIterator first, InputIterator last, OutputIterator result, Predicate pred)
 
template<typename InputIterator , typename OutputIterator , typename Predicate >
OutputIterator copy_if (InputIterator first, InputIterator last, OutputIterator result, Predicate pred)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename Predicate >
OutputIterator copy_if (const bolt::amp::control &ctl, InputIterator1 first, InputIterator1 last, InputIterator2 stencil, OutputIterator result, Predicate pred)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename Predicate >
OutputIterator copy_if (InputIterator1 first, InputIterator1 last, InputIterator2 stencil, OutputIterator result, Predicate pred)
 
template<typename InputIterator , typename EqualityComparable >
bolt::amp::iterator_traits
< InputIterator >
::difference_type 		count (control &ctl, InputIterator first, InputIterator last, const EqualityComparable &value)
 count counts the number of elements in the specified range which compare equal to the specified value.
 
template<typename InputIterator , typename EqualityComparable >
bolt::amp::iterator_traits
< InputIterator >
::difference_type 		count (InputIterator first, InputIterator last, const EqualityComparable &value)
 
template<typename InputIterator , typename Predicate >
bolt::amp::iterator_traits
< InputIterator >
::difference_type 		count_if (control &ctl, InputIterator first, InputIterator last, Predicate predicate=bolt::amp::detail::CountIfEqual< int >())
 count_if counts the number of elements in the specified range for which the specified predicate is true.
 
template<typename InputIterator , typename Predicate >
bolt::amp::iterator_traits
< InputIterator >
::difference_type 		count_if (InputIterator first, InputIterator last, Predicate predicate)
 
template<typename ForwardIterator , typename T >
void fill (const bolt::amp::control &ctl, ForwardIterator first, ForwardIterator last, const T &value)
 Fill assigns the value of value to each element in the range [first,last].
 
template<typename ForwardIterator , typename T >
void fill (ForwardIterator first, ForwardIterator last, const T &value)
 
template<typename OutputIterator , typename Size , typename T >
OutputIterator fill_n (const bolt::amp::control &ctl, OutputIterator first, Size n, const T &value)
 fill_n assigns the value value to every element in the range [first,first+n]. The return value is first + n.
 
template<typename OutputIterator , typename Size , typename T >
OutputIterator fill_n (OutputIterator first, Size n, const T &value)
 
template<typename InputIterator , typename T >
InputIterator find (InputIterator first, InputIterator last, const T &value)
 
template<typename InputIterator , typename T >
InputIterator find (bolt::amp::control &ctl, InputIterator first, InputIterator last, const T &value)
 
template<typename InputIterator , typename Predicate >
InputIterator find_if (InputIterator first, InputIterator last, Predicate pred)
 
template<typename InputIterator , typename Predicate >
InputIterator find_if (bolt::amp::control &ctl, InputIterator first, InputIterator last, Predicate pred)
 
template<typename InputIterator , typename Predicate >
InputIterator find_if_not (InputIterator first, InputIterator last, Predicate pred)
 
template<typename InputIterator , typename Predicate >
InputIterator find_if_not (bolt::amp::control &ctl, InputIterator first, InputIterator last, Predicate pred)
 
template<typename InputIterator , typename UnaryFunction >
InputIterator for_each (InputIterator first, InputIterator last, UnaryFunction f)
 ForEach applies the unary function f to each element in the range [first,last] without modifying the input sequence.
 
template<typename InputIterator , typename UnaryFunction >
InputIterator for_each (control &ctl, InputIterator first, InputIterator last, UnaryFunction f)
 
template<typename InputIterator , typename Size , typename UnaryFunction >
InputIterator for_each_n (InputIterator first, Size n, UnaryFunction f)
 ForEach_n applies the unary function f to each element in the range [first,first+n] without modifying the input sequence.
 
template<typename InputIterator , typename Size , typename UnaryFunction >
InputIterator for_each_n (control &ctl, InputIterator first, Size n, UnaryFunction f)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
void gather (::bolt::amp::control &ctl, InputIterator1 map_first, InputIterator1 map_last, InputIterator2 input_first, OutputIterator result)
 This version of gather copies elements from a source array to a destination range according to a specified map. For each i in InputIterator1 in the range [map_first, map_last), gather copies the corresponding input_first[ map [ i ] ] to result[ i - map_first ].
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
void gather (InputIterator1 map_first, InputIterator1 map_last, InputIterator2 input_first, OutputIterator result)
 
template<typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename OutputIterator >
void gather_if (bolt::amp::control &ctl, InputIterator1 map_first, InputIterator1 map_last, InputIterator2 stencil, InputIterator3 input_first, OutputIterator result)
 This version of gather_if copies elements from a source array to a destination range according to a specified map. For each i in InputIterator1 in the range [map_first, map_last), gather_if copies the corresponding input_first[ map [ i ] ] to result[ i - map_first ] if stencil[ i - map_first ] is true.
 
template<typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename OutputIterator >
void gather_if (InputIterator1 map_first, InputIterator1 map_last, InputIterator2 stencil, InputIterator3 input_first, OutputIterator result)
 
template<typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename OutputIterator , typename Predicate >
void gather_if (bolt::amp::control &ctl, InputIterator1 map_first, InputIterator1 map_last, InputIterator2 stencil, InputIterator3 input, OutputIterator result, Predicate pred)
 This version of gather_if copies elements from a source array to a destination range according to a specified map. For each i in InputIterator1 in the range [map_first, map_last), gather_if copies the corresponding input_first[ map [ i ] ] to result[ i - map_first ] if pred (stencil[ i - map_first ]) is true.
 
template<typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename OutputIterator , typename Predicate >
void gather_if (InputIterator1 map_first, InputIterator1 map_last, InputIterator2 stencil, InputIterator3 input, OutputIterator result, Predicate pred)
 
template<typename ForwardIterator , typename Generator >
void generate (bolt::amp::control &ctl, ForwardIterator first, ForwardIterator last, const Generator &gen)
 generate assigns to each element of a sequence [first,last] the value returned by gen.
 
template<typename ForwardIterator , typename Generator >
void generate (ForwardIterator first, ForwardIterator last, const Generator &gen)
 
template<typename OutputIterator , typename Size , typename Generator >
OutputIterator generate_n (bolt::amp::control &ctl, OutputIterator first, Size n, const Generator &gen)
 generate_n assigns to each element of a sequence [first,first+n] the value returned by gen.
 
template<typename OutputIterator , typename Size , typename Generator >
OutputIterator generate_n (OutputIterator first, Size n, const Generator &gen)
 
template<typename InputIterator , typename OutputType >
OutputType inner_product (bolt::amp::control &ctl, InputIterator first1, InputIterator last1, InputIterator first2, OutputType init)
 Inner Product returns the inner product of two iterators. This is similar to calculating binary transform and then reducing the result. The inner_product operation is similar the std::inner_product function. This function can take optional control structure to control command-queue.
 
template<typename InputIterator , typename OutputType >
OutputType inner_product (InputIterator first1, InputIterator last1, InputIterator first2, OutputType init)
 
template<typename InputIterator , typename OutputType , typename BinaryFunction1 , typename BinaryFunction2 >
OutputType inner_product (bolt::amp::control &ctl, InputIterator first1, InputIterator last1, InputIterator first2, OutputType init, BinaryFunction1 f1, BinaryFunction2 f2)
 Inner Product returns the inner product of two iterators using user specified binary functors f1 and f2. This is similar to calculating transform and then reducing the result. The functor f1 should be commutative. This function can take optional control structure to control command-queue. The inner_product operation is similar the std::inner_product function.
 
template<typename InputIterator , typename OutputType , typename BinaryFunction1 , typename BinaryFunction2 >
OutputType inner_product (InputIterator first1, InputIterator last1, InputIterator first2, OutputType init, BinaryFunction1 f1, BinaryFunction2 f2)
 
template<typename InputIterator , typename Predicate >
bool all_of (bolt::amp::control &ctl, InputIterator first, InputIterator last, Predicate pred)
 
template<typename InputIterator , typename Predicate >
bool all_of (InputIterator first, InputIterator last, Predicate pred)
 
template<typename InputIterator , typename Predicate >
bool any_of (bolt::amp::control &ctl, InputIterator first, InputIterator last, Predicate pred)
 
template<typename InputIterator , typename Predicate >
bool any_of (InputIterator first, InputIterator last, Predicate pred)
 
template<typename InputIterator , typename Predicate >
bool none_of (bolt::amp::control &ctl, InputIterator first, InputIterator last, Predicate pred)
 
template<typename InputIterator , typename Predicate >
bool none_of (InputIterator first, InputIterator last, Predicate pred)
 
template<typename ForwardIterator >
ForwardIterator max_element (bolt::amp::control &ctl, ForwardIterator first, ForwardIterator last)
 The max_element returns the location of the first maximum element in the specified range.
 
template<typename ForwardIterator >
ForwardIterator max_element (ForwardIterator first, ForwardIterator last)
 
template<typename ForwardIterator , typename BinaryPredicate >
ForwardIterator max_element (bolt::amp::control &ctl, ForwardIterator first, ForwardIterator last, BinaryPredicate binary_op)
 The max_element returns the location of the first maximum element in the specified range using the specified binary_op.
 
template<typename ForwardIterator , typename BinaryPredicate >
ForwardIterator max_element (ForwardIterator first, ForwardIterator last, BinaryPredicate binary_op)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
OutputIterator merge (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result)
 merge returns the result of combining the two sorted range [first1, last1] and [first2, last2] in to a single sorted range [result , result + (last1-first1) + ( last2-first2)]
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
OutputIterator merge (bolt::amp::control &ctl, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename StrictWeakCompare >
OutputIterator merge (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, StrictWeakCompare comp)
 merge returns the result of combining the two sorted range [first1, last1] and [first2, last2] in to a single sorted range [result , result + (last1-first1) + ( last2-first2)]
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename StrictWeakCompare >
OutputIterator merge (bolt::amp::control &ctl, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, StrictWeakCompare comp)
 
template<typename ForwardIterator >
ForwardIterator min_element (bolt::amp::control &ctl, ForwardIterator first, ForwardIterator last)
 The min_element returns the location of the first minimum element in the specified range.
 
template<typename ForwardIterator >
ForwardIterator min_element (ForwardIterator first, ForwardIterator last)
 
template<typename ForwardIterator , typename BinaryPredicate >
ForwardIterator min_element (bolt::amp::control &ctl, ForwardIterator first, ForwardIterator last, BinaryPredicate binary_op)
 The min_element returns the location of the first minimum element in the specified range using the specified binary_op.
 
template<typename ForwardIterator , typename BinaryPredicate >
ForwardIterator min_element (ForwardIterator first, ForwardIterator last, BinaryPredicate binary_op)
 
template<typename T1 , typename T2 >
bool operator== (const pair< T1, T2 > &x, const pair< T1, T2 > &y)
 
template<typename T1 , typename T2 >
bool operator< (const pair< T1, T2 > &x, const pair< T1, T2 > &y)
 
template<typename T1 , typename T2 >
bool operator!= (const pair< T1, T2 > &x, const pair< T1, T2 > &y)
 
template<typename T1 , typename T2 >
bool operator> (const pair< T1, T2 > &x, const pair< T1, T2 > &y)
 
template<typename T1 , typename T2 >
bool operator<= (const pair< T1, T2 > &x, const pair< T1, T2 > &y)
 
template<typename T1 , typename T2 >
bool operator>= (const pair< T1, T2 > &x, const pair< T1, T2 > &y)
 
template<typename T1 , typename T2 >
pair< T1, T2 > make_pair (T1 x, T2 y)
 
template<typename InputIterator >
std::iterator_traits
< InputIterator >::value_type 		reduce (bolt::amp::control &ctl, InputIterator first, InputIterator last)
 reduce returns the result of combining all the elements in the specified range using the specified binary_op. The classic example is a summation, where the binary_op is the plus operator. By default, the initial value is "0" and the binary operator is "plus<>()".
 
template<typename InputIterator >
std::iterator_traits
< InputIterator >::value_type 		reduce (InputIterator first, InputIterator last)
 
template<typename InputIterator , typename T >
T reduce (bolt::amp::control &ctl, InputIterator first, InputIterator last, T init)
 reduce returns the result of combining all the elements in the specified range using the specified binary_op. The classic example is a summation, where the binary_op is the plus operator. By default, the initial value is "0" and the binary operator is "plus<>()".
 
template<typename InputIterator , typename T >
T reduce (InputIterator first, InputIterator last, T init)
 
template<typename InputIterator , typename T , typename BinaryFunction >
T reduce (bolt::amp::control &ctl, InputIterator first, InputIterator last, T init, BinaryFunction binary_op=bolt::amp::plus< T >())
 reduce returns the result of combining all the elements in the specified range using the specified binary_op. The classic example is a summation, where the binary_op is the plus operator. By default, the binary operator is "plus<>()". The version takes a bolt::amp::control structure as a first argument.
 
template<typename InputIterator , typename T , typename BinaryFunction >
T reduce (InputIterator first, InputIterator last, T init, BinaryFunction binary_op)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator1 , typename OutputIterator2 >
bolt::amp::pair
< OutputIterator1,
OutputIterator2 > 		reduce_by_key (control &ctl, InputIterator1 keys_first, InputIterator1 keys_last, InputIterator2 values_first, OutputIterator1 keys_output, OutputIterator2 values_output)
 reduce_by_key performs, on a sequence, a reduction of each sub-sequence as defined by equivalent keys; the BinaryFunction in this version is plus(), and the BinaryPredicate is equal_to().
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator1 , typename OutputIterator2 >
bolt::amp::pair
< OutputIterator1,
OutputIterator2 > 		reduce_by_key (InputIterator1 keys_first, InputIterator1 keys_last, InputIterator2 values_first, OutputIterator1 keys_output, OutputIterator2 values_output)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator1 , typename OutputIterator2 , typename BinaryPredicate >
bolt::amp::pair
< OutputIterator1,
OutputIterator2 > 		reduce_by_key (control &ctl, InputIterator1 keys_first, InputIterator1 keys_last, InputIterator2 values_first, OutputIterator1 keys_output, OutputIterator2 values_output, BinaryPredicate binary_pred)
 reduce_by_key performs, on a sequence, a reduction of each sub-sequence as defined by equivalent keys; the BinaryFunction in this version is plus(). reduce_by_key is a generalization of reduce to key-value pairs. If the reduction operator is not commutative then bolt::reduce_by_key should not be used.
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator1 , typename OutputIterator2 , typename BinaryPredicate >
bolt::amp::pair
< OutputIterator1,
OutputIterator2 > 		reduce_by_key (InputIterator1 keys_first, InputIterator1 keys_last, InputIterator2 values_first, OutputIterator1 keys_output, OutputIterator2 values_output, BinaryPredicate binary_pred)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator1 , typename OutputIterator2 , typename BinaryPredicate , typename BinaryFunction >
bolt::amp::pair
< OutputIterator1,
OutputIterator2 > 		reduce_by_key (control &ctl, InputIterator1 keys_first, InputIterator1 keys_last, InputIterator2 values_first, OutputIterator1 keys_output, OutputIterator2 values_output, BinaryPredicate binary_pred, BinaryFunction binary_op)
 reduce_by_key performs, on a sequence, a reduction of each sub-sequence as defined by equivalent keys; reduce_by_key is a generalization of reduce to key-value pairs. If the reduction operator is not commutative then bolt::reduce_by_key should not be used.
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator1 , typename OutputIterator2 , typename BinaryPredicate , typename BinaryFunction >
bolt::amp::pair
< OutputIterator1,
OutputIterator2 > 		reduce_by_key (InputIterator1 keys_first, InputIterator1 keys_last, InputIterator2 values_first, OutputIterator1 keys_output, OutputIterator2 values_output, BinaryPredicate binary_pred, BinaryFunction binary_op)
 
template<typename ForwardIterator , typename Predicate >
ForwardIterator remove_if (control &ctl, ForwardIterator first, ForwardIterator last, Predicate pred)
 
template<typename ForwardIterator , typename Predicate >
ForwardIterator remove_if (ForwardIterator first, ForwardIterator last, Predicate pred)
 
template<typename ForwardIterator , typename InputIterator , typename Predicate >
ForwardIterator remove_if (control &ctl, ForwardIterator first, ForwardIterator last, InputIterator stencil, Predicate pred)
 
template<typename ForwardIterator , typename InputIterator , typename Predicate >
ForwardIterator remove_if (ForwardIterator first, ForwardIterator last, InputIterator stencil, Predicate pred)
 
template<typename ForwardIterator , typename T >
ForwardIterator remove (control &ctl, ForwardIterator first, ForwardIterator last, const T &value)
 
template<typename ForwardIterator , typename T >
ForwardIterator remove (ForwardIterator first, ForwardIterator last, const T &value)
 
template<typename InputIterator , typename OutputIterator , typename Predicate >
OutputIterator remove_copy_if (control &ctl, InputIterator first, InputIterator last, OutputIterator result, Predicate pred)
 
template<typename InputIterator , typename OutputIterator , typename Predicate >
OutputIterator remove_copy_if (InputIterator first, InputIterator last, OutputIterator result, Predicate pred)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename Predicate >
OutputIterator remove_copy_if (control &ctl, InputIterator1 first, InputIterator1 last, InputIterator2 stencil, OutputIterator result, Predicate pred)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename Predicate >
OutputIterator remove_copy_if (InputIterator1 first, InputIterator1 last, InputIterator2 stencil, OutputIterator result, Predicate pred)
 
template<typename InputIterator , typename OutputIterator , typename T >
OutputIterator remove_copy (control &ctl, InputIterator first, InputIterator last, OutputIterator result, const T &value)
 
template<typename InputIterator , typename OutputIterator , typename T >
OutputIterator remove_copy (InputIterator first, InputIterator last, OutputIterator result, const T &value)
 
template<typename InputIterator , typename T >
void replace (InputIterator first, InputIterator last, const T &old_value, const T &new_value)
 
template<typename InputIterator , typename T >
void replace (control &ctl, InputIterator first, InputIterator last, const T &old_value, const T &new_value)
 
template<typename InputIterator , typename Predicate , typename T >
void replace_if (control &ctl, InputIterator first, InputIterator last, Predicate pred, const T &new_value)
 
template<typename InputIterator , typename Predicate , typename T >
void replace_if (InputIterator first, InputIterator last, Predicate pred, const T &new_value)
 
template<typename InputIterator1 , typename InputIterator2 , typename Predicate , typename T >
void replace_if (InputIterator1 first, InputIterator1 last, InputIterator2 stencil, Predicate pred, const T &new_value)
 
template<typename InputIterator1 , typename InputIterator2 , typename Predicate , typename T >
void replace_if (control &ctl, InputIterator1 first, InputIterator1 last, InputIterator2 stencil, Predicate pred, const T &new_value)
 
template<typename InputIterator , typename OutputIterator , typename Predicate , typename T >
OutputIterator replace_copy_if (control &ctl, InputIterator first, InputIterator last, OutputIterator result, Predicate pred, const T &new_value)
 
template<typename InputIterator , typename OutputIterator , typename Predicate , typename T >
OutputIterator replace_copy_if (InputIterator first, InputIterator last, OutputIterator result, Predicate pred, const T &new_value)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename Predicate , typename T >
OutputIterator replace_copy_if (control &ctl, InputIterator1 first, InputIterator1 last, InputIterator2 stencil, OutputIterator result, Predicate pred, const T &new_value)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename Predicate , typename T >
OutputIterator replace_copy_if (InputIterator1 first, InputIterator1 last, InputIterator2 stencil, OutputIterator result, Predicate pred, const T &new_value)
 
template<typename InputIterator , typename OutputIterator , typename T >
OutputIterator replace_copy (control &ctl, InputIterator first, InputIterator last, OutputIterator result, const T &old_value, const T &new_value)
 
template<typename InputIterator , typename OutputIterator , typename T >
OutputIterator replace_copy (InputIterator first, InputIterator last, OutputIterator result, const T &old_value, const T &new_value)
 
template<typename InputIterator , typename OutputIterator >
OutputIterator inclusive_scan (control &ctl, InputIterator first, InputIterator last, OutputIterator result)
 inclusive_scan calculates a running sum over a range of values, inclusive of the current value. The result value at iterator position i is the running sum of all values less than i in the input range. inclusive_scan requires associativity of the binary operation to parallelize the prefix sum.
 
template<typename InputIterator , typename OutputIterator >
OutputIterator inclusive_scan (InputIterator first, InputIterator last, OutputIterator result)
 
template<typename InputIterator , typename OutputIterator , typename BinaryFunction >
OutputIterator inclusive_scan (control &ctl, InputIterator first, InputIterator last, OutputIterator result, BinaryFunction binary_op)
 inclusive_scan calculates a running sum over a range of values, inclusive of the current value. The result value at iterator position i is the running sum of all values less than i in the input range. inclusive_scan requires associativity of the binary operation to parallelize the prefix sum.
 
template<typename InputIterator , typename OutputIterator , typename BinaryFunction >
OutputIterator inclusive_scan (InputIterator first, InputIterator last, OutputIterator result, BinaryFunction binary_op)
 
template<typename InputIterator , typename OutputIterator >
OutputIterator exclusive_scan (control &ctl, InputIterator first, InputIterator last, OutputIterator result)
 exclusive_scan calculates a running sum over a range of values, exclusive of the current value. The result value at iterator position i is the running sum of all values less than i in the input range. exclusive_scan requires associativity of the binary operation to parallelize it.
 
template<typename InputIterator , typename OutputIterator >
OutputIterator exclusive_scan (InputIterator first, InputIterator last, OutputIterator result)
 
template<typename InputIterator , typename OutputIterator , typename T >
OutputIterator exclusive_scan (control &ctl, InputIterator first, InputIterator last, OutputIterator result, T init)
 exclusive_scan calculates a running sum over a range of values, exclusive of the current value. The result value at iterator position i is the running sum of all values less than i in the input range. exclusive_scan requires associativity of the binary operation to parallelize it.
 
template<typename InputIterator , typename OutputIterator , typename T >
OutputIterator exclusive_scan (InputIterator first, InputIterator last, OutputIterator result, T init)
 
template<typename InputIterator , typename OutputIterator , typename T , typename BinaryFunction >
OutputIterator exclusive_scan (control &ctl, InputIterator first, InputIterator last, OutputIterator result, T init, BinaryFunction binary_op)
 exclusive_scan calculates a running sum over a range of values, exclusive of the current value. The result value at iterator position i is the running sum of all values less than i in the input range. exclusive_scan requires associativity of the binary operation to parallelize it.
 
template<typename InputIterator , typename OutputIterator , typename T , typename BinaryFunction >
OutputIterator exclusive_scan (InputIterator first, InputIterator last, OutputIterator result, T init, BinaryFunction binary_op)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
OutputIterator inclusive_scan_by_key (control &ctl, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, const std::string &user_code="")
 inclusive_scan_by_key performs, on a sequence, an inclusive scan of each sub-sequence as defined by equivalent keys; the BinaryFunction in this version is plus(), and the BinaryPredicate is equal_to(). inclusive_scan_by_key uses the associative operator binary_op to perform the parallel segmented prefix sum.
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
OutputIterator inclusive_scan_by_key (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, const std::string &user_code="")
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename BinaryPredicate >
OutputIterator inclusive_scan_by_key (control &ctl, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, BinaryPredicate binary_pred, const std::string &user_code="")
 inclusive_scan_by_key performs, on a sequence, an inclusive scan of each sub-sequence as defined by equivalent keys; the BinaryFunction in this version is plus(). inclusive_scan_by_key uses the associative operator binary_op to perform the parallel segmented prefix sum.
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename BinaryPredicate >
OutputIterator inclusive_scan_by_key (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, BinaryPredicate binary_pred, const std::string &user_code="")
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename BinaryPredicate , typename BinaryFunction >
OutputIterator inclusive_scan_by_key (control &ctl, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, BinaryPredicate binary_pred, BinaryFunction binary_funct, const std::string &user_code="")
 inclusive_scan_by_key performs, on a sequence, an inclusive scan of each sub-sequence as defined by equivalent keys. inclusive_scan_by_key uses the associative operator binary_op to perform the parallel segmented prefix sum.
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename BinaryPredicate , typename BinaryFunction >
OutputIterator inclusive_scan_by_key (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, BinaryPredicate binary_pred, BinaryFunction binary_funct, const std::string &user_code="")
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
OutputIterator exclusive_scan_by_key (control &ctl, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, const std::string &user_code="")
 exclusive_scan_by_key performs, on a sequence, an exclusive scan of each sub-sequence as defined by equivalent keys; the BinaryFunction in this version is plus(), the BinaryPredicate is equal_to(), and init is 0. exclusive_scan_by_key uses the associative operator binary_op to perform the parallel segmented prefix sum.
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
OutputIterator exclusive_scan_by_key (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, const std::string &user_code="")
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename T >
OutputIterator exclusive_scan_by_key (control &ctl, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, T init, const std::string &user_code="")
 exclusive_scan_by_key performs, on a sequence, an exclusive scan of each sub-sequence as defined by equivalent keys; the BinaryFunction in this version is plus(), and the BinaryPredicate is equal_to(). exclusive_scan_by_key uses the associative operator binary_op to perform the parallel segmented prefix sum.
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename T >
OutputIterator exclusive_scan_by_key (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, T init, const std::string &user_code="")
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename T , typename BinaryPredicate >
OutputIterator exclusive_scan_by_key (control &ctl, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, T init, BinaryPredicate binary_pred, const std::string &user_code="")
 exclusive_scan_by_key performs, on a sequence, an exclusive scan of each sub-sequence as defined by equivalent keys; the BinaryFunction in this version is plus(). exclusive_scan_by_key uses the associative operator binary_op to perform the parallel segmented prefix sum.
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename T , typename BinaryPredicate >
OutputIterator exclusive_scan_by_key (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, T init, BinaryPredicate binary_pred, const std::string &user_code="")
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename T , typename BinaryPredicate , typename BinaryFunction >
OutputIterator exclusive_scan_by_key (control &ctl, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, T init, BinaryPredicate binary_pred, BinaryFunction binary_funct, const std::string &user_code="")
 exclusive_scan_by_key performs, on a sequence, an exclusive scan of each sub-sequence as defined by equivalent keys. exclusive_scan_by_key uses the associative operator binary_op to perform the parallel segmented prefix sum.
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename T , typename BinaryPredicate , typename BinaryFunction >
OutputIterator exclusive_scan_by_key (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, T init, BinaryPredicate binary_pred, BinaryFunction binary_funct, const std::string &user_code="")
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
void scatter (::bolt::amp::control &ctl, InputIterator1 first, InputIterator1 last, InputIterator2 map, OutputIterator result)
 This version of scatter copies elements from a source range to a destination array according to a specified map. For each i in InputIterator1 in the range [first, last), scatter copies the corresponding input_first to result[ map [ i ] ].
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
void scatter (InputIterator1 first, InputIterator1 last1, InputIterator2 map, OutputIterator result)
 
template<typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename OutputIterator >
void scatter_if (bolt::amp::control &ctl, InputIterator1 first1, InputIterator1 last1, InputIterator2 map, InputIterator3 stencil, OutputIterator result)
 This version of scatter_if copies elements from a source range to a destination array according to a specified map. For each i in InputIterator1 in the range [first, last), scatter_if copies the corresponding input_first to result[ map [ i ] ] if stencil[ i - first ] is true.
 
template<typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename OutputIterator >
void scatter_if (InputIterator1 first1, InputIterator1 last1, InputIterator2 map, InputIterator3 stencil, OutputIterator result)
 
template<typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename OutputIterator , typename Predicate >
void scatter_if (bolt::amp::control &ctl, InputIterator1 first1, InputIterator1 last1, InputIterator2 map, InputIterator3 stencil, OutputIterator result, Predicate pred)
 This version of scatter_if copies elements from a source range to a destination array according to a specified map. For each i in InputIterator1 in the range [first, last), scatter_if copies the corresponding input_first to result[ map [ i ] ] if pred (stencil[ i - first ]) is true.
 
template<typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename OutputIterator , typename Predicate >
void scatter_if (InputIterator1 first1, InputIterator1 last1, InputIterator2 map, InputIterator3 stencil, OutputIterator result, Predicate pred)
 
template<typename RandomAccessIterator >
void sort (bolt::amp::control &ctl, RandomAccessIterator first, RandomAccessIterator last)
 
template<typename RandomAccessIterator >
void sort (RandomAccessIterator first, RandomAccessIterator last)
 
template<typename RandomAccessIterator , typename StrictWeakOrdering >
void sort (bolt::amp::control &ctl, RandomAccessIterator first, RandomAccessIterator last, StrictWeakOrdering comp)
 
template<typename RandomAccessIterator , typename StrictWeakOrdering >
void sort (RandomAccessIterator first, RandomAccessIterator last, StrictWeakOrdering comp)
 
template<typename RandomAccessIterator1 , typename RandomAccessIterator2 >
void sort_by_key (bolt::amp::control &ctl, RandomAccessIterator1 keys_first, RandomAccessIterator1 keys_last, RandomAccessIterator2 values_first)
 This version of sort_by_key returns the sorted result of all the elements in the RandomAccessIterator between the the first and last elements key elements and corresponding values. The routine arranges the elements in an ascending order.
 
template<typename RandomAccessIterator1 , typename RandomAccessIterator2 >
void sort_by_key (RandomAccessIterator1 keys_first, RandomAccessIterator1 keys_last, RandomAccessIterator2 values_first)
 
template<typename RandomAccessIterator1 , typename RandomAccessIterator2 , typename StrictWeakOrdering >
void sort_by_key (bolt::amp::control &ctl, RandomAccessIterator1 keys_first, RandomAccessIterator1 keys_last, RandomAccessIterator2 values_first, StrictWeakOrdering comp)
 This version of sort_by_key returns the sorted result of all the elements in the RandomAccessIterator between the the first and last elements key elements and corresponding values. The routine arranges the elements in an ascending order.
 
template<typename RandomAccessIterator1 , typename RandomAccessIterator2 , typename StrictWeakOrdering >
void sort_by_key (RandomAccessIterator1 keys_first, RandomAccessIterator1 keys_last, RandomAccessIterator2 values_first, StrictWeakOrdering comp)
 
template<typename RandomAccessIterator >
void stable_sort (RandomAccessIterator first, RandomAccessIterator last)
 
template<typename RandomAccessIterator , typename StrictWeakOrdering >
void stable_sort (RandomAccessIterator first, RandomAccessIterator last, StrictWeakOrdering comp)
 
template<typename RandomAccessIterator >
void stable_sort (bolt::amp::control &ctl, RandomAccessIterator first, RandomAccessIterator last)
 
template<typename RandomAccessIterator , typename StrictWeakOrdering >
void stable_sort (bolt::amp::control &ctl, RandomAccessIterator first, RandomAccessIterator last, StrictWeakOrdering comp)
 
template<typename RandomAccessIterator1 , typename RandomAccessIterator2 >
void stable_sort_by_key (RandomAccessIterator1 keys_first, RandomAccessIterator1 keys_last, RandomAccessIterator2 values_first)
 
template<typename RandomAccessIterator1 , typename RandomAccessIterator2 , typename StrictWeakOrdering >
void stable_sort_by_key (RandomAccessIterator1 keys_first, RandomAccessIterator1 keys_last, RandomAccessIterator2 values_first, StrictWeakOrdering comp)
 
template<typename RandomAccessIterator1 , typename RandomAccessIterator2 >
void stable_sort_by_key (bolt::amp::control &ctl, RandomAccessIterator1 keys_first, RandomAccessIterator1 keys_last, RandomAccessIterator2 values_first)
 
template<typename RandomAccessIterator1 , typename RandomAccessIterator2 , typename StrictWeakOrdering >
void stable_sort_by_key (bolt::amp::control &ctl, RandomAccessIterator1 keys_first, RandomAccessIterator1 keys_last, RandomAccessIterator2 values_first, StrictWeakOrdering comp)
 
template<typename InputIterator , typename OutputIterator , typename UnaryFunction >
void transform (control &ctl, InputIterator first, InputIterator last, OutputIterator result, UnaryFunction op)
 
template<typename InputIterator , typename OutputIterator , typename UnaryFunction >
void transform (InputIterator first, InputIterator last, OutputIterator result, UnaryFunction op)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename BinaryFunction >
void transform (control &ctl, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, BinaryFunction op)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename BinaryFunction >
void transform (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, BinaryFunction op)
 
template<typename InputIterator , typename OutputIterator , typename UnaryFunction , typename Predicate >
OutputIterator transform_if (control &ctl, InputIterator first, InputIterator last, OutputIterator result, UnaryFunction op, Predicate pred)
 
template<typename InputIterator , typename OutputIterator , typename UnaryFunction , typename Predicate >
OutputIterator transform_if (InputIterator first, InputIterator last, OutputIterator result, UnaryFunction op, Predicate pred)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename UnaryFunction , typename Predicate >
OutputIterator transform_if (InputIterator1 first, InputIterator1 last, InputIterator2 stencil, OutputIterator result, UnaryFunction op, Predicate pred)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename UnaryFunction , typename Predicate >
OutputIterator transform_if (control &ctl, InputIterator1 first, InputIterator1 last, InputIterator2 stencil, OutputIterator result, UnaryFunction op, Predicate pred)
 
template<typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename OutputIterator , typename BinaryFunction , typename Predicate >
OutputIterator transform_if (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator3 stencil, OutputIterator result, BinaryFunction op, Predicate pred)
 
template<typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename OutputIterator , typename BinaryFunction , typename Predicate >
OutputIterator transform_if (control &ctl, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator3 stencil, OutputIterator result, BinaryFunction op, Predicate pred)
 
template<typename InputIterator , typename UnaryFunction , typename T , typename BinaryFunction >
T transform_reduce (InputIterator first, InputIterator last, UnaryFunction transform_op, T init, BinaryFunction reduce_op)
 transform_reduce fuses transform and reduce operations together, increasing performance by reducing memory passes.
 
template<typename InputIterator , typename UnaryFunction , typename T , typename BinaryFunction >
T transform_reduce (control &ctl, InputIterator first1, InputIterator last1, UnaryFunction transform_op, T init, BinaryFunction reduce_op)
 transform_reduce fuses transform and reduce operations together, increasing performance by reducing memory passes.
 
template<typename outputT , int Rank, typename UnaryFunction , typename BinaryFunction >
outputT transform_reduce_range (concurrency::accelerator_view av, concurrency::index< Rank > origin, concurrency::extent< Rank > ext, UnaryFunction transform_op, outputT init, BinaryFunction reduce_op)
 
template<typename outputT , int Rank, typename UnaryFunction , typename BinaryFunction >
outputT transform_reduce_range (concurrency::index< Rank > origin, concurrency::extent< Rank > ext, UnaryFunction transform_op, outputT init, BinaryFunction reduce_op)
 
template<typename InputIterator , typename OutputIterator , typename UnaryFunction , typename BinaryFunction >
OutputIterator transform_inclusive_scan (control &ctl, InputIterator first, InputIterator last, OutputIterator result, UnaryFunction unary_op, BinaryFunction binary_op)
 transform_inclusive_scan performs, on a sequence, the transformation defined by a unary operator, then the inclusive scan defined by a binary operator.
 
template<typename InputIterator , typename OutputIterator , typename UnaryFunction , typename BinaryFunction >
OutputIterator transform_inclusive_scan (InputIterator first, InputIterator last, OutputIterator result, UnaryFunction unary_op, BinaryFunction binary_op)
 
template<typename InputIterator , typename OutputIterator , typename UnaryFunction , typename T , typename BinaryFunction >
OutputIterator transform_exclusive_scan (control &ctl, InputIterator first, InputIterator last, OutputIterator result, UnaryFunction unary_op, T init, BinaryFunction binary_op)
 transform_exclusive_scan performs, on a sequence, the transformation defined by a unary operator, then the exclusive scan defined by a binary operator.
 
template<typename InputIterator , typename OutputIterator , typename UnaryFunction , typename T , typename BinaryFunction >
OutputIterator transform_exclusive_scan (InputIterator first, InputIterator last, OutputIterator result, UnaryFunction unary_op, T init, BinaryFunction binary_op)
 
template<typename ForwardIterator >
ForwardIterator unique (control &ctl, ForwardIterator first, ForwardIterator last)
 
template<typename ForwardIterator >
ForwardIterator unique (ForwardIterator first, ForwardIterator last)
 
template<typename ForwardIterator , typename BinaryPredicate >
ForwardIterator unique (control &ctl, ForwardIterator first, ForwardIterator last, BinaryPredicate binary_pred)
 
template<typename ForwardIterator , typename BinaryPredicate >
ForwardIterator unique (ForwardIterator first, ForwardIterator last, BinaryPredicate binary_pred)
 
template<typename InputIterator , typename OutputIterator >
OutputIterator unique_copy (control &ctl, InputIterator first, InputIterator last, OutputIterator output)
 
template<typename InputIterator , typename OutputIterator >
OutputIterator unique_copy (InputIterator first, InputIterator last, OutputIterator output)
 
template<typename InputIterator , typename OutputIterator , typename BinaryPredicate >
OutputIterator unique_copy (control &ctl, InputIterator first, InputIterator last, OutputIterator output, BinaryPredicate binary_pred)
 
template<typename InputIterator , typename OutputIterator , typename BinaryPredicate >
OutputIterator unique_copy (InputIterator first, InputIterator last, OutputIterator output, BinaryPredicate binary_pred)
 
template<typename InputIterator , typename OutputIterator >
OutputIterator copy (bolt::amp::control &ctrl, InputIterator first, InputIterator last, OutputIterator result)
 
template<typename InputIterator , typename Size , typename OutputIterator >
OutputIterator copy_n (bolt::amp::control &ctrl, InputIterator first, Size n, OutputIterator result)
 
template<typename InputIterator , typename OutputIterator , typename Predicate >
OutputIterator copy_if (bolt::amp::control &ctrl, InputIterator first, InputIterator last, OutputIterator result, Predicate pred)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename Predicate >
OutputIterator copy_if (bolt::amp::control &ctrl, InputIterator1 first, InputIterator1 last, InputIterator2 stencil, OutputIterator result, Predicate pred)
 
template<typename ForwardIterator , typename T >
void fill (bolt::amp::control &ctl, ForwardIterator first, ForwardIterator last, const T &value)
 
template<typename OutputIterator , typename Size , typename T >
OutputIterator fill_n (bolt::amp::control &ctl, OutputIterator first, Size n, const T &value)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
void gather (bolt::amp::control &ctl, InputIterator1 map_first, InputIterator1 map_last, InputIterator2 input, OutputIterator result)
 
template<typename Predicate >
bolt::amp::unary_negate
< Predicate > 		not1 (const Predicate &pred)
 
template<unsigned int N, typename T1 , typename T2 >
tuple_element< N, pair< T1, T2 >
>::type & 		get (pair< T1, T2 > &p)
 
template<unsigned int N, typename T1 , typename T2 >
const tuple_element< N, pair
< T1, T2 > >::type & 		get (const pair< T1, T2 > &p)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
void scatter (bolt::amp::control &ctl, InputIterator1 first1, InputIterator1 last1, InputIterator2 map, OutputIterator result)
 
template<typename Predicate >
bolt::amp::binary_negate
< Predicate > 		not2 (const Predicate &pred)
 
template<typename Iterator >
Iterator create_mapped_iterator (bolt::amp::permutation_iterator_tag, Iterator first1, int sz, bool var,::bolt::amp::control &ctl)
 
template<typename Iterator >
Iterator create_mapped_iterator (bolt::amp::transform_iterator_tag, Iterator first1, int sz, bool var,::bolt::amp::control &ctl)
 
template<typename Iterator >
bolt::amp::device_vector
< typename
Iterator::value_type >
::iterator 		create_mapped_iterator (bolt::amp::device_vector_tag, Iterator itr, int sz, bool var,::bolt::amp::control &ctl)
 
template<typename Iterator >
bolt::amp::device_vector
< typename
Iterator::value_type >
::iterator 		create_mapped_iterator (std::random_access_iterator_tag, Iterator first1, int sz, bool var,::bolt::amp::control &ctl)
 
template<typename T >
bolt::amp::device_vector< T >
::iterator 		create_mapped_iterator (std::random_access_iterator_tag, T *first1, int sz, bool var,::bolt::amp::control &ctl)
 
template<typename Iterator >
const constant_iterator
< typename
Iterator::value_type > 		create_mapped_iterator (bolt::amp::constant_iterator_tag, Iterator itr, int sz, bool var,::bolt::amp::control &ctl)
 
template<typename Iterator >
const counting_iterator
< typename
Iterator::value_type > 		create_mapped_iterator (bolt::amp::counting_iterator_tag, Iterator itr, int sz, bool var,::bolt::amp::control &ctl)
 
template<typename Iterator >
Iterator create_mapped_iterator (bolt::amp::transform_iterator_tag, bolt::amp::control &ctl, Iterator &itr)
 
template<typename Iterator >
Iterator create_mapped_iterator (bolt::amp::permutation_iterator_tag, bolt::amp::control &ctl, Iterator &itr)
 
template<typename T >
T * create_mapped_iterator (std::random_access_iterator_tag, bolt::amp::control &ctl, T *first1)
 
template<typename Iterator >
std::vector< typename
Iterator::value_type >
::iterator 		create_mapped_iterator (std::random_access_iterator_tag, bolt::amp::control &ctl, Iterator &itr)
 
template<typename Iterator >
std::iterator_traits< Iterator >
::value_type * 		create_mapped_iterator (bolt::amp::device_vector_tag, bolt::amp::control &ctl, Iterator &itr)
 
template<typename Iterator >
const constant_iterator
< typename
Iterator::value_type > & 		create_mapped_iterator (bolt::amp::constant_iterator_tag, bolt::amp::control &ctl, Iterator &itr)
 
template<typename Iterator >
const counting_iterator
< typename
Iterator::value_type > & 		create_mapped_iterator (bolt::amp::counting_iterator_tag, bolt::amp::control &ctl, Iterator &itr)
 
template<typename Type >
constant_iterator< Type > make_constant_iterator (Type constValue)
 
template<typename Type >
counting_iterator< Type > make_counting_iterator (Type initValue)
 
template<typename valueType , typename keyType >
permutation_iterator
< valueType, keyType > 		make_permutation_iterator (valueType value, keyType key)
 
template<class UnaryFunc , class Iterator >
transform_iterator< UnaryFunc,
Iterator > 		make_transform_iterator (Iterator iter, UnaryFunc func)
 

Detailed Description

Namespace containing AMP related data types and functions.

Function Documentation

void bolt::amp::getVersion ( unsigned int &  major,
unsigned int &  minor,
unsigned int &  patch 
)

Query the Bolt library for version information.

Return the major, minor and patch version numbers associated with the Bolt library

Parameters
[out]majorMajor functionality change
[out]minorMinor functionality change
[out]patchBug fixes, documentation changes, no new features introduced
Generated on Wed Nov 26 2014 18:38:34 for Bolt by   doxygen 1.8.3