summaryrefslogtreecommitdiffstats
path: root/src/boost/libs/compute/test/test_lambda.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/boost/libs/compute/test/test_lambda.cpp')
-rw-r--r--src/boost/libs/compute/test/test_lambda.cpp617
1 files changed, 617 insertions, 0 deletions
diff --git a/src/boost/libs/compute/test/test_lambda.cpp b/src/boost/libs/compute/test/test_lambda.cpp
new file mode 100644
index 00000000..5fa72ac3
--- /dev/null
+++ b/src/boost/libs/compute/test/test_lambda.cpp
@@ -0,0 +1,617 @@
+//---------------------------------------------------------------------------//
+// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com>
+//
+// Distributed under the Boost Software License, Version 1.0
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+//
+// See http://boostorg.github.com/compute for more information.
+//---------------------------------------------------------------------------//
+
+#define BOOST_TEST_MODULE TestLambda
+#include <boost/test/unit_test.hpp>
+
+#include <boost/tuple/tuple_io.hpp>
+#include <boost/tuple/tuple_comparison.hpp>
+
+#include <boost/compute/function.hpp>
+#include <boost/compute/lambda.hpp>
+#include <boost/compute/algorithm/copy_n.hpp>
+#include <boost/compute/algorithm/for_each.hpp>
+#include <boost/compute/algorithm/transform.hpp>
+#include <boost/compute/container/vector.hpp>
+#include <boost/compute/functional/bind.hpp>
+#include <boost/compute/iterator/zip_iterator.hpp>
+#include <boost/compute/types/pair.hpp>
+#include <boost/compute/types/tuple.hpp>
+
+#include "check_macros.hpp"
+#include "quirks.hpp"
+#include "context_setup.hpp"
+
+namespace bc = boost::compute;
+namespace compute = boost::compute;
+
+BOOST_AUTO_TEST_CASE(squared_plus_one)
+{
+ bc::vector<int> vector(context);
+ vector.push_back(1, queue);
+ vector.push_back(2, queue);
+ vector.push_back(3, queue);
+ vector.push_back(4, queue);
+ vector.push_back(5, queue);
+
+ // multiply each value by itself and add one
+ bc::transform(vector.begin(),
+ vector.end(),
+ vector.begin(),
+ (bc::_1 * bc::_1) + 1,
+ queue);
+ CHECK_RANGE_EQUAL(int, 5, vector, (2, 5, 10, 17, 26));
+}
+
+BOOST_AUTO_TEST_CASE(abs_int)
+{
+ bc::vector<int> vector(context);
+ vector.push_back(-1, queue);
+ vector.push_back(-2, queue);
+ vector.push_back(3, queue);
+ vector.push_back(-4, queue);
+ vector.push_back(5, queue);
+
+ bc::transform(vector.begin(),
+ vector.end(),
+ vector.begin(),
+ abs(bc::_1),
+ queue);
+ CHECK_RANGE_EQUAL(int, 5, vector, (1, 2, 3, 4, 5));
+}
+
+template<class Result, class Expr>
+void check_lambda_result(const Expr &)
+{
+ BOOST_STATIC_ASSERT((
+ boost::is_same<
+ typename ::boost::compute::lambda::result_of<Expr>::type,
+ Result
+ >::value
+ ));
+}
+
+template<class Result, class Expr, class Arg1>
+void check_lambda_result(const Expr &, const Arg1 &)
+{
+ BOOST_STATIC_ASSERT((
+ boost::is_same<
+ typename ::boost::compute::lambda::result_of<
+ Expr,
+ typename boost::tuple<Arg1>
+ >::type,
+ Result
+ >::value
+ ));
+}
+
+template<class Result, class Expr, class Arg1, class Arg2>
+void check_lambda_result(const Expr &, const Arg1 &, const Arg2 &)
+{
+ BOOST_STATIC_ASSERT((
+ boost::is_same<
+ typename ::boost::compute::lambda::result_of<
+ Expr,
+ typename boost::tuple<Arg1, Arg2>
+ >::type,
+ Result
+ >::value
+ ));
+}
+
+template<class Result, class Expr, class Arg1, class Arg2, class Arg3>
+void check_lambda_result(const Expr &, const Arg1 &, const Arg2 &, const Arg3 &)
+{
+ BOOST_STATIC_ASSERT((
+ boost::is_same<
+ typename ::boost::compute::lambda::result_of<
+ Expr,
+ typename boost::tuple<Arg1, Arg2, Arg3>
+ >::type,
+ Result
+ >::value
+ ));
+}
+
+BOOST_AUTO_TEST_CASE(result_of)
+{
+ using ::boost::compute::lambda::_1;
+ using ::boost::compute::lambda::_2;
+ using ::boost::compute::lambda::_3;
+
+ namespace proto = ::boost::proto;
+
+ using boost::compute::int_;
+
+ check_lambda_result<int_>(proto::lit(1));
+ check_lambda_result<int_>(proto::lit(1) + 2);
+ check_lambda_result<float>(proto::lit(1.2f));
+ check_lambda_result<float>(proto::lit(1) + 1.2f);
+ check_lambda_result<float>(proto::lit(1) / 2 + 1.2f);
+
+ using boost::compute::float4_;
+ using boost::compute::int4_;
+
+ check_lambda_result<int_>(_1, int_(1));
+ check_lambda_result<float>(_1, float(1.2f));
+ check_lambda_result<float4_>(_1, float4_(1, 2, 3, 4));
+ check_lambda_result<float4_>(2.0f * _1, float4_(1, 2, 3, 4));
+ check_lambda_result<float4_>(_1 * 2.0f, float4_(1, 2, 3, 4));
+
+ check_lambda_result<float>(dot(_1, _2), float4_(0, 1, 2, 3), float4_(3, 2, 1, 0));
+ check_lambda_result<float>(dot(_1, float4_(3, 2, 1, 0)), float4_(0, 1, 2, 3));
+ check_lambda_result<float>(distance(_1, _2), float4_(0, 1, 2, 3), float4_(3, 2, 1, 0));
+ check_lambda_result<float>(distance(_1, float4_(3, 2, 1, 0)), float4_(0, 1, 2, 3));
+
+ check_lambda_result<float>(length(_1), float4_(3, 2, 1, 0));
+
+ check_lambda_result<float4_>(cross(_1, _2), float4_(0, 1, 2, 3), float4_(3, 2, 1, 0));
+ check_lambda_result<float4_>(cross(_1, float4_(3, 2, 1, 0)), float4_(0, 1, 2, 3));
+
+ check_lambda_result<float4_>(max(_1, _2), float4_(3, 2, 1, 0), float4_(0, 1, 2, 3));
+ check_lambda_result<float4_>(max(_1, float(1.0f)), float4_(0, 1, 2, 3));
+ check_lambda_result<int4_>(max(_1, int4_(3, 2, 1, 0)), int4_(0, 1, 2, 3));
+ check_lambda_result<int4_>(max(_1, int_(1)), int4_(0, 1, 2, 3));
+ check_lambda_result<float4_>(min(_1, float4_(3, 2, 1, 0)), float4_(0, 1, 2, 3));
+
+ check_lambda_result<float4_>(step(_1, _2), float4_(3, 2, 1, 0), float4_(0, 1, 2, 3));
+ check_lambda_result<int4_>(step(_1, _2), float(3.0f), int4_(0, 1, 2, 3));
+
+ check_lambda_result<float4_>(
+ smoothstep(_1, _2, _3),
+ float4_(3, 2, 1, 0), float4_(3, 2, 1, 0), float4_(0, 1, 2, 3)
+ );
+ check_lambda_result<int4_>(
+ smoothstep(_1, _2, _3),
+ float(2.0f), float(3.0f), int4_(0, 1, 2, 3)
+ );
+
+ check_lambda_result<int4_>(bc::lambda::isinf(_1), float4_(0, 1, 2, 3));
+
+ check_lambda_result<int>(_1 + 2, int(2));
+ check_lambda_result<float>(_1 + 2, float(2.2f));
+
+ check_lambda_result<int>(_1 + _2, int(1), int(2));
+ check_lambda_result<float>(_1 + _2, int(1), float(2.2f));
+
+ check_lambda_result<int>(_1 + _1, int(1));
+ check_lambda_result<float>(_1 * _1, float(1));
+
+ using boost::compute::lambda::get;
+
+ check_lambda_result<float>(get<0>(_1), float4_(1, 2, 3, 4));
+ check_lambda_result<bool>(get<0>(_1) < 1.f, float4_(1, 2, 3, 4));
+ check_lambda_result<bool>(_1 < 1.f, float(2));
+
+ using boost::compute::lambda::make_pair;
+
+ check_lambda_result<int>(get<0>(make_pair(_1, _2)), int(1), float(1.2f));
+ check_lambda_result<float>(get<1>(make_pair(_1, _2)), int(1), float(1.2f));
+ check_lambda_result<std::pair<int, float> >(make_pair(_1, _2), int(1), float(1.2f));
+
+ using boost::compute::lambda::make_tuple;
+
+ check_lambda_result<boost::tuple<int> >(make_tuple(_1), int(1));
+ check_lambda_result<boost::tuple<int, float> >(make_tuple(_1, _2), int(1), float(1.2f));
+ check_lambda_result<boost::tuple<int, int> >(make_tuple(_1, _1), int(1));
+ check_lambda_result<boost::tuple<int, float> >(make_tuple(_1, _2), int(1), float(1.4f));
+ check_lambda_result<boost::tuple<char, int, float> >(
+ make_tuple(_1, _2, _3), char('a'), int(2), float(3.4f)
+ );
+ check_lambda_result<boost::tuple<int, int, int> >(
+ make_tuple(_1, _1, _1), int(1), float(1.4f)
+ );
+ check_lambda_result<boost::tuple<int, float, int, float, int> >(
+ make_tuple(_1, _2, _1, _2, _1), int(1), float(1.4f)
+ );
+}
+
+BOOST_AUTO_TEST_CASE(make_function_from_lamdba)
+{
+ using boost::compute::lambda::_1;
+
+ int data[] = { 2, 4, 6, 8, 10 };
+ compute::vector<int> vector(data, data + 5, queue);
+
+ compute::function<int(int)> f = _1 * 2 + 3;
+
+ compute::transform(
+ vector.begin(), vector.end(), vector.begin(), f, queue
+ );
+ CHECK_RANGE_EQUAL(int, 5, vector, (7, 11, 15, 19, 23));
+}
+
+BOOST_AUTO_TEST_CASE(make_function_from_binary_lamdba)
+{
+ using boost::compute::lambda::_1;
+ using boost::compute::lambda::_2;
+ using boost::compute::lambda::abs;
+
+ int data1[] = { 2, 4, 6, 8, 10 };
+ int data2[] = { 10, 8, 6, 4, 2 };
+ compute::vector<int> vec1(data1, data1 + 5, queue);
+ compute::vector<int> vec2(data2, data2 + 5, queue);
+ compute::vector<int> result(5, context);
+
+ compute::function<int(int, int)> f = abs(_1 - _2);
+
+ compute::transform(
+ vec1.begin(), vec1.end(), vec2.begin(), result.begin(), f, queue
+ );
+ CHECK_RANGE_EQUAL(int, 5, result, (8, 4, 0, 4, 8));
+}
+
+BOOST_AUTO_TEST_CASE(lambda_binary_function_with_pointer_modf)
+{
+ using boost::compute::lambda::_1;
+ using boost::compute::lambda::_2;
+ using boost::compute::lambda::abs;
+
+ bc::float_ data1[] = { 2.2f, 4.2f, 6.3f, 8.3f, 10.2f };
+ compute::vector<bc::float_> vec1(data1, data1 + 5, queue);
+ compute::vector<bc::float_> vec2(size_t(5), context);
+ compute::vector<bc::float_> result(5, context);
+
+ compute::transform(
+ bc::make_transform_iterator(vec1.begin(), _1 + 0.01f),
+ bc::make_transform_iterator(vec1.end(), _1 + 0.01f),
+ vec2.begin(),
+ result.begin(),
+ bc::lambda::modf(_1, _2),
+ queue
+ );
+ CHECK_RANGE_CLOSE(bc::float_, 5, result, (0.21f, 0.21f, 0.31f, 0.31f, 0.21f), 0.01f);
+ CHECK_RANGE_CLOSE(bc::float_, 5, vec2, (2, 4, 6, 8, 10), 0.01f);
+}
+
+BOOST_AUTO_TEST_CASE(lambda_tenary_function_with_pointer_remquo)
+{
+ if(!has_remquo_func(device))
+ {
+ return;
+ }
+
+ using boost::compute::lambda::_1;
+ using boost::compute::lambda::_2;
+ using boost::compute::lambda::get;
+
+ bc::float_ data1[] = { 2.2f, 4.2f, 6.3f, 8.3f, 10.2f };
+ bc::float_ data2[] = { 4.4f, 4.2f, 6.3f, 16.6f, 10.2f };
+ compute::vector<bc::float_> vec1(data1, data1 + 5, queue);
+ compute::vector<bc::float_> vec2(data2, data2 + 5, queue);
+ compute::vector<bc::int_> vec3(size_t(5), context);
+ compute::vector<bc::float_> result(5, context);
+
+ compute::transform(
+ compute::make_zip_iterator(
+ boost::make_tuple(vec1.begin(), vec2.begin(), vec3.begin())
+ ),
+ compute::make_zip_iterator(
+ boost::make_tuple(vec1.end(), vec2.end(), vec3.end())
+ ),
+ result.begin(),
+ bc::lambda::remquo(get<0>(_1), get<1>(_1), get<2>(_1)),
+ queue
+ );
+ CHECK_RANGE_CLOSE(bc::float_, 5, result, (2.2f, 0.0f, 0.0f, 8.3f, 0.0f), 0.01f);
+ CHECK_RANGE_EQUAL(bc::int_, 5, vec3, (0, 1, 1, 0, 1));
+}
+
+BOOST_AUTO_TEST_CASE(lambda_get_vector)
+{
+ using boost::compute::_1;
+ using boost::compute::int2_;
+ using boost::compute::lambda::get;
+
+ int data[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
+ compute::vector<int2_> vector(4, context);
+
+ compute::copy(
+ reinterpret_cast<int2_ *>(data),
+ reinterpret_cast<int2_ *>(data) + 4,
+ vector.begin(),
+ queue
+ );
+
+ // extract first component of each vector
+ compute::vector<int> first_component(4, context);
+ compute::transform(
+ vector.begin(),
+ vector.end(),
+ first_component.begin(),
+ get<0>(_1),
+ queue
+ );
+ CHECK_RANGE_EQUAL(int, 4, first_component, (1, 3, 5, 7));
+
+ // extract second component of each vector
+ compute::vector<int> second_component(4, context);
+ compute::transform(
+ vector.begin(),
+ vector.end(),
+ first_component.begin(),
+ get<1>(_1),
+ queue
+ );
+ CHECK_RANGE_EQUAL(int, 4, first_component, (2, 4, 6, 8));
+}
+
+BOOST_AUTO_TEST_CASE(lambda_get_pair)
+{
+ using boost::compute::_1;
+ using boost::compute::lambda::get;
+
+ compute::vector<std::pair<int, float> > vector(context);
+ vector.push_back(std::make_pair(1, 1.2f), queue);
+ vector.push_back(std::make_pair(3, 3.4f), queue);
+ vector.push_back(std::make_pair(5, 5.6f), queue);
+ vector.push_back(std::make_pair(7, 7.8f), queue);
+
+ // extract first compoenent of each pair
+ compute::vector<int> first_component(4, context);
+ compute::transform(
+ vector.begin(),
+ vector.end(),
+ first_component.begin(),
+ get<0>(_1),
+ queue
+ );
+ CHECK_RANGE_EQUAL(int, 4, first_component, (1, 3, 5, 7));
+
+ // extract second compoenent of each pair
+ compute::vector<float> second_component(4, context);
+ compute::transform(
+ vector.begin(),
+ vector.end(),
+ second_component.begin(),
+ get<1>(_1),
+ queue
+ );
+ CHECK_RANGE_EQUAL(float, 4, second_component, (1.2f, 3.4f, 5.6f, 7.8f));
+}
+
+BOOST_AUTO_TEST_CASE(lambda_get_tuple)
+{
+ using boost::compute::_1;
+ using boost::compute::lambda::get;
+
+ compute::vector<boost::tuple<int, char, float> > vector(context);
+
+ vector.push_back(boost::make_tuple(1, 'a', 1.2f), queue);
+ vector.push_back(boost::make_tuple(3, 'b', 3.4f), queue);
+ vector.push_back(boost::make_tuple(5, 'c', 5.6f), queue);
+ vector.push_back(boost::make_tuple(7, 'd', 7.8f), queue);
+
+ // extract first component of each tuple
+ compute::vector<int> first_component(4, context);
+ compute::transform(
+ vector.begin(),
+ vector.end(),
+ first_component.begin(),
+ get<0>(_1),
+ queue
+ );
+ CHECK_RANGE_EQUAL(int, 4, first_component, (1, 3, 5, 7));
+
+ // extract second component of each tuple
+ compute::vector<char> second_component(4, context);
+ compute::transform(
+ vector.begin(),
+ vector.end(),
+ second_component.begin(),
+ get<1>(_1),
+ queue
+ );
+ CHECK_RANGE_EQUAL(char, 4, second_component, ('a', 'b', 'c', 'd'));
+
+ // extract third component of each tuple
+ compute::vector<float> third_component(4, context);
+ compute::transform(
+ vector.begin(),
+ vector.end(),
+ third_component.begin(),
+ get<2>(_1),
+ queue
+ );
+ CHECK_RANGE_EQUAL(float, 4, third_component, (1.2f, 3.4f, 5.6f, 7.8f));
+}
+
+BOOST_AUTO_TEST_CASE(lambda_get_zip_iterator)
+{
+ using boost::compute::_1;
+ using boost::compute::lambda::get;
+
+ float data[] = { 1.2f, 2.3f, 3.4f, 4.5f, 5.6f, 6.7f, 7.8f, 9.0f };
+ compute::vector<float> input(8, context);
+ compute::copy(data, data + 8, input.begin(), queue);
+
+ compute::vector<float> output(8, context);
+
+ compute::for_each(
+ compute::make_zip_iterator(
+ boost::make_tuple(input.begin(), output.begin())
+ ),
+ compute::make_zip_iterator(
+ boost::make_tuple(input.end(), output.end())
+ ),
+ get<1>(_1) = get<0>(_1),
+ queue
+ );
+ CHECK_RANGE_EQUAL(float, 8, output,
+ (1.2f, 2.3f, 3.4f, 4.5f, 5.6f, 6.7f, 7.8f, 9.0f)
+ );
+}
+
+BOOST_AUTO_TEST_CASE(lambda_make_pair)
+{
+ using boost::compute::_1;
+ using boost::compute::_2;
+ using boost::compute::lambda::make_pair;
+
+ int int_data[] = { 1, 3, 5, 7 };
+ float float_data[] = { 1.2f, 2.3f, 3.4f, 4.5f };
+
+ compute::vector<int> int_vector(int_data, int_data + 4, queue);
+ compute::vector<float> float_vector(float_data, float_data + 4, queue);
+ compute::vector<std::pair<int, float> > output_vector(4, context);
+
+ compute::transform(
+ int_vector.begin(),
+ int_vector.end(),
+ float_vector.begin(),
+ output_vector.begin(),
+ make_pair(_1 - 1, 0 - _2),
+ queue
+ );
+
+ std::vector<std::pair<int, float> > host_vector(4);
+ compute::copy_n(output_vector.begin(), 4, host_vector.begin(), queue);
+ BOOST_CHECK(host_vector[0] == std::make_pair(0, -1.2f));
+ BOOST_CHECK(host_vector[1] == std::make_pair(2, -2.3f));
+ BOOST_CHECK(host_vector[2] == std::make_pair(4, -3.4f));
+ BOOST_CHECK(host_vector[3] == std::make_pair(6, -4.5f));
+}
+
+BOOST_AUTO_TEST_CASE(lambda_make_tuple)
+{
+ using boost::compute::_1;
+ using boost::compute::lambda::get;
+ using boost::compute::lambda::make_tuple;
+
+ std::vector<boost::tuple<int, float> > data;
+ data.push_back(boost::make_tuple(2, 1.2f));
+ data.push_back(boost::make_tuple(4, 2.4f));
+ data.push_back(boost::make_tuple(6, 4.6f));
+ data.push_back(boost::make_tuple(8, 6.8f));
+
+ compute::vector<boost::tuple<int, float> > input_vector(4, context);
+ compute::copy(data.begin(), data.end(), input_vector.begin(), queue);
+
+ // reverse the elements in the tuple
+ compute::vector<boost::tuple<float, int> > output_vector(4, context);
+
+ compute::transform(
+ input_vector.begin(),
+ input_vector.end(),
+ output_vector.begin(),
+ make_tuple(get<1>(_1), get<0>(_1)),
+ queue
+ );
+
+ std::vector<boost::tuple<float, int> > host_vector(4);
+ compute::copy_n(output_vector.begin(), 4, host_vector.begin(), queue);
+ BOOST_CHECK_EQUAL(host_vector[0], boost::make_tuple(1.2f, 2));
+ BOOST_CHECK_EQUAL(host_vector[1], boost::make_tuple(2.4f, 4));
+ BOOST_CHECK_EQUAL(host_vector[2], boost::make_tuple(4.6f, 6));
+ BOOST_CHECK_EQUAL(host_vector[3], boost::make_tuple(6.8f, 8));
+
+ // duplicate each element in the tuple
+ compute::vector<boost::tuple<int, int, float, float> > doubled_vector(4, context);
+ compute::transform(
+ input_vector.begin(),
+ input_vector.end(),
+ doubled_vector.begin(),
+ make_tuple(get<0>(_1), get<0>(_1), get<1>(_1), get<1>(_1)),
+ queue
+ );
+
+ std::vector<boost::tuple<int, int, float, float> > doubled_host_vector(4);
+ compute::copy_n(doubled_vector.begin(), 4, doubled_host_vector.begin(), queue);
+ BOOST_CHECK_EQUAL(doubled_host_vector[0], boost::make_tuple(2, 2, 1.2f, 1.2f));
+ BOOST_CHECK_EQUAL(doubled_host_vector[1], boost::make_tuple(4, 4, 2.4f, 2.4f));
+ BOOST_CHECK_EQUAL(doubled_host_vector[2], boost::make_tuple(6, 6, 4.6f, 4.6f));
+ BOOST_CHECK_EQUAL(doubled_host_vector[3], boost::make_tuple(8, 8, 6.8f, 6.8f));
+}
+
+BOOST_AUTO_TEST_CASE(bind_lambda_function)
+{
+ using compute::placeholders::_1;
+ namespace lambda = compute::lambda;
+
+ int data[] = { 1, 2, 3, 4 };
+ compute::vector<int> vector(data, data + 4, queue);
+
+ compute::transform(
+ vector.begin(), vector.end(), vector.begin(),
+ compute::bind(lambda::_1 * lambda::_2, _1, 2),
+ queue
+ );
+ CHECK_RANGE_EQUAL(int, 4, vector, (2, 4, 6, 8));
+}
+
+BOOST_AUTO_TEST_CASE(lambda_function_with_uint_args)
+{
+ compute::uint_ host_data[] = { 1, 3, 5, 7, 9 };
+ compute::vector<compute::uint_> device_vector(host_data, host_data + 5, queue);
+
+ using boost::compute::lambda::clamp;
+ using compute::lambda::_1;
+
+ compute::transform(
+ device_vector.begin(), device_vector.end(),
+ device_vector.begin(),
+ clamp(_1, compute::uint_(4), compute::uint_(6)),
+ queue
+ );
+ CHECK_RANGE_EQUAL(compute::uint_, 5, device_vector, (4, 4, 5, 6, 6));
+}
+
+BOOST_AUTO_TEST_CASE(lambda_function_with_short_args)
+{
+ compute::short_ host_data[] = { 1, 3, 5, 7, 9 };
+ compute::vector<compute::short_> device_vector(host_data, host_data + 5, queue);
+
+ using boost::compute::lambda::clamp;
+ using compute::lambda::_1;
+
+ compute::transform(
+ device_vector.begin(), device_vector.end(),
+ device_vector.begin(),
+ clamp(_1, compute::short_(4), compute::short_(6)),
+ queue
+ );
+ CHECK_RANGE_EQUAL(compute::short_, 5, device_vector, (4, 4, 5, 6, 6));
+}
+
+BOOST_AUTO_TEST_CASE(lambda_function_with_uchar_args)
+{
+ compute::uchar_ host_data[] = { 1, 3, 5, 7, 9 };
+ compute::vector<compute::uchar_> device_vector(host_data, host_data + 5, queue);
+
+ using boost::compute::lambda::clamp;
+ using compute::lambda::_1;
+
+ compute::transform(
+ device_vector.begin(), device_vector.end(),
+ device_vector.begin(),
+ clamp(_1, compute::uchar_(4), compute::uchar_(6)),
+ queue
+ );
+ CHECK_RANGE_EQUAL(compute::uchar_, 5, device_vector, (4, 4, 5, 6, 6));
+}
+
+BOOST_AUTO_TEST_CASE(lambda_function_with_char_args)
+{
+ compute::char_ host_data[] = { 1, 3, 5, 7, 9 };
+ compute::vector<compute::char_> device_vector(host_data, host_data + 5, queue);
+
+ using boost::compute::lambda::clamp;
+ using compute::lambda::_1;
+
+ compute::transform(
+ device_vector.begin(), device_vector.end(),
+ device_vector.begin(),
+ clamp(_1, compute::char_(4), compute::char_(6)),
+ queue
+ );
+ CHECK_RANGE_EQUAL(compute::char_, 5, device_vector, (4, 4, 5, 6, 6));
+}
+
+BOOST_AUTO_TEST_SUITE_END()
generated by cgit v1.2.3 (git 2.39.1) at 2025-01-21 15:22:59 +0000