PageRenderTime 25ms CodeModel.GetById 7ms app.highlight 15ms RepoModel.GetById 2ms app.codeStats 0ms

/Src/Dependencies/Boost/libs/phoenix/test/algorithm/transformation4.cpp

http://hadesmem.googlecode.com/
C++ | 159 lines | 135 code | 17 blank | 7 comment | 8 complexity | afb7a381a3d83dd373760d8964e804c7 MD5 | raw file
  1/*=============================================================================
  2    Copyright (c) 2005-2007 Dan Marsden
  3    Copyright (c) 2005-2007 Joel de Guzman
  4
  5    Distributed under the Boost Software License, Version 1.0. (See accompanying 
  6    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  7==============================================================================*/
  8
  9#include <boost/phoenix/core.hpp>
 10#include <boost/phoenix/stl/algorithm/transformation.hpp>
 11#include <boost/detail/lightweight_test.hpp>
 12
 13#include <vector>
 14#include <functional>
 15#include <algorithm>
 16
 17namespace
 18{
 19    void heap_test()
 20    {
 21        using boost::phoenix::make_heap;
 22        using boost::phoenix::pop_heap;
 23        using boost::phoenix::push_heap;
 24        using boost::phoenix::sort_heap;
 25        using boost::phoenix::arg_names::arg1;
 26        int array[] = {1,2,3};
 27        std::vector<int> vec(array, array + 3);
 28        boost::phoenix::make_heap(arg1)(vec);
 29        vec.push_back(5);
 30        boost::phoenix::push_heap(arg1)(vec);
 31        vec.push_back(4);
 32        boost::phoenix::push_heap(arg1)(vec);
 33        boost::phoenix::pop_heap(arg1)(vec);
 34        BOOST_TEST(vec.back() == 5);
 35        vec.pop_back();
 36        boost::phoenix::sort_heap(arg1)(vec);
 37        int expected_result[] = {1,2,3,4};
 38        BOOST_TEST(std::equal(vec.begin(), vec.end(), expected_result));
 39
 40        int array2[] = {3,2,1};
 41        std::vector<int> vec2(array2, array2 + 3);
 42        boost::phoenix::make_heap(arg1, std::greater<int>())(vec2);
 43        vec2.push_back(5);
 44        boost::phoenix::push_heap(arg1, std::greater<int>())(vec2);
 45        vec2.push_back(4);
 46        boost::phoenix::push_heap(arg1, std::greater<int>())(vec2);
 47        boost::phoenix::pop_heap(arg1, std::greater<int>())(vec2);
 48        BOOST_TEST(vec2.back() == 1);
 49        vec2.pop_back();
 50        boost::phoenix::sort_heap(arg1, std::greater<int>())(vec2);
 51        int expected_result2[] = {5,4,3,2};
 52        BOOST_TEST(std::equal(vec2.begin(), vec2.end(), expected_result2));
 53
 54        return;
 55    }
 56
 57    void next_permutation_test()
 58    {
 59        using boost::phoenix::next_permutation;
 60        using boost::phoenix::arg_names::arg1;
 61        int array[] = {1,2};
 62        int expected_result[] = {2,1};
 63        int expected_result2[] = {1,2};
 64
 65        BOOST_TEST(next_permutation(arg1)(array));
 66        BOOST_TEST(std::equal(array, array + 2, expected_result));
 67        BOOST_TEST(!next_permutation(arg1)(array));
 68        BOOST_TEST(std::equal(array, array + 2, expected_result2));
 69
 70        std::reverse(array, array + 2);
 71        BOOST_TEST(boost::phoenix::next_permutation(arg1, std::greater<int>())(array));
 72        BOOST_TEST(std::equal(array, array + 2, expected_result2));
 73        BOOST_TEST(!boost::phoenix::next_permutation(arg1, std::greater<int>())(array));
 74        BOOST_TEST(std::equal(array, array + 2, expected_result));
 75        return;
 76    }
 77
 78    void prev_permutation_test()
 79    {
 80        using boost::phoenix::prev_permutation;
 81        using boost::phoenix::arg_names::arg1;
 82        int array[] = {2,1};
 83        int expected_result[] = {1,2};
 84        int expected_result2[] = {2,1};
 85
 86        BOOST_TEST(prev_permutation(arg1)(array));
 87        BOOST_TEST(std::equal(array, array + 2, expected_result));
 88        BOOST_TEST(!prev_permutation(arg1)(array));
 89        BOOST_TEST(std::equal(array, array + 2, expected_result2));
 90
 91        std::reverse(array, array + 2);
 92        BOOST_TEST(boost::phoenix::prev_permutation(arg1, std::greater<int>())(array));
 93        BOOST_TEST(std::equal(array, array + 2, expected_result2));
 94        BOOST_TEST(!boost::phoenix::prev_permutation(arg1, std::greater<int>())(array));
 95        BOOST_TEST(std::equal(array, array + 2, expected_result));
 96        return;
 97    }
 98
 99    void inner_product_test()
100    {
101        using boost::phoenix::inner_product;
102        using boost::phoenix::arg_names::arg1;
103        using boost::phoenix::arg_names::arg2;
104        int lhs[] = {1,2,3};
105        int rhs[] = {4,5,6};
106        BOOST_TEST(inner_product(arg1, arg2, 0)
107                   (lhs, rhs) == 1*4 + 2*5 + 3*6);
108        BOOST_TEST(boost::phoenix::inner_product(arg1, arg2, 1, std::multiplies<int>(), std::minus<int>())
109                   (lhs, rhs) == (1 - 4) * (2 - 5) * (3 - 6));
110        return;
111    }
112
113    void partial_sum_test()
114    {
115        using boost::phoenix::partial_sum;
116        using boost::phoenix::arg_names::arg1;
117        using boost::phoenix::arg_names::arg2;
118        int array[] = {1,2,3};
119        int output[3];
120        BOOST_TEST(partial_sum(arg1, arg2)(array, output) == output + 3);
121        int expected_result[] = {1, 3, 6};
122        BOOST_TEST(std::equal(output, output + 3, expected_result));
123
124        BOOST_TEST(boost::phoenix::partial_sum(arg1, arg2, std::multiplies<int>())
125                   (array, output) == output + 3);
126        int expected_result2[] = {1, 2, 6};
127        BOOST_TEST(std::equal(output, output + 3, expected_result2));
128        return;
129    }
130
131    void adjacent_difference_test()
132    {
133        using boost::phoenix::adjacent_difference;
134        using boost::phoenix::arg_names::arg1;
135        using boost::phoenix::arg_names::arg2;
136        int array[] = {1,2,3};
137        int output[3];
138        BOOST_TEST(adjacent_difference(arg1, arg2)(array, output) == output + 3);
139        int expected_result[] = {1, 1, 1};
140        BOOST_TEST(std::equal(output, output + 3, expected_result));
141        BOOST_TEST(boost::phoenix::adjacent_difference(arg1, arg2, std::plus<int>())
142                   (array, output) == output + 3);
143        int expected_result2[] = {1, 3, 5};
144        BOOST_TEST(std::equal(output, output + 3, expected_result2));
145        return;
146    }
147
148}
149
150int main()
151{
152    heap_test();
153    next_permutation_test();
154    prev_permutation_test();
155    inner_product_test();
156    partial_sum_test();
157    adjacent_difference_test();
158    return boost::report_errors();
159}