├── README.md
├── examples
    ├── MonteCarlo.cpp
    ├── README.md
    ├── blackscholes.cpp
    ├── find_if.cpp
    ├── histogram.cpp
    ├── palindrome.cpp
    ├── prime.cpp
    ├── sort.cpp
    ├── stable_sort.cpp
    ├── sum_reduction.cpp
    └── user_policies.cpp
├── include
    └── experimental
    │   ├── algorithm
    │   ├── bits
    │       └── parallel
    │       │   ├── algos
    │       │       ├── par
    │       │       │   ├── all_of.h
    │       │       │   ├── any_of.h
    │       │       │   ├── count.h
    │       │       │   ├── count_if.h
    │       │       │   ├── diffract.h
    │       │       │   ├── fill.h
    │       │       │   ├── fill_n.h
    │       │       │   ├── find.h
    │       │       │   ├── find_if.h
    │       │       │   ├── find_if_not.h
    │       │       │   ├── for_each.h
    │       │       │   ├── for_each_n.h
    │       │       │   ├── generate.h
    │       │       │   ├── generate_n.h
    │       │       │   ├── is_heap.h
    │       │       │   ├── is_heap_until.h
    │       │       │   ├── is_sorted.h
    │       │       │   ├── max_element.h
    │       │       │   ├── min_element.h
    │       │       │   ├── minmax_element.h
    │       │       │   ├── none_of.h
    │       │       │   ├── reduce.h
    │       │       │   ├── replace.h
    │       │       │   ├── replace_if.h
    │       │       │   ├── sort.h
    │       │       │   └── stable_sort.h
    │       │       └── seq
    │       │       │   ├── adjacent_difference.h
    │       │       │   ├── adjacent_find.h
    │       │       │   ├── all_of.h
    │       │       │   ├── any_of.h
    │       │       │   ├── copy.h
    │       │       │   ├── copy_if.h
    │       │       │   ├── copy_n.h
    │       │       │   ├── count.h
    │       │       │   ├── count_if.h
    │       │       │   ├── equal.h
    │       │       │   ├── exclusive_scan.h
    │       │       │   ├── fill.h
    │       │       │   ├── fill_n.h
    │       │       │   ├── find.h
    │       │       │   ├── find_end.h
    │       │       │   ├── find_first_of.h
    │       │       │   ├── find_if.h
    │       │       │   ├── find_if_not.h
    │       │       │   ├── for_each.h
    │       │       │   ├── for_each_n.h
    │       │       │   ├── generate.h
    │       │       │   ├── generate_n.h
    │       │       │   ├── includes.h
    │       │       │   ├── inclusive_scan.h
    │       │       │   ├── inner_product.h
    │       │       │   ├── inplace_merge.h
    │       │       │   ├── is_heap.h
    │       │       │   ├── is_heap_until.h
    │       │       │   ├── is_partitioned.h
    │       │       │   ├── is_sorted.h
    │       │       │   ├── is_sorted_until.h
    │       │       │   ├── lexicographical_compare.h
    │       │       │   ├── max_element.h
    │       │       │   ├── merge.h
    │       │       │   ├── min_element.h
    │       │       │   ├── minmax_element.h
    │       │       │   ├── mismatch.h
    │       │       │   ├── move.h
    │       │       │   ├── none_of.h
    │       │       │   ├── nth_element.h
    │       │       │   ├── partial_sort.h
    │       │       │   ├── partial_sort_copy.h
    │       │       │   ├── partition.h
    │       │       │   ├── partition_copy.h
    │       │       │   ├── partition_point.h
    │       │       │   ├── reduce.h
    │       │       │   ├── remove.h
    │       │       │   ├── remove_copy.h
    │       │       │   ├── remove_copy_if.h
    │       │       │   ├── remove_if.h
    │       │       │   ├── replace.h
    │       │       │   ├── replace_copy.h
    │       │       │   ├── replace_copy_if.h
    │       │       │   ├── replace_if.h
    │       │       │   ├── reverse.h
    │       │       │   ├── reverse_copy.h
    │       │       │   ├── rotate.h
    │       │       │   ├── rotate_copy.h
    │       │       │   ├── search.h
    │       │       │   ├── search_n.h
    │       │       │   ├── set_difference.h
    │       │       │   ├── set_intersection.h
    │       │       │   ├── set_symmetric_difference.h
    │       │       │   ├── set_union.h
    │       │       │   ├── sort.h
    │       │       │   ├── stable_partition.h
    │       │       │   ├── stable_sort.h
    │       │       │   ├── swap_ranges.h
    │       │       │   ├── transform.h
    │       │       │   ├── unique.h
    │       │       │   └── unique_copy.h
    │       │   ├── policy_dynamic.h
    │       │   ├── policy_parallel.h
    │       │   └── policy_sequential.h
    │   ├── execution_policy
    │   └── numeric
├── prototypes
    └── user_policy.cpp
└── test
    ├── CMakeLists.txt
    ├── README.md
    ├── alg.modifying.operations
        ├── alg.gen.copy
        │   ├── copy.cpp
        │   ├── copy_if.cpp
        │   └── copy_n.cpp
        ├── alg.gen.fill
        │   ├── fill.cpp
        │   └── fill_n.cpp
        ├── alg.gen.generate
        │   ├── generate.cpp
        │   └── generate_n.cpp
        ├── alg.gen.move
        │   └── move.cpp
        ├── alg.gen.partitions
        │   ├── is_partitioned.cpp
        │   ├── partition.cpp
        │   ├── partition_copy.cpp
        │   ├── partition_point.cpp
        │   └── stable_partition.cpp
        ├── alg.gen.remove
        │   ├── remove.cpp
        │   ├── remove_copy.cpp
        │   ├── remove_copy_if.cpp
        │   └── remove_if.cpp
        ├── alg.gen.replace
        │   ├── replace.cpp
        │   ├── replace_copy.cpp
        │   ├── replace_copy_if.cpp
        │   └── replace_if.cpp
        ├── alg.gen.reverse
        │   ├── reverse.cpp
        │   └── reverse_copy.cpp
        ├── alg.gen.rotate
        │   ├── rotate.cpp
        │   └── rotate_copy.cpp
        ├── alg.gen.swap
        │   └── swap_ranges.cpp
        ├── alg.gen.transform
        │   ├── binary_transform.cpp
        │   └── unary_transform.cpp
        ├── alg.gen.unique
        │   ├── unique.cpp
        │   └── unique_copy.cpp
        ├── alg.numerics.adjacent.difference
        │   └── adjacent_difference.cpp
        ├── alg.numerics.exclusive.scan
        │   └── exclusive_scan.cpp
        └── alg.numerics.inclusive.scan
        │   └── inclusive_scan.cpp
    ├── alg.nonmodifying
        ├── alg.gen.adjacent.find
        │   └── adjacent_find.cpp
        ├── alg.gen.all_of
        │   └── all_of.cpp
        ├── alg.gen.any_of
        │   └── any_of.cpp
        ├── alg.gen.count
        │   ├── count.cpp
        │   └── count_if.cpp
        ├── alg.gen.equal
        │   └── equal.cpp
        ├── alg.gen.find.end
        │   └── find_end.cpp
        ├── alg.gen.find.first.of
        │   └── find_first_of.cpp
        ├── alg.gen.find
        │   ├── find.cpp
        │   ├── find_if.cpp
        │   └── find_if_not.cpp
        ├── alg.gen.foreach
        │   ├── for_each.cpp
        │   └── for_each_n.cpp
        ├── alg.gen.heap
        │   ├── is_heap.cpp
        │   └── is_heap_until.cpp
        ├── alg.gen.mismatch
        │   └── mismatch.cpp
        ├── alg.gen.none_of
        │   └── none_of.cpp
        ├── alg.gen.search
        │   ├── search.cpp
        │   └── search_n.cpp
        ├── alg.numerics.inner.product
        │   └── inner_product.cpp
        └── alg.numerics.reduce
        │   └── reduce.cpp
    └── alg.sorting
        ├── alg.gen.lex.comparison
            └── lexicographical_compare.cpp
        ├── alg.gen.merge
            ├── inplace_merge.cpp
            └── merge.cpp
        ├── alg.gen.min.max
            ├── max_element.cpp
            ├── min_element.cpp
            └── minmax_element.cpp
        ├── alg.gen.nth.element
            └── nth_element.cpp
        ├── alg.gen.set.operations
            ├── includes
            │   └── includes.cpp
            ├── set.difference
            │   └── set_difference.cpp
            ├── set.intersection
            │   └── set_intersection.cpp
            ├── set.symmetric.difference
            │   └── set_symmetric_difference.cpp
            └── set.union
            │   └── set_union.cpp
        └── alg.gen.sort
            ├── is.sorted
                ├── is_sorted.cpp
                └── is_sorted_until.cpp
            ├── partial.sort.copy
                └── partial_sort_copy.cpp
            ├── partial.sort
                └── partial_sort.cpp
            ├── sort
                └── sort.cpp
            └── stable.sort
                └── stable_sort.cpp


/README.md:
--------------------------------------------------------------------------------
 1 | # N4354 Implementation
 2 | 
 3 | ### Overview
 4 | 
 5 | This repository contains a parallel version of the STL algorithms as a proof of concept for a C++ extension proposal. It was filed as n3554 and then became [n3850](http://isocpp.org/blog/2014/01/n3850), then [n3960](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3960.pdf), then N4354 (http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4354.pdf).
 6 | 
 7 | This project is in a very early stage. We plan to first implement an integration suite based on the current STL algorithms, then implement the sequential policy and finally a parallel policy based on std::thread.
 8 | 
 9 | We will also try to draft a documentation in the wiki, largely inspired by the [cppreference](http://en.cppreference.com) website. 
10 | 
11 | The goal is to make is as easy as possible for people to implement and test their own execution policies, once the standard parallel and sequential ones are implemented.
12 | 
13 | ### Reference
14 | 
15 | * [Official TS](http://isocpp.org/blog/2014/01/n3850), most recent one [here](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3960.pdf).
16 | * [Jared Hoberock's implementation](https://github.com/n3554/n3554) based on thrust.
17 | * [Microsoft's implementation](https://parallelstl.codeplex.com) using Windows Foundation utilities.
18 | * [GCC's parallel implementation](http://gcc.gnu.org/onlinedocs/libstdc++/manual/parallel_mode.html) of the STL algorithms.
19 | 
20 | 
21 | 


--------------------------------------------------------------------------------
/examples/MonteCarlo.cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <random>
 3 | #include <limits>
 4 | #include <iostream>
 5 | #include <chrono>
 6 | #include <experimental/algorithm>
 7 | #include <experimental/numeric>
 8 | using namespace std;
 9 | 
10 | double test_pi() {
11 |   thread_local static random_device rd;
12 | 
13 |   constexpr unsigned samples = 10000;
14 |   mt19937_64 gen(rd());
15 |   uniform_real_distribution<double> dis(0,1);
16 |   
17 |   unsigned sum = 0;
18 |   for(unsigned i = 0; i < samples; ++i){
19 |     const double x = dis(gen), y = dis(gen);
20 |     double dist = sqrtf(x*x + y*y);
21 |     if(dist <= 1.0f) 
22 |       sum++;
23 |   }
24 |   
25 |   sum *= 4;
26 |   return static_cast<double>(sum)/static_cast<double>(samples);
27 | }
28 | 
29 | template<typename T>
30 | auto extimate_pi(T && policy)
31 |   -> std::chrono::microseconds
32 | {
33 |   using namespace std::experimental;
34 |   constexpr unsigned samples = 10000;
35 |   vector<double> estimates(samples);
36 | 
37 |   auto start = chrono::high_resolution_clock::now();
38 |   
39 |   parallel::generate(policy, begin(estimates), end(estimates), test_pi);
40 |   auto pi = parallel::reduce(policy, begin(estimates), end(estimates)) / double{samples};
41 | 
42 |   auto finish = chrono::high_resolution_clock::now();
43 | 
44 |   cout << "pi = " << pi << endl; 
45 | 
46 |   return chrono::duration_cast<chrono::microseconds>(finish-start); 
47 | }
48 | 
49 | int main(){
50 |   using namespace std::experimental;
51 |   cout << "Using seq: " << endl; 
52 |   auto time_seq = extimate_pi(parallel::seq);
53 |   cout << "seq took " << time_seq.count() << " us" << endl;
54 | 
55 |   cout << "Using par: " << endl; 
56 |   auto time_par = extimate_pi(parallel::par);
57 |   cout << "seq took " << time_par.count() << " us" << endl;
58 | }
59 | 


--------------------------------------------------------------------------------
/examples/README.md:
--------------------------------------------------------------------------------
 1 | # Example applications using parallel standard algorithms
 2 | 
 3 | ## Compilation
 4 | 
 5 | To compile the code, add the include directory from the root to the include path, make sure you have C++11 enabled and link with the thread library if necessary:
 6 | 
 7 | ```
 8 | #!c++
 9 | $> g++ -O3 -std=c++11 -I../include -o bs blackscholes.cpp -lpthread
10 | $> ./bs
11 | Using seq: 1609520 us
12 | Using par: 130504 us
13 | ```
14 | 
15 | 


--------------------------------------------------------------------------------
/examples/blackscholes.cpp:
--------------------------------------------------------------------------------
 1 | // adapted from http://www.espenhaug.com/black_scholes.html
 2 | #include <cmath>
 3 | #include <vector>
 4 | #include <iostream>
 5 | #include <chrono>
 6 | #include <experimental/algorithm>
 7 | 
 8 | constexpr double PI  =3.141592653589793238463;
 9 | 
10 | // The cumulative normal distribution function 
11 | double CND( double X )
12 | {
13 |   double L, K, w ;
14 | 
15 |   double const a1 = 0.31938153, a2 = -0.356563782, a3 = 1.781477937;
16 |   double const a4 = -1.821255978, a5 = 1.330274429;
17 | 
18 |   L = fabs(X);
19 |   K = 1.0 / (1.0 + 0.2316419 * L);
20 |   w = 1.0 - 1.0 / sqrt(2 * PI) * exp(-L *L / 2) * (a1 * K + a2 * K *K + a3 * pow(K,3) + a4 * pow(K,4) + a5 * pow(K,5));
21 | 
22 |   if (X < 0 ){
23 |     w= 1.0 - w;
24 |   }
25 |   return w;
26 | }
27 | 
28 | struct Option {
29 |   // members to compute
30 |   double call, put;
31 |   // compute parameters
32 |   double S, X, T, r, v;
33 | };
34 | 
35 | // This should be converted to a dynamic policy when they are implemented
36 | template<typename T>
37 | auto BlackScholes(T && policy, const std::vector<Option> & options)
38 |   -> std::chrono::microseconds
39 | {
40 |   using namespace std;
41 |   using namespace std::experimental;
42 |   auto copy = options;
43 |   auto start = chrono::high_resolution_clock::now();
44 |   for_each(policy, begin(copy), end(copy), 
45 |       [](Option & opt) {
46 |         const double d1 = (std::log(opt.S/opt.X)+(opt.r+opt.v*opt.v/2)*opt.T)/(opt.v*std::sqrt(opt.T));
47 |         const double d2 = d1-opt.v*sqrt(opt.T);
48 | 
49 |         opt.call = opt.S *CND(d1)-opt.X * exp(-opt.r*opt.T)*CND(d2);
50 |         opt.put = opt.X * exp(-opt.r * opt.T) * CND(-d2) - opt.S * CND(-d1);
51 |       });
52 |   auto finish = chrono::high_resolution_clock::now();
53 | 
54 |   // make sure the compiler is not too clever when optimizing the loop
55 |   for(auto & opt : copy) if(opt.call == 0.01 && opt.put == PI) std::cout << ".";
56 | 
57 |   return chrono::duration_cast<chrono::microseconds>(finish-start); 
58 | }
59 | 
60 | 
61 | int main()
62 | {
63 |   using namespace std;
64 |   // compute 5M options
65 |   vector<Option> options(5000000);
66 | 
67 |   cout << "Using seq: " 
68 |        << BlackScholes(experimental::parallel::seq, options).count() 
69 |        << " us" << endl;
70 | 
71 |   cout << "Using par: " 
72 |        << BlackScholes(experimental::parallel::par, options).count() 
73 |        << " us" << endl;
74 | }
75 | 
76 | 


--------------------------------------------------------------------------------
/examples/find_if.cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <iostream>
 3 | #include <chrono>
 4 | #include <random>
 5 | #include <experimental/algorithm>
 6 | 
 7 | template<typename T, class UnaryPredicate, typename U>
 8 | auto myfind(T && policy, const std::vector<U> & values, UnaryPredicate pred)
 9 |   -> std::chrono::microseconds
10 | {
11 | 	using namespace std;
12 | 	using namespace std::experimental; 
13 | 	
14 | 	auto start = chrono::high_resolution_clock::now();
15 | 	auto result = find_if(policy, begin(values), end(values), pred);
16 | 	auto finish = chrono::high_resolution_clock::now();
17 | 	
18 | 	if (result != end(values)){	
19 | 		cout << "Value found: " << *result << " at position: "
20 | 		     << &(*result) - &(*begin(values)) << endl;
21 | 	} else {
22 | 		cout << "No such value found" << endl;
23 | 	}
24 | 	
25 | 	return chrono::duration_cast<chrono::microseconds>(finish-start); 
26 | }
27 | 
28 | int main()
29 | {
30 | 	using namespace std;
31 | 	
32 | 	vector<int> values(5000000);
33 | 	for (size_t i = 0; i < values.size(); i++){
34 | 		values[i] = (int)i;
35 | 	}
36 | 	
37 | 	auto pred = [](int a){
38 | 		return false;
39 | 		//return ((a+1)%43 == 0);
40 | 	};
41 | 	
42 | 	cout << "Using seq:   " 
43 | 	     << myfind(experimental::parallel::seq, values, pred).count() 
44 | 	     << " us" << endl;
45 | 	
46 | 	cout << "Using par:   " 
47 | 	     << myfind(experimental::parallel::par, values, pred).count() 
48 | 	     << " us" << endl;
49 | }
50 | 


--------------------------------------------------------------------------------
/examples/histogram.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * This program computes the histogram of an array of random values.
 3 |  *
 4 |  * The parallel version of std::for_each requires thread safe access to the counters,
 5 |  * so it is using atomics, while the sequential version uses plain ints.
 6 |  *
 7 |  * We test for high contention on the counters and lower contention.
 8 |  */
 9 | 
10 | #include <vector>
11 | #include <iostream>
12 | #include <chrono>
13 | #include <atomic>
14 | #include <random>
15 | #include <experimental/algorithm>
16 | 
17 | // This should be converted to a dynamic policy when they are implemented
18 | template<typename Counter, typename T>
19 | auto Histogram(T && policy, const std::vector<unsigned> & values, const unsigned max)
20 |   -> std::chrono::microseconds
21 | {
22 |   using namespace std;
23 |   using namespace std::experimental;
24 |   vector<Counter> hist(max);
25 | 
26 |   auto start = chrono::high_resolution_clock::now();
27 |   for_each(policy, begin(values), end(values), 
28 |       [&hist](const int & value) {
29 |         hist[value]++;
30 |       });
31 |   auto finish = chrono::high_resolution_clock::now();
32 | 
33 |   for(auto &v : hist) if(v == 5000001) cerr << "impossible" << endl; 
34 | 
35 |   return chrono::duration_cast<chrono::microseconds>(finish-start); 
36 | }
37 | 
38 | void test(unsigned hist_size){
39 |   using namespace std;
40 | 
41 |   vector<unsigned> values(5000000);
42 |   random_device rd;
43 |   mt19937 gen(rd());
44 |   poisson_distribution<> d(hist_size/2);
45 | 
46 |   generate(begin(values), end(values), [&](){ return d(gen) % hist_size; });
47 | 
48 |   cout << "Size of the histogram: " << hist_size << std::endl;
49 | 
50 |   cout << "Using seq: " 
51 |        << Histogram<unsigned>(experimental::parallel::seq, values, hist_size).count() 
52 |        << " us" << endl;
53 | 
54 |   cout << "Using par: " 
55 |        << Histogram<std::atomic_uint>(experimental::parallel::par, values, hist_size).count() 
56 |        << " us" << endl;
57 | }
58 | 
59 | int main()
60 | {
61 |   constexpr unsigned max_small = 5, max_large = 100;
62 | 
63 |   // high collision
64 |   test(max_small);
65 | 
66 |   // low collision
67 |   test(max_large);
68 | }
69 | 
70 | 


--------------------------------------------------------------------------------
/examples/palindrome.cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <iostream>
 3 | #include <chrono>
 4 | #include <random>
 5 | #include <experimental/algorithm>
 6 | 
 7 | // This should be converted to a dynamic policy when they are implemented
 8 | template<typename T>
 9 | auto palindrome(T && policy, const std::string & str)
10 |   -> std::chrono::microseconds
11 | {
12 |   using namespace std;
13 |   using namespace std::experimental;
14 | 
15 |   auto start = chrono::high_resolution_clock::now();
16 |   const auto pal = equal(policy, begin(str), begin(str) + str.length()/2, str.rbegin());
17 |   auto finish = chrono::high_resolution_clock::now();
18 | 
19 |   cout << "The string is" << (pal ? "" : " not") << " a palindrome." << endl;
20 | 
21 |   return chrono::duration_cast<chrono::microseconds>(finish-start); 
22 | }
23 | 
24 | int main()
25 | {
26 |   using namespace std;
27 | 
28 |   // a six is a six is a six is a..
29 |   string str = "asixis";
30 |   for(unsigned i = 0; i < 22; ++i)
31 |     str += str;
32 |   str += "a";
33 | 
34 |   cout << "Testing string of " << str.length() << " characters." << endl;
35 | 
36 |   cout << "Using seq: " << endl; 
37 |   auto time_seq = palindrome(experimental::parallel::seq, str);
38 |   cout << "seq took " << time_seq.count() << " us" << endl;
39 | 
40 |   // std::equal is not yet implemented for par
41 | #if 0
42 |   cout << "Using par: " << endl; 
43 |   auto time_par = palindrome(experimental::parallel::par, str);
44 |   cout << "par took " << time_par.count() << " us" << endl;
45 | #endif
46 | }
47 | 
48 | 
49 | 


--------------------------------------------------------------------------------
/examples/prime.cpp:
--------------------------------------------------------------------------------
  1 | #include <chrono>
  2 | #include <vector>
  3 | #include <random>
  4 | #include <iostream>
  5 | #include <experimental/algorithm>
  6 | 
  7 | // Type of the generated ints. std::uint64_t can take a while.
  8 | typedef std::uint32_t number_t;
  9 | 
 10 | /**
 11 |  * Test if a number os a prime.
 12 |  */
 13 | static bool isPrime(const number_t & n)
 14 | {
 15 |   if (n < 4) return n > 1;
 16 |   if (n % 2 == 0) return false;
 17 |   const auto sq = (int)sqrt(n) + 1;
 18 |   for (number_t i = 3; i <= sq; i += 2)
 19 |     if (n % i == 0) return false;
 20 |   return true;
 21 | }
 22 | 
 23 | /**
 24 |  * Finding the first prime. The parallel version will have a big disadvantage if
 25 |  * it is scanning the entire array since the sequential version will stop at the first
 26 |  * match.
 27 |  */
 28 | template<typename t>
 29 | auto find_prime(t && policy, const std::vector<number_t> & numbers)
 30 |   -> std::chrono::microseconds
 31 | {
 32 |   using namespace std;
 33 |   using namespace std::experimental; 
 34 | 
 35 |   auto start = chrono::high_resolution_clock::now();
 36 |   auto it = find_if(policy, begin(numbers), end(numbers), isPrime);
 37 |   auto finish = chrono::high_resolution_clock::now();
 38 |     
 39 |   cout << "contains at least one prime: " << boolalpha << (it != end(numbers)) << endl;
 40 |   if(it != end(numbers))
 41 |     cout << "at position: " << distance(begin(numbers), it) << endl;
 42 |  
 43 |   return chrono::duration_cast<chrono::microseconds>(finish-start); 
 44 | }
 45 | 
 46 | template<typename t>
 47 | auto count_prime(t && policy, const std::vector<number_t> & numbers)
 48 |   -> std::chrono::microseconds
 49 | {
 50 |   using namespace std;
 51 |   auto start = chrono::high_resolution_clock::now();
 52 |   auto count = count_if(policy, begin(numbers), end(numbers), isPrime);
 53 |   auto finish = chrono::high_resolution_clock::now();
 54 |     
 55 |   cout << "Number of prime numbers: " << count << endl;
 56 |  
 57 |   return chrono::duration_cast<chrono::microseconds>(finish-start); 
 58 | }
 59 | 
 60 | 
 61 | int main(){
 62 |   using namespace std;
 63 |   default_random_engine gen(6);
 64 |   uniform_int_distribution<number_t> d(numeric_limits<number_t>::max()/2,
 65 |                                        numeric_limits<number_t>::max());
 66 | 
 67 |   vector<number_t> numbers(100000);
 68 |   generate(begin(numbers), end(numbers), [&](){ return d(gen); });
 69 | 
 70 |   { // test std::find_if
 71 |     cout << endl << "Testing std::find_if" << endl;    
 72 | 
 73 |     cout << "Using seq: " << endl; 
 74 |     auto time_seq = find_prime(experimental::parallel::seq, numbers);
 75 |     cout << "seq took " << time_seq.count() << " us" << endl;
 76 | 
 77 |     cout << "Using par: " << endl; 
 78 |     auto time_par = find_prime(experimental::parallel::par, numbers);
 79 |     cout << "par took " << time_par.count() << " us" << endl;
 80 |   }
 81 | 
 82 |   { // test std::count_if
 83 |     cout << endl << "Testing std::count_if" << endl;    
 84 | 
 85 |     cout << "Using seq: " << endl; 
 86 |     auto time_seq = count_prime(experimental::parallel::seq, numbers);
 87 |     cout << "seq took " << time_seq.count() << " us" << endl;
 88 | 
 89 |     cout << "Using par: " << endl; 
 90 |     auto time_par = count_prime(experimental::parallel::par, numbers);
 91 |     cout << "par took " << time_par.count() << " us" << endl;
 92 |   }
 93 | 
 94 |   { // test std::replace_if
 95 |     cout << endl << "Testing std::replace_if" << endl;
 96 | 
 97 |     auto copy = numbers;
 98 |     cout << "Using seq: " << endl; 
 99 |     auto start = chrono::high_resolution_clock::now(); 
100 |     replace_if(experimental::parallel::seq, begin(copy), end(copy), isPrime, 0);
101 |     auto finish = chrono::high_resolution_clock::now();
102 |     cout << "seq took " << chrono::duration_cast<chrono::microseconds>(finish-start).count() << " us" << endl;
103 | 
104 |     copy = numbers;
105 |     cout << "Using par: " << endl;
106 |     start = chrono::high_resolution_clock::now(); 
107 |     replace_if(experimental::parallel::par, begin(copy), end(copy), isPrime, 0);
108 |     finish = chrono::high_resolution_clock::now();
109 |     cout << "seq par " << chrono::duration_cast<chrono::microseconds>(finish-start).count() << " us" << endl;
110 |   }
111 | }
112 | 
113 | 


--------------------------------------------------------------------------------
/examples/sort.cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <iostream>
 3 | #include <chrono>
 4 | #include <atomic>
 5 | #include <random>
 6 | #include <experimental/algorithm>
 7 | 
 8 | // This should be converted to a dynamic policy when they are implemented
 9 | template<typename T>
10 | auto sort(T && policy, const std::vector<unsigned> & values)
11 |   -> std::chrono::microseconds
12 | {
13 |   using namespace std;
14 |   using namespace std::experimental; 
15 | 
16 |   auto copy = values;
17 | 
18 |   auto start = chrono::high_resolution_clock::now();
19 |   sort(policy, begin(copy), end(copy));
20 |   auto finish = chrono::high_resolution_clock::now();
21 | 
22 |   cout << "Is sorted: " << boolalpha << is_sorted(begin(copy), end(copy)) << endl;
23 | 
24 |   return chrono::duration_cast<chrono::microseconds>(finish-start); 
25 | }
26 | 
27 | int main(){
28 |   using namespace std;
29 | 
30 |   vector<unsigned> values(5000000);
31 |   random_device rd;
32 |   mt19937 gen(rd());
33 |   poisson_distribution<> d(10000);
34 | 
35 |   generate(begin(values), end(values), [&](){ return d(gen); });
36 |   cout << "Is sorted: " << boolalpha << is_sorted(begin(values), end(values)) << endl;
37 | 
38 |   cout << "Using seq: " << endl;
39 |   auto time_seq = sort(experimental::parallel::seq, values);
40 |   cout << "seq took " << time_seq.count() << " us" << endl;
41 | 
42 |   cout << "Using par: " << endl;
43 |   auto time_par = sort(experimental::parallel::par, values);
44 |   cout << "par took " << time_par.count() << " us" << endl;
45 | }
46 | 
47 | 


--------------------------------------------------------------------------------
/examples/stable_sort.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Stable sort test. We generate a vector of doubles sorted in descending 
 3 |  * order. We then sort this arrays in ascending order using only the integral
 4 |  * part. The result is an array where values are sorted in ascending integral 
 5 |  * values but descending fractional values.
 6 |  */
 7 | 
 8 | #include <vector>
 9 | #include <iostream>
10 | #include <chrono>
11 | #include <atomic>
12 | #include <random>
13 | #include <experimental/algorithm>
14 | 
15 | // Compare function to check that integral part is sorted in ascending order and
16 | // fractional part in descending order
17 | bool compare(const double &a, const double &b) {
18 |   return (int)a < (int)b || ((int)a == (int)b && a > b);
19 | }
20 | 
21 | 
22 | // This should be converted to a dynamic policy when they are implemented
23 | template<typename T>
24 | auto stable_sort(T && policy, const std::vector<double> & values)
25 |   -> std::chrono::microseconds
26 | {
27 |   using namespace std;
28 |   using namespace std::experimental; 
29 | 
30 |   auto copy = values;
31 | 
32 |   auto start = chrono::high_resolution_clock::now();
33 |   stable_sort(policy, begin(copy), end(copy), 
34 |               [](const double &a, const double &b){
35 |                 return (int)a < (int)b;
36 |               });
37 |   auto finish = chrono::high_resolution_clock::now();
38 | 
39 |   cout << "Is (partially) sorted: " << boolalpha
40 |        << is_sorted(begin(copy), end(copy), compare) << endl;
41 | 
42 |   return chrono::duration_cast<chrono::microseconds>(finish-start); 
43 | }
44 | 
45 | int main(){
46 |   using namespace std;
47 | 
48 |   double start = 100000;
49 |   std::vector<double> values(5000000);
50 |   generate(begin(values), end(values), [&](){ start -= 0.1; return start; });
51 | 
52 |   cout << "Is (partially) sorted: " << boolalpha
53 |        << is_sorted(begin(values), end(values),compare) << endl;
54 | 
55 |   cout << "Using seq: " << endl;
56 |   auto time_seq = stable_sort(experimental::parallel::seq, values);
57 |   cout << "seq took " << time_seq.count() << " us" << endl;
58 |   
59 |   cout << "Using par: " << endl;
60 |   auto time_par = stable_sort(experimental::parallel::par, values);
61 |   cout << "par took " << time_par.count() << " us" << endl;
62 | }
63 | 
64 | 


--------------------------------------------------------------------------------
/examples/sum_reduction.cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <iostream>
 3 | #include <chrono>
 4 | #include <random>
 5 | #include <experimental/numeric>
 6 | 
 7 | // This should be converted to a dynamic policy when they are implemented
 8 | template<typename T>
 9 | auto sum_reduction(T && policy, const std::vector<double> & values)
10 |   -> std::chrono::microseconds
11 | {
12 |   using namespace std;
13 |   using namespace std::experimental; 
14 | 
15 |   auto start = chrono::high_resolution_clock::now();
16 |   auto sum = reduce(policy, begin(values), end(values));
17 |   auto finish = chrono::high_resolution_clock::now();
18 | 
19 |   cout << "sum = " << sum << endl;
20 | 
21 |   return chrono::duration_cast<chrono::microseconds>(finish-start); 
22 | }
23 | 
24 | int main()
25 | {
26 |   using namespace std;
27 | 
28 |   vector<double> values(5000000);
29 |   random_device rd;
30 |   mt19937 gen(rd());
31 |   uniform_real_distribution<> d(1, 2);
32 | 
33 |   generate(begin(values), end(values), [&](){ return d(gen); });
34 | 
35 |   cout << "Using seq: " 
36 |        << sum_reduction(experimental::parallel::seq, values).count() 
37 |        << " us" << endl;
38 | 
39 |   cout << "Using par: " 
40 |        << sum_reduction(experimental::parallel::par, values).count() 
41 |        << " us" << endl;
42 | }
43 | 
44 | 
45 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/par/all_of.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_PARALLEL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | #include <experimental/bits/parallel/algos/par/diffract.h>
 7 | 
 8 | namespace std {
 9 | namespace experimental {
10 | namespace parallel {
11 | inline namespace v1 {
12 | 
13 |   template<class InputIterator, class Predicate>
14 |     bool parallel_execution_policy::all_of(InputIterator first, InputIterator last, Predicate pred) const
15 |   {
16 |     return detail::diffract_gather(first, last, 
17 |                                    std::all_of<InputIterator, Predicate>,
18 |                                    std::bit_and<bool>());
19 |   }
20 | 
21 | } // namespace v1
22 | } // namespace parallel
23 | } // namespace experimental
24 | } // namespace std
25 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/par/any_of.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_PARALLEL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | #include <experimental/bits/parallel/algos/par/diffract.h>
 7 | 
 8 | namespace std {
 9 | namespace experimental {
10 | namespace parallel {
11 | inline namespace v1 {
12 | 
13 |   template<class InputIterator, class Predicate>
14 |     bool parallel_execution_policy::any_of(InputIterator first, InputIterator last, Predicate pred) const
15 |   {
16 |     return detail::diffract_gather(first, last, 
17 |                                    std::any_of<InputIterator, Predicate>,
18 |                                    std::bit_or<bool>());
19 |   }
20 | 
21 | } // namespace v1
22 | } // namespace parallel
23 | } // namespace experimental
24 | } // namespace std
25 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/par/count.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_PARALLEL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | #include <experimental/bits/parallel/algos/par/diffract.h>
 7 | 
 8 | namespace std {
 9 | namespace experimental {
10 | namespace parallel {
11 | inline namespace v1 {
12 | 
13 |   template<class InputIterator, class EqualityComparable>
14 |     typename iterator_traits<InputIterator>::difference_type
15 |       parallel_execution_policy::count(InputIterator first, InputIterator last, 
16 |                                          const EqualityComparable &value) const
17 |   {
18 |     return detail::diffract_gather(first, last,
19 |                                    std::count<InputIterator, EqualityComparable>,
20 |                                    std::plus<typename iterator_traits<InputIterator>::difference_type>());
21 |   }
22 | 
23 | } // namespace v1
24 | } // namespace parallel
25 | } // namespace experimental
26 | } // namespace std
27 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/par/count_if.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_PARALLEL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | #include <experimental/bits/parallel/algos/par/diffract.h>
 7 | 
 8 | namespace std {
 9 | namespace experimental {
10 | namespace parallel {
11 | inline namespace v1 {
12 | 
13 |   template<class InputIterator, class Predicate>
14 |     typename iterator_traits<InputIterator>::difference_type
15 |       parallel_execution_policy::count_if(InputIterator first, InputIterator last, Predicate pred) const 
16 |   {
17 |     return detail::diffract_gather(first, last,
18 |                                    std::count_if<InputIterator, Predicate>,
19 |                                    std::plus<typename iterator_traits<InputIterator>::difference_type>(),
20 |                                    pred);
21 |   }
22 | 
23 | } // namespace v1
24 | } // namespace parallel
25 | } // namespace experimental
26 | } // namespace std
27 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/par/fill.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_PARALLEL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | #include <experimental/bits/parallel/algos/par/diffract.h>
 7 | 
 8 | namespace std {
 9 | namespace experimental {
10 | namespace parallel {
11 | inline namespace v1 {
12 | 
13 |   template<class ForwardIterator, class T>
14 |     void parallel_execution_policy::fill(ForwardIterator first, ForwardIterator last, const T& value) const {
15 |       detail::diffract(first, last, std::fill<ForwardIterator, T>, value);
16 |   }
17 | 
18 | } // namespace v1
19 | } // namespace parallel
20 | } // namespace experimental
21 | } // namespace std
22 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/par/fill_n.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_PARALLEL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | #include <iterator>
 7 | #include <experimental/bits/parallel/algos/par/diffract.h>
 8 | 
 9 | namespace std {
10 | namespace experimental {
11 | namespace parallel {
12 | inline namespace v1 {
13 | 
14 |   template<class OutputIterator, class Size, class T>
15 |     OutputIterator parallel_execution_policy::fill_n(OutputIterator first, Size n, const T& value) const 
16 |   {
17 |       detail::diffract(first, next(first, n), std::fill<OutputIterator, T>, value);
18 |       return n > 0 ? first + n : first;
19 |   }
20 | 
21 | } // namespace v1
22 | } // namespace parallel
23 | } // namespace experimental
24 | } // namespace std
25 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/par/find.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_PARALLEL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | #include <experimental/bits/parallel/algos/par/diffract.h>
 7 | 
 8 | namespace std {
 9 | namespace experimental {
10 | namespace parallel {
11 | inline namespace v1 {
12 | 
13 |   template<class InputIterator, class T>
14 |     InputIterator parallel_execution_policy::find(InputIterator first, InputIterator last,
15 |                        const T& value) const
16 |   {
17 |     return detail::diffract_gather_compare(
18 |         first, last,
19 |         std::find<InputIterator, T>,
20 |         [&](const InputIterator &a, const InputIterator &end_a, 
21 |             const InputIterator &b, const InputIterator &/*unused*/){
22 |           // The comparison operator returns the first non-end iterator
23 |           return distance(first, a) < distance(first, b) && a != end_a ? a : b;
24 |         },
25 |         value);
26 |   }
27 | 
28 | } // namespace v1
29 | } // namespace parallel
30 | } // namespace experimental
31 | } // namespace std
32 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/par/find_if.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_PARALLEL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | #include <experimental/bits/parallel/algos/par/diffract.h>
 7 | 
 8 | namespace std {
 9 | namespace experimental {
10 | namespace parallel {
11 | inline namespace v1 {
12 | 
13 |   template<class InputIterator, class Predicate>
14 |     InputIterator parallel_execution_policy::find_if(InputIterator first, InputIterator last,
15 |                                                      Predicate pred) const 
16 |   {
17 |     return detail::diffract_gather_compare(
18 |         first, last,
19 |         std::find_if<InputIterator, Predicate>,
20 |         [&](const InputIterator &a, const InputIterator &end_a, 
21 |             const InputIterator &b, const InputIterator &/*unused*/){
22 |           // The comparison operator returns the first non-end iterator
23 |           return distance(first, a) < distance(first, b) && a != end_a ? a : b;
24 |         },
25 |         pred);
26 | 
27 |   }
28 | 
29 | } // namespace v1
30 | } // namespace parallel
31 | } // namespace experimental
32 | } // namespace std
33 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/par/find_if_not.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_PARALLEL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator, class Predicate>
13 |     InputIterator parallel_execution_policy::find_if_not(InputIterator first, InputIterator last,
14 |                               Predicate pred) const
15 |   {
16 |     return parallel_execution_policy::find_if(first, last, not1(pred));
17 |   }
18 | 
19 | } // namespace v1
20 | } // namespace parallel
21 | } // namespace experimental
22 | } // namespace std
23 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/par/for_each.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_PARALLEL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | #include <functional>
 7 | #include <experimental/bits/parallel/algos/par/diffract.h>
 8 | 
 9 | namespace std {
10 | namespace experimental {
11 | namespace parallel {
12 | inline namespace v1 {
13 | 
14 |   template<class InputIterator, class UnaryFunction>
15 |     // requires CopyConstructible<UnaryFunction>
16 |   void parallel_execution_policy::for_each(InputIterator first, InputIterator last, 
17 |                                            UnaryFunction f) const 
18 |   { 
19 |     //  diffract the range and forward
20 |     detail::diffract(first, last, std::for_each<InputIterator, UnaryFunction>, std::forward(f));
21 |   }
22 | 
23 | } // namespace v1
24 | } // namespace parallel
25 | } // namespace experimental
26 | } // namespace std
27 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/par/for_each_n.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_PARALLEL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | #include <experimental/bits/parallel/algos/par/diffract.h>
 7 | 
 8 | namespace std {
 9 | namespace experimental {
10 | namespace parallel {
11 | inline namespace v1 {
12 | 
13 |   template<class InputIterator, class Size, class Function>
14 |     InputIterator parallel_execution_policy::for_each_n(InputIterator first, Size n,
15 |                                                         Function f) const 
16 |   {
17 |     if(n < 0)
18 |       return first;
19 |     auto end = first;
20 |     advance(end, n);
21 |     detail::diffract(first, end, std::for_each<InputIterator, Function>, std::move(f));
22 |     return end;
23 |   }
24 | 
25 | } // namespace v1
26 | } // namespace parallel
27 | } // namespace experimental
28 | } // namespace std
29 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/par/generate.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_PARALLEL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | #include <experimental/bits/parallel/algos/par/diffract.h>
 7 | 
 8 | namespace std {
 9 | namespace experimental {
10 | namespace parallel {
11 | inline namespace v1 {
12 | 
13 |   template<class ForwardIterator, class Generator>
14 |     void parallel_execution_policy::generate(ForwardIterator first, ForwardIterator last, Generator gen) const 
15 |   {
16 |     detail::diffract(first, last, 
17 |                      std::generate<ForwardIterator, Generator>, 
18 |                      std::forward<Generator>(gen));
19 |   }
20 | 
21 | } // namespace v1
22 | } // namespace parallel
23 | } // namespace experimental
24 | } // namespace std
25 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/par/generate_n.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_PARALLEL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | #include <experimental/bits/parallel/algos/par/diffract.h>
 7 | 
 8 | namespace std {
 9 | namespace experimental {
10 | namespace parallel {
11 | inline namespace v1 {
12 | 
13 |   template<class OutputIterator, class Size, class Generator>
14 |     OutputIterator parallel_execution_policy::generate_n(OutputIterator first, Size n, Generator gen) const 
15 |   {
16 |     detail::diffract(first, first + n, std::generate_n<OutputIterator, Size, Generator>);
17 |     return n > 0 ? first + n : first;
18 |   }
19 | 
20 | } // namespace v1
21 | } // namespace parallel
22 | } // namespace experimental
23 | } // namespace std
24 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/par/is_heap.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_PARALLEL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | #include <experimental/bits/parallel/algos/par/diffract.h>
 7 | 
 8 | namespace std {
 9 | namespace experimental {
10 | namespace parallel {
11 | inline namespace v1 {
12 | 
13 |   template<class ForwardIterator>
14 |     bool parallel_execution_policy::is_heap(ForwardIterator first, ForwardIterator last) const 
15 |   {
16 |     return detail::diffract_gather(first, last, 
17 |                                    std::is_heap<ForwardIterator>,
18 |                                    std::bit_and<bool>());
19 |   }
20 | 
21 | 
22 |   template<class ForwardIterator, class Compare>
23 |     bool parallel_execution_policy::is_heap(ForwardIterator first, ForwardIterator last,
24 |                         Compare comp) const 
25 |   {
26 |     return detail::diffract_gather(first, last, 
27 |                                    std::is_heap<ForwardIterator, Compare>,
28 |                                    std::bit_and<bool>(),
29 |                                    comp);
30 |   }
31 | 
32 | } // namespace v1
33 | } // namespace parallel
34 | } // namespace experimental
35 | } // namespace std
36 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/par/is_heap_until.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_PARALLEL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | #include <experimental/bits/parallel/algos/par/diffract.h>
 7 | 
 8 | namespace std {
 9 | namespace experimental {
10 | namespace parallel {
11 | inline namespace v1 {
12 | 
13 |   template<class ForwardIterator>
14 |     ForwardIterator parallel_execution_policy::is_heap_until(ForwardIterator first, ForwardIterator last) const 
15 |   {
16 |     return detail::diffract_gather(first, last, 
17 |                                    std::is_heap_until<ForwardIterator>,
18 |                                    std::bit_and<bool>());
19 | 
20 |   }
21 | 
22 |   template<class ForwardIterator, class Compare>
23 |     ForwardIterator parallel_execution_policy::is_heap_until(ForwardIterator first, ForwardIterator last,
24 |                                                                Compare comp) const
25 |   {
26 |     return detail::diffract_gather(first, last, 
27 |                                    std::is_heap_until<ForwardIterator, Compare>,
28 |                                    std::bit_and<bool>(),
29 |                                    comp);
30 | 
31 |   }
32 | 
33 | } // namespace v1
34 | } // namespace parallel
35 | } // namespace experimental
36 | } // namespace std
37 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/par/is_sorted.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_PARALLEL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class ForwardIterator>
13 |     bool parallel_execution_policy::is_sorted(ForwardIterator first, ForwardIterator last) const 
14 |   {
15 |     return this->is_sorted_until(first, last) == last;
16 |   }
17 | 
18 | 
19 |   template<class ForwardIterator, class Compare>
20 |     bool parallel_execution_policy::is_sorted(ForwardIterator first, ForwardIterator last,
21 |                         Compare comp) const 
22 |   {
23 |     return this->is_sorted_until(first, last, comp) == last;
24 |   }
25 | 
26 | } // namespace v1
27 | } // namespace parallel
28 | } // namespace experimental
29 | } // namespace std
30 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/par/max_element.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_PARALLEL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | #include <experimental/bits/parallel/algos/par/diffract.h>
 7 | 
 8 | namespace std {
 9 | namespace experimental {
10 | namespace parallel {
11 | inline namespace v1 {
12 | 
13 |   template<class ForwardIterator>
14 |     ForwardIterator parallel_execution_policy::max_element(ForwardIterator first, 
15 |                                                            ForwardIterator last) const 
16 |   {
17 |     return detail::diffract_gather(first, last,
18 |                                    ::std::max_element<ForwardIterator>,
19 |                                    ::std::max<ForwardIterator>());
20 |   }
21 | 
22 | 
23 |   template<class ForwardIterator, class Compare>
24 |     ForwardIterator parallel_execution_policy::max_element(ForwardIterator first, 
25 |                                                            ForwardIterator last,
26 |                                                            Compare comp) const {
27 |     return detail::diffract_gather(first, last,
28 |                                    ::std::max_element<ForwardIterator, Compare>,
29 |                                    ::std::max<ForwardIterator>(),
30 |                                    comp);
31 |   }
32 | 
33 | } // namespace v1
34 | } // namespace parallel
35 | } // namespace experimental
36 | } // namespace std
37 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/par/min_element.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_PARALLEL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | #include <experimental/bits/parallel/algos/par/diffract.h>
 7 | 
 8 | namespace std {
 9 | namespace experimental {
10 | namespace parallel {
11 | inline namespace v1 {
12 | 
13 |   template<class ForwardIterator>
14 |     ForwardIterator parallel_execution_policy::min_element(ForwardIterator first, 
15 |                                                            ForwardIterator last) const 
16 |   {
17 |     return detail::diffract_gather(first, last,
18 |                                    ::std::min_element<ForwardIterator>,
19 |                                    ::std::min<ForwardIterator>());
20 |   }
21 | 
22 | 
23 |   template<class ForwardIterator, class Compare>
24 |     ForwardIterator parallel_execution_policy::min_element(ForwardIterator first, 
25 |                                                            ForwardIterator last,
26 |                                                            Compare comp) const {
27 |     return detail::diffract_gather(first, last,
28 |                                    ::std::min_element<ForwardIterator, Compare>,
29 |                                    ::std::min<ForwardIterator>(),
30 |                                    comp);
31 |   }
32 | 
33 | } // namespace v1
34 | } // namespace parallel
35 | } // namespace experimental
36 | } // namespace std
37 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/par/minmax_element.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_PARALLEL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | #include <experimental/bits/parallel/algos/par/diffract.h>
 7 | 
 8 | namespace std {
 9 | namespace experimental {
10 | namespace parallel {
11 | inline namespace v1 {
12 | 
13 |   template<class ForwardIt>
14 |     pair<ForwardIt, ForwardIt>
15 |       parallel_execution_policy::minmax_element(ForwardIt first, ForwardIt last) const 
16 |   {
17 |     return this->minmax_element(first, last, std::less<typename iterator_traits<ForwardIt>::value_type>());
18 |   }
19 | 
20 |   template<class ForwardIt, class Compare>
21 |     pair<ForwardIt, ForwardIt>
22 |       parallel_execution_policy::minmax_element(ForwardIt first, ForwardIt last, 
23 |                                                 Compare comp) const 
24 |   {
25 |     return detail::diffract_gather(first, last,
26 |                                    std::minmax_element<ForwardIt, Compare>,
27 |                                    [](const pair<ForwardIt,ForwardIt> &a, const pair<ForwardIt,ForwardIt> &b)
28 |                                      -> pair<ForwardIt,ForwardIt> 
29 |                                    {
30 |                                      return make_pair(min(a.first, b.first), max(a.second, b.second));
31 |                                    },
32 |                                    comp);
33 |   }
34 | 
35 | } // namespace v1
36 | } // namespace parallel
37 | } // namespace experimental
38 | } // namespace std
39 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/par/none_of.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_PARALLEL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | #include <experimental/bits/parallel/algos/par/diffract.h>
 7 | 
 8 | namespace std {
 9 | namespace experimental {
10 | namespace parallel {
11 | inline namespace v1 {
12 | 
13 |   template<class InputIterator, class Predicate>
14 |     bool parallel_execution_policy::none_of(InputIterator first, InputIterator last, Predicate pred) const
15 |   {
16 |     return detail::diffract_gather(first, last, 
17 |                                    std::none_of<InputIterator, Predicate>,
18 |                                    std::bit_and<bool>());
19 |   }
20 | 
21 | } // namespace v1
22 | } // namespace parallel
23 | } // namespace experimental
24 | } // namespace std
25 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/par/reduce.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_PARALLEL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | #include <experimental/bits/parallel/algos/par/diffract.h>
 7 | 
 8 | namespace std {
 9 | namespace experimental {
10 | namespace parallel {
11 | inline namespace v1 {
12 | 
13 |   namespace detail {
14 |     template<class InputIterator, class T, class BinaryOperation>
15 |     T partial_reduce(InputIterator first, InputIterator last, BinaryOperation op)
16 |     {
17 |       typename std::iterator_traits<InputIterator>::value_type sum = *first;
18 |       while (++first != last) sum = op(sum, *first);
19 |       return sum;
20 |     }
21 |   } 
22 | 
23 |   template<class InputIterator, class T, class BinaryOperation>
24 |     T parallel_execution_policy::reduce(InputIterator first, InputIterator last, T init,
25 |                   BinaryOperation binary_op) const 
26 |   {
27 |     if(first == last) return init;
28 |     return binary_op(detail::diffract_gather(first, last, 
29 |                                              detail::partial_reduce,
30 |                                              binary_op), init);
31 |   }
32 | 
33 |   template<class InputIterator, class T>
34 |     T parallel_execution_policy::reduce(InputIterator first, InputIterator last, T init) const 
35 |   {
36 |     return this->reduce(first, last, init, ::std::plus<T>());
37 |   }
38 | 
39 |   template<class InputIterator>
40 |     typename iterator_traits<InputIterator>::value_type
41 |       parallel_execution_policy::reduce(InputIterator first, InputIterator last) const {
42 |     typedef typename iterator_traits<InputIterator>::value_type T;
43 |     return this->reduce(first, last, T{});
44 |   }
45 | 
46 | } // namespace v1
47 | } // namespace parallel
48 | } // namespace experimental
49 | } // namespace std
50 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/par/replace.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_PARALLEL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | #include <experimental/bits/parallel/algos/par/diffract.h>
 7 | 
 8 | namespace std {
 9 | namespace experimental {
10 | namespace parallel {
11 | inline namespace v1 {
12 | 
13 |   template<class ForwardIterator, class T>
14 |     void parallel_execution_policy::replace(ForwardIterator first, ForwardIterator last,
15 |                       const T& old_value, const T& new_value) const {
16 |       detail::diffract(first, last, std::replace<ForwardIterator, T>, old_value, new_value);
17 |     }
18 | 
19 | } // namespace v1
20 | } // namespace parallel
21 | } // namespace experimental
22 | } // namespace std
23 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/par/replace_if.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_PARALLEL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | #include <experimental/bits/parallel/algos/par/diffract.h>
 7 | 
 8 | namespace std {
 9 | namespace experimental {
10 | namespace parallel {
11 | inline namespace v1 {
12 | 
13 |   template<class ForwardIterator, class Predicate, class T>
14 |     void parallel_execution_policy::replace_if(ForwardIterator first, ForwardIterator last,
15 |                                                Predicate pred, const T& new_value) const {
16 |     detail::diffract(first, last, std::replace_if<ForwardIterator, Predicate, T>, pred, new_value);
17 |   }
18 | 
19 | } // namespace v1
20 | } // namespace parallel
21 | } // namespace experimental
22 | } // namespace std
23 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/par/sort.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_PARALLEL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | #include <experimental/bits/parallel/algos/par/diffract.h> 
 7 | #include <vector>
 8 | 
 9 | namespace std {
10 | namespace experimental {
11 | namespace parallel {
12 | inline namespace v1 {
13 | 
14 |   template<class RandomAccessIterator>
15 |     void parallel_execution_policy::sort(RandomAccessIterator first, RandomAccessIterator last) const 
16 |   {
17 |     return this->sort(first, last, std::less<typename iterator_traits<RandomAccessIterator>::value_type>());
18 |   }
19 | 
20 |   template<class RandomAccessIterator, class Compare>
21 |     void parallel_execution_policy::sort(RandomAccessIterator first, RandomAccessIterator last, 
22 |                                            Compare comp) const 
23 |   {
24 |     // 2 stage sort:
25 |     // - stage 1: divide the range and sort sub-ranges individually
26 |     // - stage 2: tree reduction using std::inplace_merge
27 | 
28 |     // stage 1
29 |     auto __sort_fct = (void(*)(RandomAccessIterator, RandomAccessIterator, Compare))::std::sort;
30 |     detail::diffract(first, last, __sort_fct, comp);
31 | 
32 |     // stage 2
33 |     // TODO: we could use the parallel version of std::inplace_merge
34 |     
35 |     // split the ranges
36 |     auto ranges = detail::splitRange(first, last);
37 | 
38 |     // begin/middle/end triple for inplace_merge
39 |     struct Triple {RandomAccessIterator begin, middle, end;};
40 | 
41 |     // tree reduction for inplace_merge, until there is only one range
42 |     while(ranges.size() > 1){
43 |       // container for the sub-ranges at the next reduction level
44 |       vector<pair<RandomAccessIterator,RandomAccessIterator>> new_ranges;
45 | 
46 |       // group the sub-ranges in triples instead of pairs
47 |       vector<Triple> merge_ranges;
48 |       for(auto it = begin(ranges); it != end(ranges); ++it){
49 |         auto n = next(it);
50 |         // if there is a next pair, create a triple
51 |         if(n != end(ranges)){
52 |           new_ranges.push_back(make_pair(it->first, n->second));
53 |           merge_ranges.push_back({it->first, it->second, n->second});
54 |           it++;
55 |         }
56 |         // otherwise it is an orphan range, add it to the list of sub-ranges
57 |         else {
58 |           new_ranges.push_back(*it);
59 |         }
60 |       }
61 | 
62 |       // merge the triples in pairs
63 |       auto merge_op = 
64 |         [&](const Triple & t) {
65 |           std::inplace_merge(t.begin, t.middle, t.end, comp);
66 |         };
67 |       detail::diffract(begin(merge_ranges), end(merge_ranges), 
68 |                        std::for_each<typename vector<Triple>::iterator, decltype(merge_op)>,
69 |                        merge_op);
70 | 
71 |       // move to the next reduction level.
72 |       ranges = new_ranges;
73 |     }
74 |   }
75 | 
76 | } // namespace v1
77 | } // namespace parallel
78 | } // namespace experimental
79 | } // namespace std
80 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/par/stable_sort.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_PARALLEL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | #include <experimental/bits/parallel/algos/par/diffract.h> 
 7 | #include <vector>
 8 | 
 9 | namespace std {
10 | namespace experimental {
11 | namespace parallel {
12 | inline namespace v1 {
13 | 
14 |   template<class RandomAccessIterator>
15 |     void parallel_execution_policy::stable_sort(RandomAccessIterator first, RandomAccessIterator last) const 
16 |   {
17 |     return this->stable_sort(first, last, 
18 |                              std::less<typename iterator_traits<RandomAccessIterator>::value_type>());
19 |   }
20 | 
21 |   template<class RandomAccessIterator, class Compare>
22 |     void parallel_execution_policy::stable_sort(RandomAccessIterator first, RandomAccessIterator last, 
23 |                                                 Compare comp) const 
24 |   {
25 |     // 2 stage sort:
26 |     // - stage 1: divide the range and sort sub-ranges individually
27 |     // - stage 2: tree reduction using std::inplace_merge
28 | 
29 |     // stage 1
30 |     detail::diffract(first, last, std::stable_sort<RandomAccessIterator, Compare>, comp);
31 | 
32 |     // stage 2
33 |     // TODO: we could use the parallel version of std::inplace_merge
34 |     
35 |     // split the ranges
36 |     auto ranges = detail::splitRange(first, last);
37 | 
38 |     // begin/middle/end triple for inplace_merge
39 |     struct Triple {RandomAccessIterator begin, middle, end;};
40 | 
41 |     // tree reduction for inplace_merge, until there is only one range
42 |     while(ranges.size() > 1){
43 |       // container for the sub-ranges at the next reduction level
44 |       vector<pair<RandomAccessIterator,RandomAccessIterator>> new_ranges;
45 | 
46 |       // group the sub-ranges in triples instead of pairs
47 |       vector<Triple> merge_ranges;
48 |       for(auto it = begin(ranges); it != end(ranges); ++it){
49 |         auto n = next(it);
50 |         // if there is a next pair, create a triple
51 |         if(n != end(ranges)){
52 |           new_ranges.push_back(make_pair(it->first, n->second));
53 |           merge_ranges.push_back({it->first, it->second, n->second});
54 |           it++;
55 |         }
56 |         // otherwise it is an orphan range, add it to the list of sub-ranges
57 |         else {
58 |           new_ranges.push_back(*it);
59 |         }
60 |       }
61 | 
62 |       // merge the triples in pairs
63 |       auto merge_op = 
64 |         [&](const Triple & t) {
65 |           std::inplace_merge(t.begin, t.middle, t.end, comp);
66 |         };
67 |       detail::diffract(begin(merge_ranges), end(merge_ranges), 
68 |                        std::for_each<typename vector<Triple>::iterator, decltype(merge_op)>,
69 |                        merge_op);
70 | 
71 |       // move to the next reduction level.
72 |       ranges = new_ranges;
73 |     }
74 |   }
75 | 
76 | } // namespace v1
77 | } // namespace parallel
78 | } // namespace experimental
79 | } // namespace std
80 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/adjacent_difference.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 | 
13 | } // namespace v1
14 | } // namespace parallel
15 | } // namespace experimental
16 | } // namespace std
17 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/adjacent_find.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class ForwardIterator>
13 |     ForwardIterator sequential_execution_policy::adjacent_find(ForwardIterator first, 
14 |                                                                ForwardIterator last) const{
15 |     return std::adjacent_find(first, last);
16 |   }
17 | 
18 | 
19 |   template<class ForwardIterator, class BinaryPredicate>
20 |     ForwardIterator sequential_execution_policy::adjacent_find(ForwardIterator first, ForwardIterator last,
21 |                                   BinaryPredicate pred) const{
22 |     return std::adjacent_find(first, last, pred);
23 |   }
24 | 
25 | } // namespace v1
26 | } // namespace parallel
27 | } // namespace experimental
28 | } // namespace std
29 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/all_of.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator, class Predicate>
13 |     bool sequential_execution_policy::all_of(InputIterator first, InputIterator last, Predicate pred) const{
14 |     return std::all_of(first, last, pred);
15 |   }
16 | 
17 | } // namespace v1
18 | } // namespace parallel
19 | } // namespace experimental
20 | } // namespace std
21 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/any_of.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator, class Predicate>
13 |     bool sequential_execution_policy::any_of(InputIterator first, InputIterator last, Predicate pred) const{
14 |     return std::any_of(first, last, pred);
15 |   }
16 | 
17 | } // namespace v1
18 | } // namespace parallel
19 | } // namespace experimental
20 | } // namespace std
21 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/copy.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |  template<class InputIterator, class OutputIterator>
13 |     OutputIterator sequential_execution_policy::copy(InputIterator first, InputIterator last,
14 |                              OutputIterator result) const{
15 |     return std::copy(first, last, result);
16 |   }
17 | 
18 | } // namespace v1
19 | } // namespace parallel
20 | } // namespace experimental
21 | } // namespace std
22 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/copy_if.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator, class OutputIterator, class Predicate>
13 |     OutputIterator
14 |       sequential_execution_policy::copy_if(InputIterator first, InputIterator last,
15 |                    OutputIterator result, Predicate pred) const{
16 |     return std::copy_if(first, last, result, pred);
17 |   }
18 | 
19 | } // namespace v1
20 | } // namespace parallel
21 | } // namespace experimental
22 | } // namespace std
23 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/copy_n.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator, class Size, class OutputIterator>
13 |     OutputIterator sequential_execution_policy::copy_n(InputIterator first, Size n,
14 |                                                        OutputIterator result) const {
15 |     return std::copy_n(first, n, result);
16 |   }
17 | 
18 | } // namespace v1
19 | } // namespace parallel
20 | } // namespace experimental
21 | } // namespace std
22 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/count.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator, class EqualityComparable>
13 |     typename iterator_traits<InputIterator>::difference_type
14 |       sequential_execution_policy::count(InputIterator first, InputIterator last, 
15 |                                          const EqualityComparable &value) const{
16 |     return std::count(first, last, value);
17 |   }
18 | 
19 | } // namespace v1
20 | } // namespace parallel
21 | } // namespace experimental
22 | } // namespace std
23 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/count_if.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator, class Predicate>
13 |     typename iterator_traits<InputIterator>::difference_type
14 |       sequential_execution_policy::count_if(InputIterator first, InputIterator last, Predicate pred) const {
15 |     return std::count_if(first, last, pred);
16 |   }
17 | 
18 | } // namespace v1
19 | } // namespace parallel
20 | } // namespace experimental
21 | } // namespace std
22 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/equal.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator1, class InputIterator2>
13 |     bool sequential_execution_policy::equal(InputIterator1 first1, InputIterator1 last1,
14 |                     InputIterator2 first2) const {
15 |     return std::equal(first1, last1, first2);
16 |   }
17 | 
18 | 
19 |   template<class InputIterator1, class InputIterator2, class BinaryPredicate>
20 |     bool sequential_execution_policy::equal(InputIterator1 first1, InputIterator1 last1,
21 |                     InputIterator2 first2, BinaryPredicate pred) const {
22 |     return std::equal(first1, last1, first2, pred);
23 |   }
24 | 
25 | } // namespace v1
26 | } // namespace parallel
27 | } // namespace experimental
28 | } // namespace std
29 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/exclusive_scan.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 | 
13 | } // namespace v1
14 | } // namespace parallel
15 | } // namespace experimental
16 | } // namespace std
17 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/fill.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class ForwardIterator, class T>
13 |     void sequential_execution_policy::fill(ForwardIterator first, ForwardIterator last, const T& value) const {
14 |     std::fill(first, last, value);
15 |   }
16 | 
17 | } // namespace v1
18 | } // namespace parallel
19 | } // namespace experimental
20 | } // namespace std
21 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/fill_n.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class OutputIterator, class Size, class T>
13 |     OutputIterator sequential_execution_policy::fill_n(OutputIterator first, Size n, const T& value) const 
14 |   {
15 |     return std::fill_n(first, n, value);
16 |   }
17 | 
18 | } // namespace v1
19 | } // namespace parallel
20 | } // namespace experimental
21 | } // namespace std
22 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/find.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator, class T>
13 |     InputIterator sequential_execution_policy::find(InputIterator first, InputIterator last,
14 |                        const T& value) const {
15 |     return std::find(first, last, value);
16 |   }
17 | 
18 | } // namespace v1
19 | } // namespace parallel
20 | } // namespace experimental
21 | } // namespace std
22 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/find_end.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class ForwardIterator1, class ForwardIterator2>
13 |     ForwardIterator1
14 |       sequential_execution_policy::find_end(ForwardIterator1 first1, ForwardIterator1 last1,
15 |                     ForwardIterator2 first2, ForwardIterator2 last2) const {
16 |     return std::find_end(first1, last1, first2, last2);
17 |   }
18 | 
19 |   template<class ForwardIterator1, class ForwardIterator2,
20 |            class BinaryPredicate>
21 |     ForwardIterator1
22 |       sequential_execution_policy::find_end(ForwardIterator1 first1, ForwardIterator1 last1,
23 |                     ForwardIterator2 first2, ForwardIterator2 last2,
24 |                     BinaryPredicate pred) const {
25 |     return std::find_end(first1, last1, first2, last2, pred);
26 |   }
27 | 
28 | } // namespace v1
29 | } // namespace parallel
30 | } // namespace experimental
31 | } // namespace std
32 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/find_first_of.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator, class ForwardIterator>
13 |     InputIterator
14 |       sequential_execution_policy::find_first_of(InputIterator first1, InputIterator last1,
15 |                          ForwardIterator first2, ForwardIterator last2) const {
16 |     return std::find_first_of(first1, last1, first2, last2);
17 |   }
18 | 
19 | 
20 |   template<class InputIterator, class ForwardIterator,
21 |            class BinaryPredicate>
22 |     InputIterator
23 |       sequential_execution_policy::find_first_of(InputIterator first1, InputIterator last1,
24 |                          ForwardIterator first2, ForwardIterator last2,
25 |                          BinaryPredicate pred) const {
26 |     return std::find_first_of(first1, last1, first2, last2, pred);
27 |   }
28 | 
29 | } // namespace v1
30 | } // namespace parallel
31 | } // namespace experimental
32 | } // namespace std
33 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/find_if.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator, class Predicate>
13 |     InputIterator sequential_execution_policy::find_if(InputIterator first, InputIterator last,
14 |                           Predicate pred) const {
15 |     return std::find_if(first, last, pred);
16 |   }
17 | 
18 | } // namespace v1
19 | } // namespace parallel
20 | } // namespace experimental
21 | } // namespace std
22 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/find_if_not.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator, class Predicate>
13 |     InputIterator sequential_execution_policy::find_if_not(InputIterator first, InputIterator last,
14 |                               Predicate pred) const {
15 |     return std::find_if_not(first, last, pred);
16 |   }
17 | 
18 | } // namespace v1
19 | } // namespace parallel
20 | } // namespace experimental
21 | } // namespace std
22 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/for_each.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator, class Function>
13 |   void sequential_execution_policy::for_each(InputIterator first, InputIterator last, Function f) const { 
14 |     std::for_each(first, last, f);
15 |   }
16 | 
17 | } // namespace v1
18 | } // namespace parallel
19 | } // namespace experimental
20 | } // namespace std
21 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/for_each_n.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator, class Size, class Function>
13 |     InputIterator sequential_execution_policy::for_each_n(InputIterator first, Size n,
14 |                                                           Function f) const 
15 |   {
16 |     if(n < 0)
17 |       return first;
18 |     auto end = first;
19 |     advance(end, n);
20 |     std::for_each(first, end, f);
21 |     return end;
22 |   }
23 | 
24 | } // namespace v1
25 | } // namespace parallel
26 | } // namespace experimental
27 | } // namespace std
28 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/generate.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class ForwardIterator, class Generator>
13 |     void sequential_execution_policy::generate(ForwardIterator first, ForwardIterator last, Generator gen) const {
14 |     std::generate(first, last, gen);
15 |   }
16 | 
17 | } // namespace v1
18 | } // namespace parallel
19 | } // namespace experimental
20 | } // namespace std
21 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/generate_n.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class OutputIterator, class Size, class Generator>
13 |     OutputIterator sequential_execution_policy::generate_n(OutputIterator first, Size n, Generator gen) const {
14 |     return std::generate_n(first, n, gen);
15 |   }
16 | 
17 | } // namespace v1
18 | } // namespace parallel
19 | } // namespace experimental
20 | } // namespace std
21 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/includes.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator1, class InputIterator2>
13 |     bool sequential_execution_policy::includes(InputIterator1 first1, InputIterator1 last1,
14 |                        InputIterator2 first2, InputIterator2 last2) const {
15 |     return std::includes(first1, last1, first2, last2);
16 |   }
17 | 
18 | 
19 |   template<class InputIterator1, class InputIterator2, class Compare>
20 |     bool sequential_execution_policy::includes(InputIterator1 first1, InputIterator1 last1,
21 |                        InputIterator2 first2, InputIterator2 last2,
22 |                        Compare comp) const {
23 |     return std::includes(first1, last1, first2, last2, comp);
24 |   }
25 | 
26 | } // namespace v1
27 | } // namespace parallel
28 | } // namespace experimental
29 | } // namespace std
30 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/inclusive_scan.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 | 
13 | } // namespace v1
14 | } // namespace parallel
15 | } // namespace experimental
16 | } // namespace std
17 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/inner_product.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 | 
13 | 
14 | } // namespace v1
15 | } // namespace parallel
16 | } // namespace experimental
17 | } // namespace std
18 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/inplace_merge.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class BidirectionalIterator>
13 |     void sequential_execution_policy::inplace_merge(BidirectionalIterator first,
14 |                             BidirectionalIterator middle,
15 |                             BidirectionalIterator last) const {
16 |     std::inplace_merge(first, middle, last);
17 |   }
18 | 
19 | 
20 |   template<class BidirectionalIterator,
21 |            class Compare>
22 |     void sequential_execution_policy::inplace_merge(BidirectionalIterator first,
23 |                             BidirectionalIterator middle,
24 |                             BidirectionalIterator last, Compare comp) const {
25 |     std::inplace_merge(first, middle, last, comp);
26 |   }
27 | 
28 | } // namespace v1
29 | } // namespace parallel
30 | } // namespace experimental
31 | } // namespace std
32 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/is_heap.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class ForwardIterator>
13 |     bool sequential_execution_policy::is_heap(ForwardIterator first, ForwardIterator last) const {
14 |     return std::is_heap(first, last);
15 |   }
16 | 
17 | 
18 |   template<class ForwardIterator, class Compare>
19 |     bool sequential_execution_policy::is_heap(ForwardIterator first, ForwardIterator last,
20 |                         Compare comp) const {
21 |     return std::is_heap(first, last, comp);
22 |   }
23 | 
24 | } // namespace v1
25 | } // namespace parallel
26 | } // namespace experimental
27 | } // namespace std
28 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/is_heap_until.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class ForwardIterator>
13 |     ForwardIterator sequential_execution_policy::is_heap_until(ForwardIterator first, ForwardIterator last) const {
14 |     return std::is_heap_until(first, last);
15 |   }
16 | 
17 |   template<class ForwardIterator, class Compare>
18 |     ForwardIterator sequential_execution_policy::is_heap_until(ForwardIterator first, ForwardIterator last,
19 |                                                                Compare comp) const {
20 |     return std::is_heap_until(first, last, comp);
21 |   }
22 | 
23 | 
24 | } // namespace v1
25 | } // namespace parallel
26 | } // namespace experimental
27 | } // namespace std
28 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/is_partitioned.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator, class Predicate>
13 |     bool sequential_execution_policy::is_partitioned(InputIterator first, InputIterator last, Predicate pred) const {
14 |     return std::is_partitioned(first, last, pred);
15 |   }
16 | 
17 | } // namespace v1
18 | } // namespace parallel
19 | } // namespace experimental
20 | } // namespace std
21 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/is_sorted.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class ForwardIterator>
13 |     bool sequential_execution_policy::is_sorted(ForwardIterator first, ForwardIterator last) const {
14 |     return std::is_sorted(first, last);
15 |   }
16 | 
17 | 
18 |   template<class ForwardIterator, class Compare>
19 |     bool sequential_execution_policy::is_sorted(ForwardIterator first, ForwardIterator last,
20 |                         Compare comp) const {
21 |     return std::is_sorted(first, last, comp);
22 |   }
23 | 
24 | } // namespace v1
25 | } // namespace parallel
26 | } // namespace experimental
27 | } // namespace std
28 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/is_sorted_until.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class ForwardIterator>
13 |     ForwardIterator sequential_execution_policy::is_sorted_until(ForwardIterator first, 
14 |                                                                  ForwardIterator last) const {
15 |     return std::is_sorted_until(first, last);
16 |   }
17 | 
18 |   template<class ForwardIterator, class Compare>
19 |     ForwardIterator sequential_execution_policy::is_sorted_until(ForwardIterator first, 
20 |                                                                  ForwardIterator last,
21 |                                                                  Compare comp) const {
22 |     return std::is_sorted_until(first, last, comp);
23 |   }
24 | 
25 | } // namespace v1
26 | } // namespace parallel
27 | } // namespace experimental
28 | } // namespace std
29 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/lexicographical_compare.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator1, class InputIterator2>
13 |     bool
14 |       sequential_execution_policy::lexicographical_compare(InputIterator1 first1, 
15 |                                                            InputIterator1 last1,
16 |                                                            InputIterator2 first2, 
17 |                                                            InputIterator2 last2) const {
18 |     return std::lexicographical_compare(first1, last1, first2, last2);
19 |   }
20 | 
21 | 
22 | 
23 |   template<class InputIterator1, class InputIterator2, class Compare>
24 |     bool
25 |       sequential_execution_policy::lexicographical_compare(InputIterator1 first1, 
26 |                                                            InputIterator1 last1,
27 |                                                            InputIterator2 first2, 
28 |                                                            InputIterator2 last2,
29 |                                                            Compare comp) const {
30 |     return std::lexicographical_compare(first1, last1, first2, last2, comp);
31 |   }
32 | 
33 | } // namespace v1
34 | } // namespace parallel
35 | } // namespace experimental
36 | } // namespace std
37 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/max_element.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class ForwardIterator>
13 |     ForwardIterator sequential_execution_policy::max_element(ForwardIterator first, 
14 |                                                              ForwardIterator last) const {
15 |     return std::max_element(first, last);
16 |   }
17 | 
18 | 
19 |   template<class ForwardIterator, class Compare>
20 |     ForwardIterator sequential_execution_policy::max_element(ForwardIterator first, 
21 |                                                              ForwardIterator last,
22 |                                                              Compare comp) const {
23 |     return std::max_element(first, last, comp);
24 |   }
25 | 
26 | } // namespace v1
27 | } // namespace parallel
28 | } // namespace experimental
29 | } // namespace std
30 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/merge.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator1, class InputIterator2,
13 |            class OutputIterator>
14 |     OutputIterator
15 |       sequential_execution_policy::merge(InputIterator1 first1, InputIterator1 last1,
16 |                  InputIterator2 first2, InputIterator2 last2,
17 |                  OutputIterator result) const {
18 |     return std::merge(first1, last1, first2, last2, result);
19 |   }
20 | 
21 | 
22 |   template<class InputIterator1, class InputIterator2,
23 |            class OutputIterator, class Compare>
24 |     OutputIterator
25 |       sequential_execution_policy::merge(InputIterator1 first1, InputIterator1 last1,
26 |                  InputIterator2 first2, InputIterator2 last2,
27 |                  OutputIterator result, Compare comp) const {
28 |     return std::merge(first1, last1, first2, last2, result, comp);
29 |   }
30 | 
31 | } // namespace v1
32 | } // namespace parallel
33 | } // namespace experimental
34 | } // namespace std
35 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/min_element.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class ForwardIterator>
13 |     ForwardIterator sequential_execution_policy::min_element(ForwardIterator first, 
14 |                                                              ForwardIterator last) const {
15 |     return std::min_element(first, last);
16 |   }
17 | 
18 | 
19 |   template<class ForwardIterator, class Compare>
20 |     ForwardIterator sequential_execution_policy::min_element(ForwardIterator first, 
21 |                                                              ForwardIterator last,
22 |                                                              Compare comp) const {
23 |     return std::min_element(first, last, comp);
24 |   }
25 | 
26 | } // namespace v1
27 | } // namespace parallel
28 | } // namespace experimental
29 | } // namespace std
30 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/minmax_element.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class ForwardIterator>
13 |     pair<ForwardIterator, ForwardIterator>
14 |       sequential_execution_policy::minmax_element(ForwardIterator first, ForwardIterator last) const {
15 |     return std::minmax_element(first, last);
16 |   }
17 | 
18 |   template<class ForwardIterator, class Compare>
19 |     pair<ForwardIterator, ForwardIterator>
20 |       sequential_execution_policy::minmax_element(ForwardIterator first, ForwardIterator last, 
21 |                                                   Compare comp) const {
22 |     return std::minmax_element(first, last, comp);
23 |   }
24 | 
25 | } // namespace v1
26 | } // namespace parallel
27 | } // namespace experimental
28 | } // namespace std
29 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/mismatch.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator1, class InputIterator2>
13 |     pair<InputIterator1,InputIterator2>
14 |       sequential_execution_policy::mismatch(InputIterator1 first1, InputIterator1 last1, 
15 |                     InputIterator2 first2) const {
16 |     return std::mismatch(first1, last1, first2);
17 |   }
18 | 
19 |   template<class InputIterator1, class InputIterator2, class BinaryPredicate>
20 |     pair<InputIterator1,InputIterator2>
21 |       sequential_execution_policy::mismatch(InputIterator1 first1, InputIterator1 last1,
22 |                     InputIterator2 first2, BinaryPredicate pred) const {
23 |     return std::mismatch(first1, last1, first2, pred);
24 |   }
25 | 
26 | } // namespace v1
27 | } // namespace parallel
28 | } // namespace experimental
29 | } // namespace std
30 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/move.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator, class OutputIterator>
13 |     OutputIterator
14 |       sequential_execution_policy::move(InputIterator first, InputIterator last,
15 |                 OutputIterator result) const {
16 |     return std::move(first, last, result);
17 |   }
18 | 
19 | } // namespace v1
20 | } // namespace parallel
21 | } // namespace experimental
22 | } // namespace std
23 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/none_of.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator, class Predicate>
13 |     bool sequential_execution_policy::none_of(InputIterator first, InputIterator last, Predicate pred) const {
14 |     return std::none_of(first, last, pred);
15 |   }
16 | 
17 | } // namespace v1
18 | } // namespace parallel
19 | } // namespace experimental
20 | } // namespace std
21 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/nth_element.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class RandomAccessIterator>
13 |     void sequential_execution_policy::nth_element(RandomAccessIterator first, RandomAccessIterator nth,
14 |                           RandomAccessIterator last) const {
15 |     std::nth_element(first, nth, last);
16 |   }
17 | 
18 | 
19 |   template<class RandomAccessIterator, class Compare>
20 |     void sequential_execution_policy::nth_element(RandomAccessIterator first, RandomAccessIterator nth,
21 |                           RandomAccessIterator last, Compare comp) const {
22 |     std::nth_element(first, nth, last, comp);
23 |   }
24 | 
25 | } // namespace v1
26 | } // namespace parallel
27 | } // namespace experimental
28 | } // namespace std
29 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/partial_sort.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class RandomAccessIterator>
13 |     void sequential_execution_policy::partial_sort(RandomAccessIterator first,
14 |                            RandomAccessIterator middle,
15 |                            RandomAccessIterator last) const {
16 |     std::partial_sort(first, middle, last);
17 |   }
18 | 
19 |   template<class RandomAccessIterator, class Compare>
20 |     void sequential_execution_policy::partial_sort(RandomAccessIterator first,
21 |                            RandomAccessIterator middle,
22 |                            RandomAccessIterator last,
23 |                            Compare comp) const {
24 |     std::partial_sort(first, middle, last, comp);
25 |   }
26 | 
27 | } // namespace v1
28 | } // namespace parallel
29 | } // namespace experimental
30 | } // namespace std
31 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/partial_sort_copy.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator, class RandomAccessIterator>
13 |     RandomAccessIterator
14 |       sequential_execution_policy::partial_sort_copy(InputIterator first, InputIterator last,
15 |                              RandomAccessIterator result_first,
16 |                              RandomAccessIterator result_last) const {
17 |     return std::partial_sort_copy(first, last, result_first, result_last);
18 |   }
19 | 
20 |   template<class InputIterator, class RandomAccessIterator,
21 |            class Compare>
22 |     RandomAccessIterator
23 |       sequential_execution_policy::partial_sort_copy(InputIterator first, InputIterator last,
24 |                              RandomAccessIterator result_first,
25 |                              RandomAccessIterator result_last,
26 |                              Compare comp) const {
27 |     return std::partial_sort_copy(first, last, result_first, result_last);
28 |   }
29 | 
30 | } // namespace v1
31 | } // namespace parallel
32 | } // namespace experimental
33 | } // namespace std
34 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/partition.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class ForwardIterator, class Predicate>
13 |     ForwardIterator
14 |       sequential_execution_policy::partition(ForwardIterator first,
15 |                      ForwardIterator last, Predicate pred) const {
16 |     return std::partition(first, last, pred);
17 |   }
18 | 
19 | } // namespace v1
20 | } // namespace parallel
21 | } // namespace experimental
22 | } // namespace std
23 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/partition_copy.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator, class OutputIterator1,
13 |            class OutputIterator2, class Predicate>
14 |   pair<OutputIterator1, OutputIterator2>
15 |   sequential_execution_policy::partition_copy(InputIterator first, InputIterator last,
16 |                       OutputIterator1 out_true, OutputIterator2 out_false,
17 |                       Predicate pred) const {
18 |     return partition_copy(first, last, out_true, out_false, pred);
19 |   }
20 | 
21 | } // namespace v1
22 | } // namespace parallel
23 | } // namespace experimental
24 | } // namespace std
25 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/partition_point.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class ForwardIterator, class Predicate>
13 |     ForwardIterator sequential_execution_policy::partition_point(ForwardIterator first,
14 |                                          ForwardIterator last,
15 |                                          Predicate pred) const {
16 |     return std::partition_point(first, last, pred);
17 |   }
18 | 
19 | } // namespace v1
20 | } // namespace parallel
21 | } // namespace experimental
22 | } // namespace std
23 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/reduce.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator>
13 |     typename iterator_traits<InputIterator>::value_type
14 |       sequential_execution_policy::reduce(InputIterator first, InputIterator last) const {
15 |     typedef typename iterator_traits<InputIterator>::value_type T;
16 |     return std::accumulate(first, last, T{});
17 |   }
18 | 
19 |   template<class InputIterator, class T>
20 |     T sequential_execution_policy::reduce(InputIterator first, InputIterator last, T init) const {
21 |     return std::accumulate(first, last, init);
22 |   }
23 | 
24 |   template<class InputIterator, class T, class BinaryOperation>
25 |     T sequential_execution_policy::reduce(InputIterator first, InputIterator last, T init,
26 |                   BinaryOperation binary_op) const {
27 |     return std::accumulate(first, last, init, binary_op);
28 |   }
29 | 
30 | } // namespace v1
31 | } // namespace parallel
32 | } // namespace experimental
33 | } // namespace std
34 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/remove.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class ForwardIterator, class T>
13 |     ForwardIterator sequential_execution_policy::remove(ForwardIterator first, 
14 |                                                         ForwardIterator last, 
15 |                                                         const T& value) const {
16 |     return std::remove(first, last, value);
17 |   }
18 | 
19 | } // namespace v1
20 | } // namespace parallel
21 | } // namespace experimental
22 | } // namespace std
23 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/remove_copy.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator, class OutputIterator, class T>
13 |     OutputIterator
14 |       sequential_execution_policy::remove_copy(InputIterator first, InputIterator last,
15 |                   OutputIterator result, const T& value) const {
16 |     return std::remove_copy(first, last, result, value);
17 |   }
18 | 
19 | } // namespace v1
20 | } // namespace parallel
21 | } // namespace experimental
22 | } // namespace std
23 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/remove_copy_if.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator, class OutputIterator, class Predicate>
13 |     OutputIterator
14 |       sequential_execution_policy::remove_copy_if(InputIterator first, InputIterator last,
15 |                           OutputIterator result, Predicate pred) const {
16 |     return std::remove_copy_if(first, last, result, pred);
17 |   }
18 | 
19 | } // namespace v1
20 | } // namespace parallel
21 | } // namespace experimental
22 | } // namespace std
23 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/remove_if.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class ForwardIterator, class Predicate>
13 |     ForwardIterator sequential_execution_policy::remove_if(ForwardIterator first, 
14 |                                                            ForwardIterator last, 
15 |                                                            Predicate pred) const {
16 |     return std::remove_if(first, last, pred);
17 |   }
18 | 
19 | } // namespace v1
20 | } // namespace parallel
21 | } // namespace experimental
22 | } // namespace std
23 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/replace.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class ForwardIterator, class T>
13 |     void sequential_execution_policy::replace(ForwardIterator first, ForwardIterator last,
14 |                       const T& old_value, const T& new_value) const {
15 |     return std::replace(first, last, old_value, new_value);
16 |   }
17 | 
18 | } // namespace v1
19 | } // namespace parallel
20 | } // namespace experimental
21 | } // namespace std
22 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/replace_copy.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator, class OutputIterator, class T>
13 |     OutputIterator
14 |       sequential_execution_policy::replace_copy(InputIterator first, InputIterator last,
15 |                         OutputIterator result,
16 |                         const T& old_value, const T& new_value) const {
17 |     return std::replace_copy(first, last, result, old_value, new_value);
18 |   }
19 | 
20 | } // namespace v1
21 | } // namespace parallel
22 | } // namespace experimental
23 | } // namespace std
24 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/replace_copy_if.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator, class OutputIterator, class Predicate, class T>
13 |     OutputIterator
14 |       sequential_execution_policy::replace_copy_if(InputIterator first, InputIterator last,
15 |                            OutputIterator result, Predicate pred,
16 |                            const T& new_value) const {
17 |     return std::replace_copy_if(first, last, result, pred, new_value);
18 |   }
19 | 
20 | } // namespace v1
21 | } // namespace parallel
22 | } // namespace experimental
23 | } // namespace std
24 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/replace_if.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class ForwardIterator, class Predicate, class T>
13 |     void sequential_execution_policy::replace_if(ForwardIterator first, ForwardIterator last,
14 |                          Predicate pred, const T& new_value) const {
15 |     return std::replace_if(first, last, pred, new_value);
16 |   }
17 | 
18 | } // namespace v1
19 | } // namespace parallel
20 | } // namespace experimental
21 | } // namespace std
22 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/reverse.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class BidirectionalIterator>
13 |     void sequential_execution_policy::reverse(BidirectionalIterator first, BidirectionalIterator last) const {
14 |     std::reverse(first, last);
15 |   }
16 | 
17 | } // namespace v1
18 | } // namespace parallel
19 | } // namespace experimental
20 | } // namespace std
21 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/reverse_copy.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class BidirectionalIterator, class OutputIterator>
13 |     OutputIterator
14 |       sequential_execution_policy::reverse_copy(BidirectionalIterator first,
15 |                         BidirectionalIterator last, OutputIterator result) const {
16 |     return std::reverse_copy(first, last, result);
17 |   }
18 | 
19 | } // namespace v1
20 | } // namespace parallel
21 | } // namespace experimental
22 | } // namespace std
23 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/rotate.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class ForwardIterator>
13 |     ForwardIterator
14 |       sequential_execution_policy::rotate(ForwardIterator first, ForwardIterator middle,
15 |                   ForwardIterator last) const {
16 |     std::rotate(first, middle, last);
17 |     // TODO: this is not optimal.
18 |     advance(first, distance(middle, last));
19 |     return first;
20 |   }
21 | 
22 | } // namespace v1
23 | } // namespace parallel
24 | } // namespace experimental
25 | } // namespace std
26 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/rotate_copy.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class ForwardIterator, class OutputIterator>
13 |     OutputIterator
14 |       sequential_execution_policy::rotate_copy(ForwardIterator first, ForwardIterator middle,
15 |                        ForwardIterator last, OutputIterator result) const {
16 |     return std::rotate_copy(first, middle, last, result);
17 |   }
18 | 
19 | } // namespace v1
20 | } // namespace parallel
21 | } // namespace experimental
22 | } // namespace std
23 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/search.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class ForwardIterator1, class ForwardIterator2>
13 |     ForwardIterator1 sequential_execution_policy::search(ForwardIterator1 first1, ForwardIterator1 last1,
14 |                                  ForwardIterator2 first2, ForwardIterator2 last2) const {
15 |     return std::search(first1, last1, first2, last2);
16 |   }
17 | 
18 |   template<class ForwardIterator1, class ForwardIterator2,
19 |            class BinaryPredicate>
20 |     ForwardIterator1 sequential_execution_policy::search(ForwardIterator1 first1, ForwardIterator1 last1,
21 |                                  ForwardIterator2 first2, ForwardIterator2 last2,
22 |                                  BinaryPredicate pred) const {
23 |     return std::search(first1, last1, first2, last2, pred);
24 |   }
25 | 
26 | } // namespace v1
27 | } // namespace parallel
28 | } // namespace experimental
29 | } // namespace std
30 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/search_n.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class ForwardIterator, class Size, class T>
13 |     ForwardIterator sequential_execution_policy::search_n(ForwardIterator first, ForwardIterator last, Size count,
14 |                                   const T& value) const {
15 |     return std::search_n(first, last, count, value);
16 |   }
17 | 
18 |   template<class ForwardIterator, class Size, class T, class BinaryPredicate>
19 |     ForwardIterator sequential_execution_policy::search_n(ForwardIterator first, ForwardIterator last, Size count,
20 |                                   const T& value, BinaryPredicate pred) const {
21 |     return std::search_n(first, last, count, value, pred);
22 |   }
23 | 
24 | } // namespace v1
25 | } // namespace parallel
26 | } // namespace experimental
27 | } // namespace std
28 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/set_difference.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator1, class InputIterator2,
13 |            class OutputIterator>
14 |     OutputIterator
15 |       sequential_execution_policy::set_difference(InputIterator1 first1, InputIterator1 last1,
16 |                           InputIterator2 first2, InputIterator2 last2,
17 |                           OutputIterator result) const {
18 |     return std::set_difference(first1, last1, first2, last2, result);
19 |   }
20 | 
21 | 
22 |   template<class InputIterator1, class InputIterator2,
23 |            class OutputIterator, class Compare>
24 |     OutputIterator
25 |       sequential_execution_policy::set_difference(InputIterator1 first1, InputIterator1 last1,
26 |                           InputIterator2 first2, InputIterator2 last2,
27 |                           OutputIterator result, Compare comp) const {
28 |     return std::set_difference(first1, last1, first2, last2, result, comp);
29 |   }
30 | 
31 | } // namespace v1
32 | } // namespace parallel
33 | } // namespace experimental
34 | } // namespace std
35 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/set_intersection.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator1, class InputIterator2,
13 |            class OutputIterator>
14 |     OutputIterator
15 |       sequential_execution_policy::set_intersection(InputIterator1 first1, InputIterator1 last1,
16 |                             InputIterator2 first2, InputIterator2 last2,
17 |                             OutputIterator result) const {
18 |     return std::set_intersection(first1, last1, first2, last2, result);
19 |   }
20 | 
21 | 
22 |   template<class InputIterator1, class InputIterator2,
23 |            class OutputIterator, class Compare>
24 |     OutputIterator
25 |       sequential_execution_policy::set_intersection(InputIterator1 first1, InputIterator1 last1,
26 |                             InputIterator2 first2, InputIterator2 last2,
27 |                             OutputIterator result, Compare comp) const {
28 |     return std::set_intersection(first1, last1, first2, last2, result, comp);
29 |   }
30 | 
31 | } // namespace v1
32 | } // namespace parallel
33 | } // namespace experimental
34 | } // namespace std
35 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/set_symmetric_difference.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator1, class InputIterator2,
13 |            class OutputIterator>
14 |     OutputIterator
15 |       sequential_execution_policy::set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
16 |                                     InputIterator2 first2, InputIterator2 last2,
17 |                                     OutputIterator result) const {
18 |     return std::set_symmetric_difference(first1, last1, first2, last2, result);
19 |   }
20 | 
21 | 
22 |   template<class InputIterator1, class InputIterator2,
23 |            class OutputIterator, class Compare>
24 |     OutputIterator
25 |       sequential_execution_policy::set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
26 |                                     InputIterator2 first2, InputIterator2 last2,
27 |                                     OutputIterator result, Compare comp) const {
28 |     return std::set_symmetric_difference(first1, last1, first2, last2, result, comp);
29 |   }
30 | 
31 | } // namespace v1
32 | } // namespace parallel
33 | } // namespace experimental
34 | } // namespace std
35 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/set_union.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator1, class InputIterator2,
13 |            class OutputIterator>
14 |     OutputIterator
15 |       sequential_execution_policy::set_union(InputIterator1 first1, InputIterator1 last1,
16 |                      InputIterator2 first2, InputIterator2 last2,
17 |                      OutputIterator result) const {
18 |     return std::set_union(first1, last1, first2, last2, result);
19 |   }
20 | 
21 | 
22 |   template<class InputIterator1, class InputIterator2,
23 |            class OutputIterator, class Compare>
24 |     OutputIterator
25 |       sequential_execution_policy::set_union(InputIterator1 first1, InputIterator1 last1,
26 |                      InputIterator2 first2, InputIterator2 last2,
27 |                      OutputIterator result, Compare comp) const {
28 |     return std::set_union(first1, last1, first2, last2, result, comp);
29 |   }
30 | 
31 | } // namespace v1
32 | } // namespace parallel
33 | } // namespace experimental
34 | } // namespace std
35 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/sort.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class RandomAccessIterator>
13 |     void sequential_execution_policy::sort(RandomAccessIterator first, RandomAccessIterator last) const {
14 |     std::sort(first, last);
15 |   }
16 | 
17 |   template<class RandomAccessIterator, class Compare>
18 |     void sequential_execution_policy::sort(RandomAccessIterator first, RandomAccessIterator last, 
19 |                                            Compare comp) const {
20 |     std::sort(first, last, comp);
21 |   }
22 | 
23 | } // namespace v1
24 | } // namespace parallel
25 | } // namespace experimental
26 | } // namespace std
27 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/stable_partition.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class BidirectionalIterator, class Predicate>
13 |     BidirectionalIterator
14 |       sequential_execution_policy::stable_partition(BidirectionalIterator first,
15 |                             BidirectionalIterator last, Predicate pred) const {
16 |     return std::stable_partition(first, last, pred);
17 |   }
18 | 
19 | } // namespace v1
20 | } // namespace parallel
21 | } // namespace experimental
22 | } // namespace std
23 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/stable_sort.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class RandomAccessIterator>
13 |     void sequential_execution_policy::stable_sort(RandomAccessIterator first, 
14 |                                                   RandomAccessIterator last) const {
15 |     std::stable_sort(first, last);
16 |   }
17 | 
18 |   template<class RandomAccessIterator, class Compare>
19 |     void sequential_execution_policy::stable_sort(RandomAccessIterator first, 
20 |                                                   RandomAccessIterator last,
21 |                                                   Compare comp) const {
22 |     std::stable_sort(first, last, comp);
23 |   }
24 | 
25 | } // namespace v1
26 | } // namespace parallel
27 | } // namespace experimental
28 | } // namespace std
29 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/swap_ranges.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class ForwardIterator1, class ForwardIterator2>
13 |     ForwardIterator2
14 |       sequential_execution_policy::swap_ranges(ForwardIterator1 first1,
15 |                                                ForwardIterator1 last1,
16 |                                                ForwardIterator2 first2) const 
17 |   {
18 |     return std::swap_ranges(first1, last1, first2);
19 |   }
20 | 
21 | } // namespace v1
22 | } // namespace parallel
23 | } // namespace experimental
24 | } // namespace std
25 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/transform.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator, class OutputIterator,
13 |            class UnaryOperation>
14 |     OutputIterator sequential_execution_policy::transform(InputIterator first, InputIterator last,
15 |                                   OutputIterator result, UnaryOperation op) const {
16 |     return std::transform(first, last, result, op);
17 |   }
18 | 
19 | 
20 |   template<class InputIterator1, class InputIterator2, class OutputIterator,
21 |            class BinaryOperation>
22 |     OutputIterator
23 |       sequential_execution_policy::transform(InputIterator1 first1, InputIterator1 last1,
24 |                      InputIterator2 first2, OutputIterator result,
25 |                      BinaryOperation binary_op) const {
26 |     return std::transform(first1, last1, first2, result, binary_op);
27 |   }
28 | 
29 | } // namespace v1
30 | } // namespace parallel
31 | } // namespace experimental
32 | } // namespace std
33 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/unique.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class ForwardIterator>
13 |     ForwardIterator sequential_execution_policy::unique(ForwardIterator first, ForwardIterator last) const {
14 |     return std::unique(first, last);
15 |   }
16 | 
17 | 
18 |   template<class ForwardIterator, typename BinaryPredicate>
19 |     ForwardIterator sequential_execution_policy::unique(ForwardIterator first, ForwardIterator last,
20 |                            BinaryPredicate pred) const {
21 |     return std::unique(first, last, pred);
22 |   }
23 | 
24 | } // namespace v1
25 | } // namespace parallel
26 | } // namespace experimental
27 | } // namespace std
28 | 


--------------------------------------------------------------------------------
/include/experimental/bits/parallel/algos/seq/unique_copy.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EXPERIMENTAL_N3554_POLICY_SEQUENTIAL
 2 | #error Include <parallel/algorithm> or <parallel/utility>
 3 | #endif
 4 | 
 5 | #include <algorithm>
 6 | 
 7 | namespace std {
 8 | namespace experimental {
 9 | namespace parallel {
10 | inline namespace v1 {
11 | 
12 |   template<class InputIterator, class OutputIterator>
13 |     OutputIterator
14 |       sequential_execution_policy::unique_copy(InputIterator first, InputIterator last,
15 |                   OutputIterator result) const {
16 |     return std::unique_copy(first, last, result);
17 |   }
18 | 
19 | 
20 |   template<class InputIterator, class OutputIterator, class BinaryPredicate>
21 |     OutputIterator
22 |       sequential_execution_policy::unique_copy(InputIterator first, InputIterator last,
23 |                   OutputIterator result, BinaryPredicate pred) const {
24 |     return std::unique_copy(first, last, result, pred);
25 |   }
26 | 
27 | } // namespace v1
28 | } // namespace parallel
29 | } // namespace experimental
30 | } // namespace std
31 | 


--------------------------------------------------------------------------------
/test/CMakeLists.txt:
--------------------------------------------------------------------------------
  1 | cmake_minimum_required(VERSION 2.8.7 FATAL_ERROR)
  2 | project(n3554_TestSuite)
  3 | 
  4 | set(CMAKE_CXX_FLAGS "-std=c++14 -g") # -std=c++0x is supported by g++-4.6 (-std=c++11 not)
  5 | set(CMAKE_CXX_FLAGS_DEBUG "-std=c++14 -g -O0")
  6 | 
  7 | # Enable ExternalProject CMake module
  8 | include(ExternalProject)
  9 | 
 10 | # Set the build type if it isn't already
 11 | if(NOT CMAKE_BUILD_TYPE)
 12 |   set(CMAKE_BUILD_TYPE Release)
 13 | endif()
 14 | 
 15 | option (UNITY_BUILD
 16 |   "Compact all test files into one compilation unit." OFF)
 17 | 
 18 | # Set default ExternalProject root directory
 19 | set_directory_properties(PROPERTIES EP_PREFIX ${CMAKE_BINARY_DIR}/ThirdParty)
 20 | 
 21 | # Add gtest
 22 | ExternalProject_Add(
 23 |     googletest
 24 |     SVN_REPOSITORY http://googletest.googlecode.com/svn/trunk/
 25 |     SVN_REVISION -r 660
 26 |     TIMEOUT 10
 27 |     # Force separate output paths for debug and release builds to allow easy
 28 |     # identification of correct lib in subsequent TARGET_LINK_LIBRARIES commands
 29 |     CMAKE_ARGS -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
 30 |                -DCMAKE_ARCHIVE_OUTPUT_DIRECTORY_DEBUG:PATH=DebugLibs
 31 |                -DCMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELEASE:PATH=ReleaseLibs
 32 |                -Dgtest_force_shared_crt=ON
 33 |     # Disable update and install step
 34 |     UPDATE_COMMAND ""
 35 |     INSTALL_COMMAND ""
 36 |     # Wrap download, configure and build steps in a script to log output
 37 |     LOG_DOWNLOAD ON
 38 |     LOG_CONFIGURE ON
 39 |     LOG_BUILD ON)
 40 | 
 41 | # Specify include dir
 42 | ExternalProject_Get_Property(googletest source_dir)
 43 | include_directories(${source_dir}/include)
 44 | include_directories(../include/)
 45 | 
 46 | file(GLOB_RECURSE ALL_TESTS
 47 |      alg.modifying.operations/*.cpp alg.nonmodifying/*.cpp alg.sorting/*.cpp)
 48 | 
 49 | # Specify MainTest's link libraries
 50 | ExternalProject_Get_Property(googletest binary_dir)
 51 | if(MSVC)
 52 |   set(Suffix ".lib")
 53 | else()
 54 |   set(Suffix ".a")
 55 |   set(Pthread "-pthread")
 56 | endif()
 57 | 
 58 | set(TEST_LIBS 
 59 |     debug ${binary_dir}/DebugLibs/${CMAKE_FIND_LIBRARY_PREFIXES}gtest${Suffix} 
 60 |     debug ${binary_dir}/DebugLibs/${CMAKE_FIND_LIBRARY_PREFIXES}gtest_main${Suffix}
 61 |     optimized ${binary_dir}/ReleaseLibs/${CMAKE_FIND_LIBRARY_PREFIXES}gtest${Suffix} 
 62 |     optimized ${binary_dir}/ReleaseLibs/${CMAKE_FIND_LIBRARY_PREFIXES}gtest_main${Suffix}
 63 |     ${Pthread})
 64 | 
 65 | enable_testing()
 66 | 
 67 | if( UNITY_BUILD )
 68 |   
 69 |   file(WRITE ${CMAKE_BINARY_DIR}/unity.cpp "/* Generated file, do not edit */\n" )
 70 |   foreach(file ${ALL_TESTS})
 71 |     file(APPEND ${CMAKE_BINARY_DIR}/unity.cpp "#include <${file}>\n")
 72 |   endforeach()
 73 | 
 74 |   add_executable(test_std ${CMAKE_BINARY_DIR}/unity.cpp)
 75 |   add_dependencies(test_std googletest)
 76 |   target_link_libraries(test_std ${TEST_LIBS})
 77 |   add_test(std test_std)
 78 | 
 79 |   add_executable(test_seq ${CMAKE_BINARY_DIR}/unity.cpp)
 80 |   set_target_properties(test_seq PROPERTIES COMPILE_DEFINITIONS
 81 |                         "EXECUTION_POLICY=std::experimental::parallel::seq")
 82 |   add_dependencies(test_seq googletest)
 83 |   target_link_libraries(test_seq ${TEST_LIBS})
 84 |   add_test(std::seq test_seq)
 85 | 
 86 | 
 87 | else()
 88 | 
 89 |   # standard algos
 90 |   FOREACH (TEST ${ALL_TESTS})
 91 |     GET_FILENAME_COMPONENT(TESTNAME ${TEST} NAME_WE)
 92 |     add_executable(test_${TESTNAME} ${TEST})
 93 |     add_dependencies(test_${TESTNAME} googletest)
 94 |     target_link_libraries(test_${TESTNAME} ${TEST_LIBS})
 95 |     add_test(std::${TESTNAME} test_${TESTNAME})
 96 |   ENDFOREACH(TEST)
 97 | 
 98 |   # std::seq policy
 99 |   FOREACH (TEST ${ALL_TESTS})
100 |     GET_FILENAME_COMPONENT(TESTNAME ${TEST} NAME_WE)
101 |     set(UNITTEST test-seq_${TESTNAME})
102 |     add_executable(${UNITTEST} ${TEST})
103 |     set_target_properties(${UNITTEST} PROPERTIES COMPILE_DEFINITIONS 
104 |                         "EXECUTION_POLICY=std::experimental::parallel::seq")
105 |     add_dependencies(${UNITTEST} googletest)
106 |     target_link_libraries(${UNITTEST} ${TEST_LIBS})
107 |     add_test(seq-std::${TESTNAME} ${UNITTEST})
108 |   ENDFOREACH(TEST)
109 | 
110 | endif()
111 | 
112 | 


--------------------------------------------------------------------------------
/test/README.md:
--------------------------------------------------------------------------------
 1 | # n3554 Test Suite
 2 | 
 3 | ## Requirements
 4 | 
 5 | * You need cmake, version 2.8 or upper.
 6 | * You need SVN, to pull gtest...
 7 | * You need a C++11 compiler (obviously...)
 8 | 
 9 | ## Instructions
10 | 
11 | * Create a build directory, anywhere.
12 | * Run `cmake` with this path.
13 | * Run `make`.
14 | * Run `make test` to run the test suite.
15 | * You can run each test individually by calling its executable.
16 | 
17 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.gen.copy/copy.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(copy, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.gen.copy/copy_if.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(copy_if, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.gen.copy/copy_n.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(copy_n, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.gen.fill/fill.cpp:
--------------------------------------------------------------------------------
 1 | #include "gtest/gtest.h"
 2 | 
 3 | #include <vector>
 4 | 
 5 | #ifdef EXECUTION_POLICY
 6 | #include <experimental/parallel/algorithm>
 7 | #else
 8 | #include <algorithm>
 9 | #endif
10 | 
11 | TEST(fill, Simple){
12 |   using namespace std;
13 | #ifdef EXECUTION_POLICY
14 |   using namespace std::experimental;
15 | #endif
16 | 
17 |   vector<int> v(10000);
18 | 
19 |   fill(
20 | #ifdef EXECUTION_POLICY
21 |             EXECUTION_POLICY,
22 | #endif
23 |             begin(v), end(v),
24 |             123);
25 | 
26 |   EXPECT_EQ(10000, v.size());
27 |   for(auto i : v){
28 |     EXPECT_EQ(123, v[i]);
29 |   }
30 | }
31 | 
32 | TEST(fill, partial){
33 |   using namespace std;
34 | #ifdef EXECUTION_POLICY
35 |   using namespace std::experimental;
36 | #endif
37 | 
38 |   vector<int> v(10000);
39 |   v[800]=23;
40 |   v[900]=42;
41 | 
42 |   fill(
43 | #ifdef EXECUTION_POLICY
44 |             EXECUTION_POLICY,
45 | #endif
46 |             begin(v), next(begin(v),800),
47 |             123);
48 | 
49 |   EXPECT_EQ(10000, v.size());
50 |   for(auto i=0; i < 800; i++){
51 |     EXPECT_EQ(123, v[i]);
52 |   }
53 |   EXPECT_EQ(42, v[900]);
54 |   EXPECT_EQ(23, v[800]);
55 | }
56 | 
57 | 
58 | TEST(fill, Empty){
59 |   using namespace std;
60 | #ifdef EXECUTION_POLICY
61 |   using namespace std::experimental;
62 | #endif
63 | 
64 |   vector<int> v;
65 | 
66 |   fill(
67 | #ifdef EXECUTION_POLICY
68 |                 EXECUTION_POLICY,
69 | #endif
70 |                 begin(v), end(v),
71 |                 1);
72 | 
73 |   EXPECT_TRUE(v.empty());
74 | }
75 | 
76 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.gen.fill/fill_n.cpp:
--------------------------------------------------------------------------------
  1 | #include "gtest/gtest.h"
  2 | 
  3 | #include <vector>
  4 | 
  5 | #ifdef EXECUTION_POLICY
  6 | #include <experimental/parallel/algorithm>
  7 | #else
  8 | #include <algorithm>
  9 | #endif
 10 | 
 11 | TEST(fill_n, Lambda){
 12 |   using namespace std;
 13 | #ifdef EXECUTION_POLICY
 14 |   using namespace std::experimental;
 15 | #endif
 16 |   
 17 |   vector<int> v(10000);
 18 | 
 19 |   auto it = fill_n(
 20 | #ifdef EXECUTION_POLICY
 21 |               EXECUTION_POLICY,
 22 | #endif
 23 |               begin(v), v.size(),
 24 |               1);
 25 | 
 26 |   for(auto i : v){
 27 |     EXPECT_EQ(1, v[i]);
 28 |   }
 29 |   EXPECT_EQ(end(v),it);
 30 | }
 31 | 
 32 | TEST(fill_n, partial){
 33 |   using namespace std;
 34 | #ifdef EXECUTION_POLICY
 35 |   using namespace std::experimental;
 36 | #endif
 37 | 
 38 |   vector<int> v(10000);
 39 |   v[8000]=23;
 40 |   v[9000]=42;
 41 | 
 42 |   auto it = fill_n(
 43 | #ifdef EXECUTION_POLICY
 44 |             EXECUTION_POLICY,
 45 | #endif
 46 |             begin(v), 8000,
 47 |             123);
 48 | 
 49 |   EXPECT_EQ(10000, v.size());
 50 |   for(auto i=0; i < 8000; i++){
 51 |     EXPECT_EQ(123, v[i]);
 52 |   }
 53 |   EXPECT_EQ(next(begin(v),8000),it);
 54 |   EXPECT_EQ(42, v[9000]);
 55 |   EXPECT_EQ(23, v[8000]);
 56 | }
 57 | 
 58 | 
 59 | TEST(fill_n, Empty){
 60 |   using namespace std;
 61 | #ifdef EXECUTION_POLICY
 62 |   using namespace std::experimental;
 63 | #endif
 64 |   
 65 |   vector<int> v;
 66 | 
 67 |   auto it = fill_n(
 68 | #ifdef EXECUTION_POLICY
 69 |                   EXECUTION_POLICY,
 70 | #endif
 71 |                   begin(v), 0,
 72 |                   1);
 73 | 
 74 |   EXPECT_TRUE(v.empty());
 75 |   EXPECT_EQ(begin(v),it);
 76 | }
 77 | 
 78 | 
 79 | TEST(fill_n, Negative){
 80 |   using namespace std;
 81 | #ifdef EXECUTION_POLICY
 82 |   using namespace std::experimental;
 83 | #endif
 84 |   
 85 |   vector<int> v(100);
 86 | 
 87 |   auto it = fill_n(
 88 | #ifdef EXECUTION_POLICY
 89 |                   EXECUTION_POLICY,
 90 | #endif
 91 |                   begin(v), -100,
 92 |                   1);
 93 | 
 94 |   EXPECT_EQ(begin(v),it);
 95 |   for(auto i : v){
 96 |     EXPECT_EQ(0, v[i]);
 97 |   }
 98 | }
 99 | 
100 | 
101 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.gen.generate/generate.cpp:
--------------------------------------------------------------------------------
 1 | #include "gtest/gtest.h"
 2 | 
 3 | #include <vector>
 4 | #include <cstdlib>
 5 | 
 6 | #ifdef EXECUTION_POLICY
 7 | #include <experimental/algorithm>
 8 | #else
 9 | #include <algorithm>
10 | #endif
11 | 
12 | TEST(generate, Lambda){
13 |   using namespace std;
14 | #ifdef EXECUTION_POLICY
15 |   using namespace std::experimental;
16 | #endif
17 |   
18 |   vector<int> v(100);
19 | 
20 |   generate(
21 | #ifdef EXECUTION_POLICY
22 |                 EXECUTION_POLICY,
23 | #endif
24 |                 begin(v), end(v),
25 |                 [](){ return rand() % 100 + 123; });
26 | 
27 |   EXPECT_EQ(100, v.size());
28 |   for(auto i : v){
29 |     EXPECT_TRUE(i >= 123);
30 |     EXPECT_TRUE(i <= 222);
31 |   }
32 | }
33 | 
34 | 
35 | TEST(generate, Functor){
36 |   using namespace std;
37 | #ifdef EXECUTION_POLICY
38 |   using namespace std::experimental;
39 | #endif
40 |   
41 |   vector<int> v(100);
42 | 
43 |   struct Functor {
44 |     int operator()() {
45 |       return rand() % 100 + 123;
46 |     }
47 |   } f;
48 | 
49 |   generate(
50 | #ifdef EXECUTION_POLICY
51 |                 EXECUTION_POLICY,
52 | #endif
53 |                 begin(v), end(v),
54 |                 f);
55 | 
56 |   EXPECT_EQ(100, v.size());
57 |   for(auto i : v){
58 |     EXPECT_TRUE(i >= 123);
59 |     EXPECT_TRUE(i <= 222);
60 |   }
61 | }
62 | 
63 | 
64 | TEST(generate, Empty){
65 |   using namespace std;
66 | #ifdef EXECUTION_POLICY
67 |   using namespace std::experimental;
68 | #endif
69 |   
70 |   vector<int> v;
71 | 
72 |   generate(
73 | #ifdef EXECUTION_POLICY
74 |                 EXECUTION_POLICY,
75 | #endif
76 |                 begin(v), end(v),
77 |                 [](){ return rand() % 100 + 123; });
78 | 
79 |   EXPECT_TRUE(v.empty());
80 | }
81 | 
82 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.gen.generate/generate_n.cpp:
--------------------------------------------------------------------------------
  1 | #include "gtest/gtest.h"
  2 | 
  3 | #include <vector>
  4 | #include <cstdlib>
  5 | 
  6 | #ifdef EXECUTION_POLICY
  7 | #include <experimental/algorithm>
  8 | #else
  9 | #include <algorithm>
 10 | #endif
 11 | 
 12 | TEST(generate_n, Lambda){
 13 |   using namespace std;
 14 | #ifdef EXECUTION_POLICY
 15 |   using namespace std::experimental;
 16 | #endif
 17 |   
 18 |   vector<int> v(100);
 19 | 
 20 |   generate_n(
 21 | #ifdef EXECUTION_POLICY
 22 |                   EXECUTION_POLICY,
 23 | #endif
 24 |                   begin(v), v.size(),
 25 |                   [](){ return rand() % 100 + 123; });
 26 | 
 27 |   EXPECT_EQ(100, v.size());
 28 |   for(auto i : v){
 29 |     EXPECT_TRUE(i >= 123);
 30 |     EXPECT_TRUE(i <= 222);
 31 |   }
 32 | }
 33 | 
 34 | 
 35 | TEST(generate_n, Functor){
 36 |   using namespace std;
 37 | #ifdef EXECUTION_POLICY
 38 |   using namespace std::experimental;
 39 | #endif
 40 |   
 41 |   vector<int> v(100);
 42 | 
 43 |   struct Functor {
 44 |     int operator()() {
 45 |       return rand() % 100 + 123;
 46 |     }
 47 |   } f;
 48 | 
 49 |   generate_n(
 50 | #ifdef EXECUTION_POLICY
 51 |                   EXECUTION_POLICY,
 52 | #endif
 53 |                   begin(v), v.size(),
 54 |                   f);
 55 | 
 56 |   EXPECT_EQ(100, v.size());
 57 |   for(auto i : v){
 58 |     EXPECT_TRUE(i >= 123);
 59 |     EXPECT_TRUE(i <= 222);
 60 |   }
 61 | }
 62 | 
 63 | 
 64 | TEST(generate_n, Empty){
 65 |   using namespace std;
 66 | #ifdef EXECUTION_POLICY
 67 |   using namespace std::experimental;
 68 | #endif
 69 |   
 70 |   vector<int> v;
 71 | 
 72 |   generate_n(
 73 | #ifdef EXECUTION_POLICY
 74 |                   EXECUTION_POLICY,
 75 | #endif
 76 |                   begin(v), 0,
 77 |                   [](){ return 1; });
 78 | 
 79 |   EXPECT_TRUE(v.empty());
 80 | }
 81 | 
 82 | 
 83 | TEST(generate_n, Negative){
 84 |   using namespace std;
 85 | #ifdef EXECUTION_POLICY
 86 |   using namespace std::experimental;
 87 | #endif
 88 |   
 89 |   vector<int> v(100);
 90 | 
 91 |   generate_n(
 92 | #ifdef EXECUTION_POLICY
 93 |                   EXECUTION_POLICY,
 94 | #endif
 95 |                   begin(v), -100,
 96 |                   [](){ return 1; });
 97 | 
 98 |   EXPECT_EQ(100, v.size());
 99 |   for(auto i : v){
100 |     EXPECT_EQ(0, i);
101 |   }
102 | }
103 | 
104 | 
105 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.gen.move/move.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(move, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.gen.partitions/is_partitioned.cpp:
--------------------------------------------------------------------------------
 1 | #include "gtest/gtest.h"
 2 | 
 3 | #include <vector>
 4 | 
 5 | #ifdef EXECUTION_POLICY
 6 | #include <experimental/algorithm>
 7 | #else
 8 | #include <algorithm>
 9 | #endif
10 | 
11 | TEST(is_partitioned, Patitioned){
12 |   using namespace std;
13 | #ifdef EXECUTION_POLICY
14 |   using namespace std::experimental;
15 | #endif
16 | 
17 |   const vector<int> v{1,3,5,7,9,11,2,4,6,8,10,12};
18 | 
19 |   EXPECT_TRUE(is_partitioned(
20 | #ifdef EXECUTION_POLICY
21 |                              EXECUTION_POLICY,
22 | #endif
23 |                              begin(v), end(v),
24 |                              [](const int &i){ return i % 2 == 1;}));
25 | }
26 | 
27 | TEST(is_partitioned, NotPatitioned){
28 |   using namespace std;
29 | #ifdef EXECUTION_POLICY
30 |   using namespace std::experimental;
31 | #endif
32 | 
33 |   const vector<int> v{1,2,3,4,5,6,7,8,9,10,11,12};
34 | 
35 |   EXPECT_FALSE(is_partitioned(
36 | #ifdef EXECUTION_POLICY
37 |                               EXECUTION_POLICY,
38 | #endif
39 |                               begin(v), end(v),
40 |                               [](const int &i){ return i % 2 == 1;}));
41 | }
42 | 
43 | TEST(is_partitioned, Empty){
44 |   using namespace std;
45 | #ifdef EXECUTION_POLICY
46 |   using namespace std::experimental;
47 | #endif
48 | 
49 |   const vector<int> v;
50 | 
51 |   EXPECT_TRUE(is_partitioned(
52 | #ifdef EXECUTION_POLICY
53 |                              EXECUTION_POLICY,
54 | #endif
55 |                              begin(v), end(v),
56 |                              [](const int &i){ return i % 2 == 1;}));
57 | }
58 | 
59 | 
60 | 
61 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.gen.partitions/partition.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(partition, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.gen.partitions/partition_copy.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(partition_copy, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.gen.partitions/partition_point.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(partition_point, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.gen.partitions/stable_partition.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(stable_partition, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.gen.remove/remove.cpp:
--------------------------------------------------------------------------------
 1 | #include "gtest/gtest.h"
 2 | 
 3 | #include <vector>
 4 | 
 5 | #ifdef EXECUTION_POLICY
 6 | #include <experimental/algorithm>
 7 | #else
 8 | #include <algorithm>
 9 | #endif
10 | 
11 | TEST(remove, Present_unique){
12 |   using namespace std;
13 | #ifdef EXECUTION_POLICY
14 |   using namespace std::experimental;
15 | #endif
16 |   
17 |   vector<int> v{1,2,3,4,5,6,7,8,9,10,11,12};
18 |   const vector<int> g{1,2,3,4,5,6,  8,9,10,11,12};
19 | 
20 |   auto range = 
21 |     remove(
22 | #ifdef EXECUTION_POLICY
23 |                  EXECUTION_POLICY,
24 | #endif
25 |                  begin(v), end(v),
26 |                  7);
27 | 
28 |   EXPECT_EQ(distance(g.begin(), g.end()), distance(v.begin(), range)); 
29 |   EXPECT_TRUE(equal(v.begin(), range, g.begin()));
30 | }
31 | 
32 | TEST(remove, Present_multiple){
33 |   using namespace std;
34 | #ifdef EXECUTION_POLICY
35 |   using namespace std::experimental;
36 | #endif
37 |   
38 |   vector<int> v{1,2,3,4,5,6,7,8,9,10,7,7};
39 |   const vector<int> g{1,2,3,4,5,6,  8,9,10    };
40 | 
41 |   auto range =
42 |      remove(
43 | #ifdef EXECUTION_POLICY
44 |                  EXECUTION_POLICY,
45 | #endif
46 |                  begin(v), end(v),
47 |                  7);
48 | 
49 |   EXPECT_EQ(distance(g.begin(), g.end()), distance(v.begin(), range));
50 |   EXPECT_TRUE(equal(v.begin(), range, g.begin()));
51 | }
52 | 
53 | TEST(remove, Missing){
54 |   using namespace std;
55 | #ifdef EXECUTION_POLICY
56 |   using namespace std::experimental;
57 | #endif
58 |   
59 |   vector<int> v{1,2,3,4,5,6,7,8,9,10,11,12};
60 |   const vector<int> g{1,2,3,4,5,6,7,8,9,10,11,12};
61 | 
62 |   auto range =
63 |      remove(
64 | #ifdef EXECUTION_POLICY
65 |                  EXECUTION_POLICY,
66 | #endif
67 |                  begin(v), end(v),
68 |                  20);
69 | 
70 |   EXPECT_EQ(distance(g.begin(), g.end()), distance(v.begin(), range));
71 |   EXPECT_TRUE(equal(v.begin(), range, g.begin()));
72 | }
73 | 
74 | TEST(remove, Empty){
75 | using namespace std;
76 | #ifdef EXECUTION_POLICY
77 |   using namespace std::experimental;
78 | #endif
79 |   
80 |   vector<int> v, g;
81 | 
82 |   auto range =
83 |      remove(
84 | #ifdef EXECUTION_POLICY
85 |                  EXECUTION_POLICY,
86 | #endif
87 |                  begin(v), end(v),
88 |                  0);
89 | 
90 |   EXPECT_EQ(distance(g.begin(), g.end()), distance(v.begin(), range));
91 |   EXPECT_TRUE(equal(v.begin(), range, g.begin()));
92 | }
93 | 
94 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.gen.remove/remove_copy.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(remove_copy, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.gen.remove/remove_copy_if.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(remove_copy_if, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.gen.remove/remove_if.cpp:
--------------------------------------------------------------------------------
 1 | #include "gtest/gtest.h"
 2 | 
 3 | #include <vector>
 4 | 
 5 | #ifdef EXECUTION_POLICY
 6 | #include <experimental/algorithm>
 7 | #else
 8 | #include <algorithm>
 9 | #endif
10 | 
11 | TEST(remove_if, Present_unique){
12 |   using namespace std;
13 | #ifdef EXECUTION_POLICY
14 |   using namespace std::experimental;
15 | #endif
16 |   
17 |   vector<int> v{1,2,3,4,5,6,7,8,9,10,11,12};
18 |   const vector<int> g{1,2,3,4,5,6,  8,9,10,11,12};
19 | 
20 |   auto range = 
21 |   remove_if(
22 | #ifdef EXECUTION_POLICY
23 |                  EXECUTION_POLICY,
24 | #endif
25 |                  begin(v), end(v),
26 |                  [](const int &i) { return i == 7;});
27 | 
28 |   EXPECT_EQ(distance(g.begin(), g.end()), distance(v.begin(), range)); 
29 |   EXPECT_TRUE(equal(v.begin(), range, g.begin()));
30 | }
31 | 
32 | TEST(remove_if, Present_multiple){
33 |   using namespace std;
34 | #ifdef EXECUTION_POLICY
35 |   using namespace std::experimental;
36 | #endif
37 |   
38 |   vector<int> v{1,2,3,4,5,6,7,8,9,10,7,7};
39 |   const vector<int> g{1,2,3,4,5,6,  8,9,10    };
40 | 
41 |   auto range =
42 |   remove_if(
43 | #ifdef EXECUTION_POLICY
44 |                  EXECUTION_POLICY,
45 | #endif
46 |                  begin(v), end(v),
47 |                  [](const int &i) { return i == 7;});
48 | 
49 |   EXPECT_EQ(distance(g.begin(), g.end()), distance(v.begin(), range));
50 |   EXPECT_TRUE(equal(v.begin(), range, g.begin()));
51 | }
52 | 
53 | TEST(remove_if, Missing){
54 |   using namespace std;
55 | #ifdef EXECUTION_POLICY
56 |   using namespace std::experimental;
57 | #endif
58 |   
59 |   vector<int> v{1,2,3,4,5,6,7,8,9,10,11,12};
60 |   const vector<int> g{1,2,3,4,5,6,7,8,9,10,11,12};
61 | 
62 |   auto range =
63 |   remove_if(
64 | #ifdef EXECUTION_POLICY
65 |                  EXECUTION_POLICY,
66 | #endif
67 |                  begin(v), end(v),
68 |                  [](const int &i) { return i == 20;});
69 | 
70 |   EXPECT_EQ(distance(g.begin(), g.end()), distance(v.begin(), range));
71 |   EXPECT_TRUE(equal(v.begin(), range, g.begin()));
72 | }
73 | 
74 | TEST(remove_if, Empty){
75 |   using namespace std;
76 | #ifdef EXECUTION_POLICY
77 |   using namespace std::experimental;
78 | #endif
79 |   
80 |   vector<int> v, g;
81 | 
82 |   auto range =
83 |   remove_if(
84 | #ifdef EXECUTION_POLICY
85 |                  EXECUTION_POLICY,
86 | #endif
87 |                  begin(v), end(v),
88 |                  [](const int &i) { return true;});
89 | 
90 |   EXPECT_EQ(distance(g.begin(), g.end()), distance(v.begin(), range));
91 |   EXPECT_TRUE(equal(v.begin(), range, g.begin()));
92 | }
93 | 
94 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.gen.replace/replace.cpp:
--------------------------------------------------------------------------------
  1 | #include "gtest/gtest.h"
  2 | 
  3 | #include <vector>
  4 | 
  5 | #ifdef EXECUTION_POLICY
  6 | #include <experimental/algorithm>
  7 | #else
  8 | #include <algorithm>
  9 | #endif
 10 | 
 11 | TEST(replace, Present_unique){
 12 |   using namespace std;
 13 | #ifdef EXECUTION_POLICY
 14 |   using namespace std::experimental;
 15 | #endif
 16 |  
 17 |   vector<int> v{1,2,3,4,5,6, 7,8,9,10,11,12};
 18 |   const vector<int> g{1,2,3,4,5,6,77,8,9,10,11,12};
 19 | 
 20 |   replace(
 21 | #ifdef EXECUTION_POLICY
 22 |                EXECUTION_POLICY,
 23 | #endif
 24 |                begin(v), end(v),
 25 |                7, 77);
 26 | 
 27 |   EXPECT_EQ(g, v);
 28 | }
 29 | 
 30 | TEST(replace, OldWithNew)
 31 | {
 32 |   using namespace std;
 33 | #ifdef EXECUTION_POLICY
 34 |   using namespace experimental;
 35 | #endif
 36 |   
 37 |   vector<int> v{1,2,3,4,5,6,7,8,9,10,11,12};
 38 |   const vector<int> gold{1,2,3,4,0,6,7,8,9,10,11,12};
 39 |   int oldVal = 5;
 40 |   int newVal = 0;
 41 | 
 42 |   replace(
 43 | #ifdef EXECUTION_POLICY
 44 |       EXECUTION_POLICY,
 45 | #endif
 46 |       begin(v), end(v), oldVal, newVal);
 47 | 
 48 |   EXPECT_EQ(gold, v);
 49 | }
 50 | 
 51 | TEST(replace, Missing)
 52 | {
 53 |   using namespace std;
 54 | #ifdef EXECUTION_POLICY
 55 |   using namespace experimental;
 56 | #endif
 57 |   
 58 |   vector<int> v{1,2,3,4,5,6,7,8,9,10,11,12};
 59 |   const vector<int> gold{1,2,3,4,5,6,7,8,9,10,11,12};
 60 |   int oldVal = 0;
 61 |   int newVal = 0;
 62 | 
 63 |   replace(
 64 | #ifdef EXECUTION_POLICY
 65 |       EXECUTION_POLICY,
 66 | #endif
 67 |       begin(v), end(v), oldVal, newVal);
 68 | 
 69 |   EXPECT_EQ(gold, v);
 70 | }
 71 | 
 72 | TEST(replace, Empty)
 73 | {
 74 |   using namespace std;
 75 | #ifdef EXECUTION_POLICY
 76 |   using namespace experimental;
 77 | #endif
 78 |   
 79 |   vector<int> v;
 80 |   int oldVal = 0;
 81 |   int newVal = 1;
 82 | 
 83 |   replace(
 84 | #ifdef EXECUTION_POLICY
 85 |       EXECUTION_POLICY,
 86 | #endif
 87 |       begin(v), end(v), oldVal, newVal);
 88 | 
 89 |   EXPECT_TRUE(v.empty());
 90 | }
 91 | 
 92 | TEST(replace, Present_multiple){
 93 |   using namespace std;
 94 | #ifdef EXECUTION_POLICY
 95 |   using namespace std::experimental;
 96 | #endif
 97 |   
 98 |   vector<int> v{1,2,3,4,5,6, 7,8,9,10, 7, 7};
 99 |   const vector<int> g{1,2,3,4,5,6,77,8,9,10,77,77};
100 | 
101 |   replace(
102 | #ifdef EXECUTION_POLICY
103 |                EXECUTION_POLICY,
104 | #endif
105 |                begin(v), end(v),
106 |                7, 77);
107 | 
108 |   EXPECT_EQ(g, v); 
109 | }
110 | 
111 | 
112 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.gen.replace/replace_copy.cpp:
--------------------------------------------------------------------------------
 1 | #include "gtest/gtest.h"
 2 | 
 3 | #include <vector>
 4 | 
 5 | #ifdef EXECUTION_POLICY
 6 | #include <experimental/algorithm>
 7 | #else
 8 | #include <algorithm>
 9 | #endif
10 | 
11 | TEST(replace_copy, OldWithNew)
12 | {
13 |   using namespace std;
14 | #ifdef EXECUTION_POLICY
15 |   using namespace std::experimental;
16 | #endif
17 |   const vector<int> v1{1,2,3,4,5,6,7,8,9,10,11,12};
18 |   vector<int> v2; v2.resize(v1.size());
19 |   const vector<int> gold{1,2,3,4,0,6,7,8,9,10,11,12};
20 |   int oldVal = 5;
21 |   int newVal = 0;
22 | 
23 |   replace_copy(
24 | #ifdef EXECUTION_POLICY
25 |       EXECUTION_POLICY,
26 | #endif
27 |       begin(v1), end(v1), begin(v2), oldVal, newVal);
28 | 
29 |   EXPECT_EQ(gold, v2);
30 | }
31 | 
32 | TEST(replace_copy, Missing)
33 | {
34 |   using namespace std;
35 | #ifdef EXECUTION_POLICY
36 |   using namespace std::experimental;
37 | #endif
38 |   const vector<int> v1{1,2,3,4,5,6,7,8,9,10,11,12};
39 |   vector<int> v2; v2.resize(v1.size());
40 |   const vector<int> gold{1,2,3,4,5,6,7,8,9,10,11,12};
41 |   int oldVal = 0;
42 |   int newVal = 0;
43 | 
44 |   replace_copy(
45 | #ifdef EXECUTION_POLICY
46 |       EXECUTION_POLICY,
47 | #endif
48 |       begin(v1), end(v1), begin(v2), oldVal, newVal);
49 | 
50 |   EXPECT_EQ(gold, v2);
51 | }
52 | 
53 | TEST(replace_copy, Empty)
54 | {
55 |   using namespace std;
56 | #ifdef EXECUTION_POLICY
57 |   using namespace std::experimental;
58 | #endif
59 |   const vector<int> v1;
60 |   vector<int> v2;
61 |   int oldVal = 0;
62 |   int newVal = 1;
63 | 
64 |   replace_copy(
65 | #ifdef EXECUTION_POLICY
66 |       EXECUTION_POLICY,
67 | #endif
68 |       begin(v1), end(v1), begin(v2), oldVal, newVal);
69 | 
70 |   EXPECT_TRUE(v2.empty());
71 | }
72 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.gen.replace/replace_copy_if.cpp:
--------------------------------------------------------------------------------
 1 | #include "gtest/gtest.h"
 2 | 
 3 | #include <vector>
 4 | 
 5 | #ifdef EXECUTION_POLICY
 6 | #include <experimental/algorithm>
 7 | #else
 8 | #include <algorithm>
 9 | #endif
10 | 
11 | TEST(replace_copy_if, EvenWithNew)
12 | {
13 |   using namespace std;
14 | #ifdef EXECUTION_POLICY
15 |   using namespace std::experimental;
16 | #endif
17 |   const vector<int> v1{1,2,3,4,5,6,7,8,9,10,11,12};
18 |   vector<int> v2; v2.resize(v1.size());
19 |   const vector<int> gold{1,0,3,0,5,0,7,0,9,0,11,0};
20 |   auto even = [](int i) { return (i % 2) == 0; };
21 |   int newVal = 0;
22 | 
23 |   replace_copy_if(
24 | #ifdef EXECUTION_POLICY
25 |       EXECUTION_POLICY,
26 | #endif
27 |       begin(v1), end(v1), begin(v2), even, newVal);
28 | 
29 |   EXPECT_EQ(gold, v2);
30 | }
31 | 
32 | TEST(replace_copy_if, Missing)
33 | {
34 |   using namespace std;
35 | #ifdef EXECUTION_POLICY
36 |   using namespace std::experimental;
37 | #endif
38 |   const vector<int> v1{1,2,3,4,5,6,7,8,9,10,11,12};
39 |   vector<int> v2; v2.resize(v1.size());
40 |   const vector<int> gold{1,2,3,4,5,6,7,8,9,10,11,12};
41 |   auto isNull = [](int i) { return i == 0; };
42 |   int newVal = 0;
43 | 
44 |   replace_copy_if(
45 | #ifdef EXECUTION_POLICY
46 |       EXECUTION_POLICY,
47 | #endif
48 |       begin(v1), end(v1), begin(v2), isNull, newVal);
49 | 
50 |   EXPECT_EQ(gold, v2);
51 | }
52 | 
53 | TEST(replace_copy_if, Empty)
54 | {
55 |   using namespace std;
56 | #ifdef EXECUTION_POLICY
57 |   using namespace std::experimental;
58 | #endif
59 |   const vector<int> v1;
60 |   vector<int> v2;
61 |   auto func = [](int i) { return true; };
62 |   int newVal = 1;
63 | 
64 |   replace_copy_if(
65 | #ifdef EXECUTION_POLICY
66 |       EXECUTION_POLICY,
67 | #endif
68 |       begin(v1), end(v1), begin(v2), func, newVal);
69 | 
70 |   EXPECT_TRUE(v2.empty());
71 | }
72 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.gen.replace/replace_if.cpp:
--------------------------------------------------------------------------------
  1 | #include "gtest/gtest.h"
  2 | 
  3 | #include <vector>
  4 | 
  5 | #ifdef EXECUTION_POLICY
  6 | #include <experimental/algorithm>
  7 | #else
  8 | #include <algorithm>
  9 | #endif
 10 | 
 11 | TEST(replace_if, Present_unique){
 12 |   using namespace std;
 13 | #ifdef EXECUTION_POLICY
 14 |   using namespace std::experimental;
 15 | #endif
 16 |         vector<int> v{1,2,3,4,5,6, 7,8,9,10,11,12};
 17 |   const vector<int> g{1,2,3,4,5,6,77,8,9,10,11,12};
 18 | 
 19 |   replace_if(
 20 | #ifdef EXECUTION_POLICY
 21 |              EXECUTION_POLICY,
 22 | #endif
 23 |              begin(v), end(v),
 24 |              [](const int &i) { return i == 7;} , 77);
 25 | 
 26 |   EXPECT_EQ(g, v); 
 27 | }
 28 | 
 29 | TEST(replace_if, EvenWithNew)
 30 | {
 31 |   using namespace std;
 32 | #ifdef EXECUTION_POLICY
 33 |   using namespace std::experimental;
 34 | #endif
 35 |   vector<int> v{1,2,3,4,5,6,7,8,9,10,11,12};
 36 |   const vector<int> gold{1,0,3,0,5,0,7,0,9,0,11,0};
 37 |   auto even = [](int i) { return (i % 2) == 0; };
 38 |   int newVal = 0;
 39 | 
 40 |   replace_if(
 41 | #ifdef EXECUTION_POLICY
 42 |       EXECUTION_POLICY,
 43 | #endif
 44 |       begin(v), end(v), even, newVal);
 45 | 
 46 |   EXPECT_EQ(gold, v);
 47 | }
 48 | 
 49 | TEST(replace_if, Present_multiple){
 50 |   using namespace std;
 51 | #ifdef EXECUTION_POLICY
 52 |   using namespace std::experimental;
 53 | #endif
 54 |         std::vector<int> v{1,2,3,4,5,6, 7,8,9,10, 7, 7};
 55 |   const std::vector<int> g{1,2,3,4,5,6,77,8,9,10,77,77};
 56 | 
 57 |   replace_if(
 58 | #ifdef EXECUTION_POLICY
 59 |              EXECUTION_POLICY,
 60 | #endif
 61 |              begin(v), end(v),
 62 |              [](const int &i) { return i == 7;}, 77);
 63 | 
 64 |   EXPECT_EQ(g, v); 
 65 | }
 66 | 
 67 | TEST(replace_if, Missing){
 68 |   using namespace std;
 69 | #ifdef EXECUTION_POLICY
 70 |   using namespace std::experimental;
 71 | #endif
 72 | 
 73 |         std::vector<int> v{1,2,3,4,5,6,7,8,9,10,11,12};
 74 |   const std::vector<int> g{1,2,3,4,5,6,7,8,9,10,11,12};
 75 | 
 76 |   replace_if(
 77 | #ifdef EXECUTION_POLICY
 78 |              EXECUTION_POLICY,
 79 | #endif
 80 |              begin(v), end(v),
 81 |              [](const int &i) { return i == 20;}, 0);
 82 | 
 83 |   EXPECT_EQ(g, v); 
 84 | }
 85 | 
 86 | TEST(replace_if, Empty){
 87 |   using namespace std;
 88 | #ifdef EXECUTION_POLICY
 89 |   using namespace std::experimental;
 90 | #endif
 91 |   vector<int> v, g;
 92 | 
 93 |   replace_if(
 94 | #ifdef EXECUTION_POLICY
 95 |              EXECUTION_POLICY,
 96 | #endif
 97 |              begin(v), end(v),
 98 |              [](const int &i) { return true;}, 1);
 99 | 
100 |   EXPECT_EQ(g, v); 
101 | }
102 | 
103 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.gen.reverse/reverse.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(reverse, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.gen.reverse/reverse_copy.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(reverse_copy, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.gen.rotate/rotate.cpp:
--------------------------------------------------------------------------------
 1 | #include "gtest/gtest.h"
 2 | 
 3 | #include <vector>
 4 | 
 5 | #ifdef EXECUTION_POLICY
 6 | #include <experimental/algorithm>
 7 | #else
 8 | #include <algorithm>
 9 | #endif
10 | 
11 | TEST(rotate, MoveToLast)
12 | {
13 |   using namespace std;
14 | #ifdef EXECUTION_POLICY
15 |   using namespace std::experimental;
16 | #endif
17 |   vector<int> v{1,2,3,4,5,6,7,8,9,10,11,12};
18 |   const vector<int> gold{2,3,4,5,6,7,8,9,10,11,12,1};
19 | 
20 |   rotate(
21 | #ifdef EXECUTION_POLICY
22 |       EXECUTION_POLICY,
23 | #endif
24 |       begin(v), begin(v)+1, end(v));
25 | 
26 |   EXPECT_EQ(gold, v);
27 | }
28 | 
29 | TEST(rotate, MoveRangeToEnd)
30 | {
31 |   using namespace std;
32 | #ifdef EXECUTION_POLICY
33 |   using namespace std::experimental;
34 | #endif
35 |   vector<int> v{1,2,3,4,5,6,7,8,9,10,11,12};
36 |   const vector<int> gold{7,8,9,10,11,12,1,2,3,4,5,6};
37 | 
38 |   auto middle = [](vector<int>& v) {
39 |     return begin(v) + v.size()/2;
40 |   };
41 | 
42 |   rotate(
43 | #ifdef EXECUTION_POLICY
44 |       EXECUTION_POLICY,
45 | #endif
46 |       begin(v), middle(v), end(v));
47 | 
48 |   EXPECT_EQ(gold, v);
49 | }
50 | 
51 | TEST(rotate, MoveRangeToMiddle)
52 | {
53 |   using namespace std;
54 | #ifdef EXECUTION_POLICY
55 |   using namespace std::experimental;
56 | #endif
57 |   vector<int> v{1,2,3,4,5,6,7,8,9,10,11,12};
58 |   const vector<int> gold{4,5,6,1,2,3,7,8,9,10,11,12};
59 | 
60 |   auto middle = [](vector<int>& v) {
61 |     return begin(v) + v.size()/2;
62 |   };
63 | 
64 |   auto quarter = [](vector<int>& v) {
65 |     return begin(v) + v.size()/4;
66 |   };
67 | 
68 |   rotate(
69 | #ifdef EXECUTION_POLICY
70 |       EXECUTION_POLICY,
71 | #endif
72 |       begin(v), quarter(v), middle(v));
73 | 
74 |   EXPECT_EQ(gold, v);
75 | }
76 | 
77 | TEST(rotate, Empty)
78 | {
79 |   using namespace std;
80 | #ifdef EXECUTION_POLICY
81 |   using namespace std::experimental;
82 | #endif
83 |   vector<int> v;
84 | 
85 |   rotate(
86 | #ifdef EXECUTION_POLICY
87 |       EXECUTION_POLICY,
88 | #endif
89 |       begin(v), begin(v), end(v));
90 | 
91 |   EXPECT_TRUE(v.empty());
92 | }
93 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.gen.rotate/rotate_copy.cpp:
--------------------------------------------------------------------------------
 1 | #include "gtest/gtest.h"
 2 | 
 3 | #include <vector>
 4 | 
 5 | #ifdef EXECUTION_POLICY
 6 | #include <experimental/algorithm>
 7 | #else
 8 | #include <algorithm>
 9 | #endif
10 | 
11 | TEST(rotate_copy, MoveToLast)
12 | {
13 |   using namespace std;
14 | #ifdef EXECUTION_POLICY
15 |   using namespace std::experimental;
16 | #endif
17 |   const vector<int> v1{1,2,3,4,5,6,7,8,9,10,11,12};
18 |   vector<int> v2; v2.resize(v1.size());
19 |   const vector<int> gold{2,3,4,5,6,7,8,9,10,11,12,1};
20 | 
21 |   rotate_copy(
22 | #ifdef EXECUTION_POLICY
23 |       EXECUTION_POLICY,
24 | #endif
25 |       begin(v1), begin(v1)+1, end(v1), begin(v2));
26 | 
27 |   EXPECT_EQ(gold, v2);
28 | }
29 | 
30 | TEST(rotate_copy, MoveRangeToEnd)
31 | {
32 |   using namespace std;
33 | #ifdef EXECUTION_POLICY
34 |   using namespace std::experimental;
35 | #endif
36 |   const vector<int> v1{1,2,3,4,5,6,7,8,9,10,11,12};
37 |   vector<int> v2; v2.resize(v1.size());
38 |   const vector<int> gold{7,8,9,10,11,12,1,2,3,4,5,6};
39 | 
40 |   auto middle = [](const vector<int>& v) {
41 |     return begin(v) + v.size()/2;
42 |   };
43 | 
44 |   rotate_copy(
45 | #ifdef EXECUTION_POLICY
46 |       EXECUTION_POLICY,
47 | #endif
48 |       begin(v1), middle(v1), end(v1), begin(v2));
49 | 
50 |   EXPECT_EQ(gold, v2);
51 | }
52 | 
53 | TEST(rotate_copy, MoveRangeToMiddle)
54 | {
55 |   using namespace std;
56 | #ifdef EXECUTION_POLICY
57 |   using namespace std::experimental;
58 | #endif
59 |   const vector<int> v1{1,2,3,4,5,6,7,8,9,10,11,12};
60 |   vector<int> v2; v2.resize(v1.size());
61 |   const vector<int> gold{4,5,6,1,2,3,0,0,0,0,0,0};
62 | 
63 |   auto middle = [](const vector<int>& v) {
64 |     return begin(v) + v.size()/2;
65 |   };
66 | 
67 |   auto quarter = [](const vector<int>& v) {
68 |     return begin(v) + v.size()/4;
69 |   };
70 | 
71 |   rotate_copy(
72 | #ifdef EXECUTION_POLICY
73 |       EXECUTION_POLICY,
74 | #endif
75 |       begin(v1), quarter(v1), middle(v1), begin(v2));
76 | 
77 |   EXPECT_EQ(gold, v2);
78 | }
79 | 
80 | TEST(rotate_copy, Empty)
81 | {
82 |   using namespace std;
83 | #ifdef EXECUTION_POLICY
84 |   using namespace std::experimental;
85 | #endif
86 |   const vector<int> v1;
87 |   vector<int> v2;
88 | 
89 |   rotate_copy(
90 | #ifdef EXECUTION_POLICY
91 |       EXECUTION_POLICY,
92 | #endif
93 |       begin(v1), begin(v1), end(v1), begin(v2));
94 | 
95 |   EXPECT_TRUE(v2.empty());
96 | }
97 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.gen.swap/swap_ranges.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(swap_ranges, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.gen.transform/binary_transform.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(binary_transform, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.gen.transform/unary_transform.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(unary_transform, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.gen.unique/unique.cpp:
--------------------------------------------------------------------------------
  1 | #include "gtest/gtest.h"
  2 | 
  3 | #include <vector>
  4 | 
  5 | #ifdef EXECUTION_POLICY
  6 | #include <experimental/algorithm>
  7 | #else
  8 | #include <algorithm>
  9 | #endif
 10 | 
 11 | TEST(unique, Empty){
 12 |   using namespace std;
 13 | #ifdef EXECUTION_POLICY
 14 |   using namespace std::experimental;
 15 | #endif
 16 |   vector<int> v;
 17 |   vector<int> w = v;
 18 |   
 19 |   auto it = unique(
 20 | #ifdef EXECUTION_POLICY
 21 |                    EXECUTION_POLICY,
 22 | #endif
 23 |                    begin(v), end(v));
 24 | 
 25 |   EXPECT_TRUE(v.empty());
 26 |   EXPECT_TRUE(distance(begin(v), it) == 0);
 27 |   EXPECT_TRUE(v == w);
 28 | }
 29 | 
 30 | TEST(unique, Unique){
 31 |   using namespace std;
 32 | #ifdef EXECUTION_POLICY
 33 |   using namespace std::experimental;
 34 | #endif
 35 |   vector<int> v = {1,2,4,5,6,7,8,9};
 36 |   vector<int> w = v;
 37 |   
 38 |   auto it = unique(
 39 | #ifdef EXECUTION_POLICY
 40 |                    EXECUTION_POLICY,
 41 | #endif
 42 |                    begin(v), end(v));
 43 | 
 44 |   EXPECT_TRUE(v.size() == w.size());
 45 |   EXPECT_TRUE(it == end(v));
 46 |   EXPECT_TRUE(v == w);
 47 | }
 48 | 
 49 | TEST(unique, NonConseqUnique){
 50 |   using namespace std;
 51 | #ifdef EXECUTION_POLICY
 52 |   using namespace std::experimental;
 53 | #endif
 54 |   vector<int> v = {1,2,4,5,6,7,8,9,8,7,6,5,4,3,2,1};
 55 |   vector<int> w = v;
 56 |   
 57 |   auto it = unique(
 58 | #ifdef EXECUTION_POLICY
 59 |                    EXECUTION_POLICY,
 60 | #endif
 61 |                    begin(v), end(v));
 62 | 
 63 |   EXPECT_TRUE(v.size() == w.size());
 64 |   EXPECT_TRUE(it == end(v));
 65 |   EXPECT_TRUE(v == w);
 66 | }
 67 | 
 68 | TEST(unique, Duplicates){
 69 |   using namespace std;
 70 | #ifdef EXECUTION_POLICY
 71 |   using namespace std::experimental;
 72 | #endif
 73 |   vector<int> v = {1,2,2,2,4,4,5,6,7,7,8,9,2,4};
 74 |   vector<int> w = {1,2,    4,  5,6,7,  8,9,2,4};
 75 | 
 76 |   const auto diff = v.size() - w.size();
 77 |   
 78 |   auto it = unique(
 79 | #ifdef EXECUTION_POLICY
 80 |                    EXECUTION_POLICY,
 81 | #endif
 82 |                    begin(v), end(v));
 83 | 
 84 |   EXPECT_TRUE(distance(begin(v), it) == w.size());
 85 |   EXPECT_TRUE(equal(begin(v), it, begin(w)));
 86 | }
 87 | 
 88 | // TODO: The comp function should be different from default
 89 | bool myComp (int i, int j) { return i==j; }
 90 | 
 91 | TEST(unique, EmptyComp){
 92 |   using namespace std;
 93 | #ifdef EXECUTION_POLICY
 94 |   using namespace std::experimental;
 95 | #endif
 96 |   vector<int> v;
 97 |   vector<int> w = v;
 98 |   
 99 |   auto it = unique(
100 | #ifdef EXECUTION_POLICY
101 |                    EXECUTION_POLICY,
102 | #endif
103 |                    begin(v), end(v), myComp);
104 | 
105 |   EXPECT_TRUE(v.empty());
106 |   EXPECT_TRUE(distance(begin(v), it) == 0);
107 |   EXPECT_TRUE(v == w);
108 | }
109 | 
110 | TEST(unique, UniqueComp){
111 |   using namespace std;
112 | #ifdef EXECUTION_POLICY
113 |   using namespace std::experimental;
114 | #endif
115 |   vector<int> v = {1,2,4,5,6,7,8,9};
116 |   vector<int> w = v;
117 |   
118 |   auto it = unique(
119 | #ifdef EXECUTION_POLICY
120 |                    EXECUTION_POLICY,
121 | #endif
122 |                    begin(v), end(v), myComp);
123 | 
124 |   EXPECT_TRUE(v.size() == w.size());
125 |   EXPECT_TRUE(it == end(v));
126 |   EXPECT_TRUE(v == w);
127 | }
128 | 
129 | TEST(unique, NonConseqUniqueComp){
130 |   using namespace std;
131 | #ifdef EXECUTION_POLICY
132 |   using namespace std::experimental;
133 | #endif
134 |   vector<int> v = {1,2,4,5,6,7,8,9,8,7,6,5,4,3,2,1};
135 |   vector<int> w = v;
136 |   
137 |   auto it = unique(
138 | #ifdef EXECUTION_POLICY
139 |                    EXECUTION_POLICY,
140 | #endif
141 |                    begin(v), end(v), myComp);
142 | 
143 |   EXPECT_TRUE(v.size() == w.size());
144 |   EXPECT_TRUE(it == end(v));
145 |   EXPECT_TRUE(v == w);
146 | }
147 | 
148 | TEST(unique, DuplicatesComp){
149 |   using namespace std;
150 | #ifdef EXECUTION_POLICY
151 |   using namespace std::experimental;
152 | #endif
153 |   vector<int> v = {1,2,2,2,4,4,5,6,7,7,8,9,2,4};
154 |   vector<int> w = {1,2,    4,  5,6,7,  8,9,2,4};
155 | 
156 |   const auto diff = v.size() - w.size();
157 |   
158 |   auto it = unique(
159 | #ifdef EXECUTION_POLICY
160 |                    EXECUTION_POLICY,
161 | #endif
162 |                    begin(v), end(v), myComp);
163 | 
164 |   EXPECT_TRUE(distance(begin(v), it) == w.size());
165 |   EXPECT_TRUE(equal(begin(v), it, begin(w)));
166 | }
167 | 
168 | 
169 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.gen.unique/unique_copy.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(unique_copy, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.numerics.adjacent.difference/adjacent_difference.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(adjacent_difference, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.numerics.exclusive.scan/exclusive_scan.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(exclusive_scan, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.modifying.operations/alg.numerics.inclusive.scan/inclusive_scan.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(inclusive_scan, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.nonmodifying/alg.gen.adjacent.find/adjacent_find.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(adjacent_find, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.nonmodifying/alg.gen.all_of/all_of.cpp:
--------------------------------------------------------------------------------
 1 | #include "gtest/gtest.h"
 2 | 
 3 | #include <vector>
 4 | 
 5 | #ifdef EXECUTION_POLICY
 6 | #include <experimental/algorithm>
 7 | #else
 8 | #include <algorithm>
 9 | #endif
10 | 
11 | TEST(all_of, True) {
12 |   using namespace std;
13 | #ifdef EXECUTION_POLICY
14 |   using namespace std::experimental;
15 | #endif
16 |   
17 |   vector<int> v{1,2,3,4,5,6,7,8,9};
18 | 
19 |   // everything is less than 10
20 |   EXPECT_TRUE(all_of(
21 | #ifdef EXECUTION_POLICY
22 |                      EXECUTION_POLICY,
23 | #endif
24 |                      begin(v), end(v),
25 |                      [](const int &i){ return i < 10; }));
26 | }
27 | 
28 | TEST(all_of, False) {
29 |   using namespace std;
30 | #ifdef EXECUTION_POLICY
31 |   using namespace std::experimental;
32 | #endif
33 | 
34 |   vector<int> v{1,2,3,4,5,6,7,8,9};
35 | 
36 |   // not everything is 1
37 |   EXPECT_FALSE(all_of(
38 | #ifdef EXECUTION_POLICY
39 |                       EXECUTION_POLICY,
40 | #endif
41 |                       begin(v), end(v),
42 |                       [](const int &i){ return i == 1; }));
43 | }
44 | 
45 | TEST(all_of, Empty) {
46 |   using namespace std; 
47 | #ifdef EXECUTION_POLICY
48 |   using namespace std::experimental;
49 | #endif
50 | 
51 |   vector<int> v;
52 |   
53 |   // empty range should return true regardless of the predicate
54 |   EXPECT_TRUE(all_of(
55 | #ifdef EXECUTION_POLICY
56 |                      EXECUTION_POLICY,
57 | #endif
58 |                      begin(v), end(v),
59 |                      [](const int &i){ return false; }));
60 | }
61 | 
62 | 


--------------------------------------------------------------------------------
/test/alg.nonmodifying/alg.gen.any_of/any_of.cpp:
--------------------------------------------------------------------------------
 1 | #include "gtest/gtest.h"
 2 | 
 3 | #include <vector>
 4 | 
 5 | #ifdef EXECUTION_POLICY
 6 | #include <experimental/algorithm>
 7 | #else
 8 | #include <algorithm>
 9 | #endif
10 | 
11 | TEST(any_of, True) {
12 |   using namespace std;
13 | #ifdef EXECUTION_POLICY
14 |   using namespace experimental;
15 | #endif 
16 |   
17 |   vector<int> v{1,2,3,4,5,6,7,8,9};
18 | 
19 |   // everything is less than 10
20 |   EXPECT_TRUE(any_of(
21 | #ifdef EXECUTION_POLICY
22 |                      EXECUTION_POLICY,
23 | #endif
24 |                      begin(v), end(v),
25 |                      [](const int &i){ return i == 2; }));
26 | }
27 | 
28 | TEST(any_of, False) {
29 |   using namespace std;
30 | #ifdef EXECUTION_POLICY
31 |   using namespace experimental;
32 | #endif
33 |   
34 |   vector<int> v{1,2,3,4,5,6,7,8,9};
35 | 
36 |   // not everything is 1
37 |   EXPECT_FALSE(any_of(
38 | #ifdef EXECUTION_POLICY
39 |                        EXECUTION_POLICY,
40 | #endif
41 |                        begin(v), end(v),
42 |                        [](const int &i){ return i == 10; }));
43 | }
44 | 
45 | TEST(any_of, Empty) {
46 |   using namespace std;
47 | #ifdef EXECUTION_POLICY
48 |   using namespace experimental;
49 | #endif
50 |   
51 |   vector<int> v;
52 |   
53 |   // empty range should return false regardless of the predicate
54 |   EXPECT_FALSE(any_of(
55 | #ifdef EXECUTION_POLICY
56 |                        EXECUTION_POLICY,
57 | #endif
58 |                        begin(v), end(v),
59 |                        [](const int &i){ return true; }));
60 | }
61 | 
62 | 


--------------------------------------------------------------------------------
/test/alg.nonmodifying/alg.gen.count/count.cpp:
--------------------------------------------------------------------------------
 1 | #include "gtest/gtest.h"
 2 | 
 3 | #include <vector>
 4 | 
 5 | #ifdef EXECUTION_POLICY
 6 | #include <experimental/algorithm>
 7 | #else
 8 | #include <algorithm>
 9 | #endif
10 | 
11 | TEST(count, None){
12 |   using namespace std;
13 | #ifdef EXECUTION_POLICY
14 |   using namespace std::experimental;
15 | #endif
16 |   
17 |   vector<int> v{1,2,3,4,5,6,7,8,9,10,11,12};
18 | 
19 |   auto value = 
20 |      count(
21 | #ifdef EXECUTION_POLICY
22 |            EXECUTION_POLICY,
23 | #endif
24 |            begin(v), end(v),
25 |            20);
26 | 
27 |   EXPECT_EQ(0, value); 
28 | }
29 | 
30 | TEST(count, One){
31 |   using namespace std;
32 | #ifdef EXECUTION_POLICY
33 |   using namespace std::experimental;
34 | #endif
35 |   
36 |   vector<int> v{1,2,3,4,5,6,7,8,9,10,11,12};
37 | 
38 |   auto value = 
39 |      count(
40 | #ifdef EXECUTION_POLICY
41 |            EXECUTION_POLICY,
42 | #endif
43 |            begin(v), end(v),
44 |            1);
45 | 
46 |   EXPECT_EQ(1, value); 
47 | }
48 | 
49 | TEST(count, Many){
50 |   using namespace std;
51 | #ifdef EXECUTION_POLICY
52 |   using namespace std::experimental;
53 | #endif
54 |   
55 |   vector<int> v{1,2,3,4,5,1,7,8,9,10,1,1};
56 | 
57 |   auto value = 
58 |      count(
59 | #ifdef EXECUTION_POLICY
60 |            EXECUTION_POLICY,
61 | #endif
62 |            begin(v), end(v),
63 |            1);
64 | 
65 |   EXPECT_EQ(4, value); 
66 | }
67 | 
68 | TEST(count, Empty){
69 |   using namespace std;
70 | #ifdef EXECUTION_POLICY
71 |   using namespace std::experimental;
72 | #endif
73 |   
74 |   vector<int> v;
75 | 
76 |   auto value = 
77 |      count(
78 | #ifdef EXECUTION_POLICY
79 |            EXECUTION_POLICY,
80 | #endif
81 |            begin(v), end(v),
82 |            1);
83 | 
84 |   EXPECT_EQ(0, value); 
85 | }
86 | 
87 | 


--------------------------------------------------------------------------------
/test/alg.nonmodifying/alg.gen.count/count_if.cpp:
--------------------------------------------------------------------------------
 1 | #include "gtest/gtest.h"
 2 | 
 3 | #include <vector>
 4 | 
 5 | #ifdef EXECUTION_POLICY
 6 | #include <experimental/algorithm>
 7 | #else
 8 | #include <algorithm>
 9 | #endif
10 | 
11 | TEST(count_if, None){
12 |   using namespace std;
13 | #ifdef EXECUTION_POLICY
14 |   using namespace std::experimental;
15 | #endif
16 |   
17 |   vector<int> v{1,2,3,4,5,6,7,8,9,10,11,12};
18 | 
19 |   auto value = 
20 |      count_if(
21 | #ifdef EXECUTION_POLICY
22 |               EXECUTION_POLICY,
23 | #endif
24 |               begin(v), end(v),
25 |               [](const int &i){return i > 20;});
26 | 
27 |   EXPECT_EQ(0, value); 
28 | }
29 | 
30 | TEST(count_if, One){
31 |   using namespace std;
32 | #ifdef EXECUTION_POLICY
33 |   using namespace std::experimental;
34 | #endif
35 |   
36 |   vector<int> v{1,2,3,4,5,6,7,8,9,10,11,12};
37 | 
38 |   auto value = 
39 |      count_if(
40 | #ifdef EXECUTION_POLICY
41 |               EXECUTION_POLICY,
42 | #endif
43 |               begin(v), end(v),
44 |               [](const int &i){return i == 2;});
45 | 
46 |   EXPECT_EQ(1, value); 
47 | }
48 | 
49 | TEST(count_if, Many){
50 |   using namespace std;
51 | #ifdef EXECUTION_POLICY
52 |   using namespace std::experimental;
53 | #endif
54 |   
55 |   vector<int> v{1,2,3,4,5,6,7,8,9,10,11,12};
56 | 
57 |   auto value = 
58 |      count_if(
59 | #ifdef EXECUTION_POLICY
60 |               EXECUTION_POLICY,
61 | #endif
62 |               begin(v), end(v),
63 |               [](const int &i){return i < 8;});
64 | 
65 |   EXPECT_EQ(7, value); 
66 | }
67 | 
68 | TEST(count_if, Empty){
69 |   using namespace std;
70 | #ifdef EXECUTION_POLICY
71 |   using namespace std::experimental;
72 | #endif
73 |   
74 |   vector<int> v;
75 | 
76 |   auto value = 
77 |      count_if(
78 | #ifdef EXECUTION_POLICY
79 |               EXECUTION_POLICY,
80 | #endif
81 |               begin(v), end(v),
82 |               [](const int &i){return true;});
83 | 
84 |   EXPECT_EQ(0, value); 
85 | }
86 | 
87 | 


--------------------------------------------------------------------------------
/test/alg.nonmodifying/alg.gen.equal/equal.cpp:
--------------------------------------------------------------------------------
  1 | // TODO: integrate C++14 prototypes when an implementation of C++14 is available.
  2 | 
  3 | #include "gtest/gtest.h"
  4 | 
  5 | #include <vector>
  6 | 
  7 | #ifdef EXECUTION_POLICY
  8 | #include <experimental/algorithm>
  9 | #else
 10 | #include <algorithm>
 11 | #endif
 12 | 
 13 | TEST(equal, Empty){
 14 |   using namespace std;
 15 | #ifdef EXECUTION_POLICY
 16 |   using namespace std::experimental;
 17 | #endif
 18 |   vector<int> v, w;
 19 |   
 20 |   EXPECT_TRUE(equal(
 21 | #ifdef EXECUTION_POLICY
 22 |                     EXECUTION_POLICY,
 23 | #endif
 24 |                     begin(v), end(v), begin(w)));
 25 | }
 26 | 
 27 | 
 28 | TEST(equal, Equal){
 29 |   using namespace std;
 30 | #ifdef EXECUTION_POLICY
 31 |   using namespace std::experimental;
 32 | #endif
 33 |   vector<int> v = {1,2,3,4,5,6,7,8,9};
 34 |   vector<int> w = {1,2,3,4,5,6,7,8,9};
 35 | 
 36 |   EXPECT_TRUE(equal(
 37 | #ifdef EXECUTION_POLICY
 38 |                     EXECUTION_POLICY,
 39 | #endif
 40 |                     begin(v), end(v), begin(w)));
 41 | }
 42 | 
 43 | TEST(equal, EqualSubset){
 44 |   using namespace std;
 45 | #ifdef EXECUTION_POLICY
 46 |   using namespace std::experimental;
 47 | #endif
 48 |   vector<int> v = {1,2,3,4,5,6,7,8,9};
 49 |   vector<int> w = {1,2,3,4,5,6,7,8,9,10,11,12,13};
 50 | 
 51 |   EXPECT_TRUE(equal(
 52 | #ifdef EXECUTION_POLICY
 53 |                     EXECUTION_POLICY,
 54 | #endif
 55 |                     begin(v), end(v), begin(w)));
 56 | }
 57 | 
 58 | TEST(equal, NotEqual){
 59 |   using namespace std;
 60 | #ifdef EXECUTION_POLICY
 61 |   using namespace std::experimental;
 62 | #endif
 63 |   vector<int> v = {1,2,3,4,5,6,7,8,9};
 64 |   vector<int> w = {8,4,2,1,7,3,6,8,4};
 65 | 
 66 |   EXPECT_FALSE(equal(
 67 | #ifdef EXECUTION_POLICY
 68 |                     EXECUTION_POLICY,
 69 | #endif
 70 |                     begin(v), end(v), begin(w)));
 71 | }
 72 | 
 73 | TEST(equal, EmptyRange){
 74 |   using namespace std;
 75 | #ifdef EXECUTION_POLICY
 76 |   using namespace std::experimental;
 77 | #endif
 78 |   vector<int> v = {8,4,7,4,5,1,23,4,7};
 79 |   vector<int> w = {1,2,3,4,5,6,7,8,9};
 80 | 
 81 |   EXPECT_TRUE(equal(
 82 | #ifdef EXECUTION_POLICY
 83 |                     EXECUTION_POLICY,
 84 | #endif
 85 |                     begin(v), begin(v), begin(w)));
 86 | }
 87 | 
 88 | 
 89 | // TODO: the predicate should be more interesting
 90 | bool myPred(int a, int b) { return a == b; }
 91 | 
 92 | TEST(equal, EmptyPred){
 93 |   using namespace std;
 94 | #ifdef EXECUTION_POLICY
 95 |   using namespace std::experimental;
 96 | #endif
 97 |   vector<int> v, w;
 98 |   
 99 |   EXPECT_TRUE(equal(
100 | #ifdef EXECUTION_POLICY
101 |                     EXECUTION_POLICY,
102 | #endif
103 |                     begin(v), end(v), begin(w), myPred));
104 | }
105 | 
106 | TEST(equal, EqualPred){
107 |   using namespace std;
108 | #ifdef EXECUTION_POLICY
109 |   using namespace std::experimental;
110 | #endif
111 |   vector<int> v = {1,2,3,4,5,6,7,8,9};
112 |   vector<int> w = {1,2,3,4,5,6,7,8,9};
113 | 
114 |   EXPECT_TRUE(equal(
115 | #ifdef EXECUTION_POLICY
116 |                     EXECUTION_POLICY,
117 | #endif
118 |                     begin(v), end(v), begin(w), myPred));
119 | }
120 | 
121 | TEST(equal, EqualSubsetPred){
122 |   using namespace std;
123 | #ifdef EXECUTION_POLICY
124 |   using namespace std::experimental;
125 | #endif
126 |   vector<int> v = {1,2,3,4,5,6,7,8,9};
127 |   vector<int> w = {1,2,3,4,5,6,7,8,9,10,11,12,13};
128 | 
129 |   EXPECT_TRUE(equal(
130 | #ifdef EXECUTION_POLICY
131 |                     EXECUTION_POLICY,
132 | #endif
133 |                     begin(v), end(v), begin(w), myPred));
134 | }
135 | 
136 | TEST(equal, NotEqualPred){
137 |   using namespace std;
138 | #ifdef EXECUTION_POLICY
139 |   using namespace std::experimental;
140 | #endif
141 |   vector<int> v = {1,2,3,4,5,6,7,8,9};
142 |   vector<int> w = {8,4,2,1,7,3,6,8,4};
143 | 
144 |   EXPECT_FALSE(equal(
145 | #ifdef EXECUTION_POLICY
146 |                     EXECUTION_POLICY,
147 | #endif
148 |                     begin(v), end(v), begin(w), myPred));
149 | }
150 | 
151 | TEST(equal, EmptyRangePred){
152 |   using namespace std;
153 | #ifdef EXECUTION_POLICY
154 |   using namespace std::experimental;
155 | #endif
156 |   vector<int> v = {8,4,7,4,5,1,23,4,7};
157 |   vector<int> w = {1,2,3,4,5,6,7,8,9};
158 | 
159 |   EXPECT_TRUE(equal(
160 | #ifdef EXECUTION_POLICY
161 |                     EXECUTION_POLICY,
162 | #endif
163 |                     begin(v), begin(v), begin(w), myPred));
164 | }
165 | 
166 | 
167 | // TODO: C++14 functions...
168 | 
169 | 
170 | 
171 | 


--------------------------------------------------------------------------------
/test/alg.nonmodifying/alg.gen.find.end/find_end.cpp:
--------------------------------------------------------------------------------
  1 | #include "gtest/gtest.h"
  2 | 
  3 | #include <vector>
  4 | 
  5 | #ifdef EXECUTION_POLICY
  6 | #include <experimental/algorithm>
  7 | #else
  8 | #include <algorithm>
  9 | #endif
 10 | 
 11 | TEST(find_end, Present_unique){
 12 |   using namespace std;
 13 | #ifdef EXECUTION_POLICY
 14 |   using namespace std::experimental;
 15 | #endif
 16 | 
 17 |   const vector<int> v1{1,2,3,4,5,6,7,8,9,10,11,12};
 18 |   const vector<int> v2{8,9,10};
 19 | 
 20 |   auto elt = find_end(
 21 | #ifdef EXECUTION_POLICY
 22 |                           EXECUTION_POLICY,
 23 | #endif
 24 |                           begin(v1), end(v1), begin(v2), end(v2));
 25 | 
 26 |   EXPECT_EQ(7, distance(v1.begin(), elt));
 27 | }
 28 | 
 29 | TEST(find_end, Present_unique_fist){
 30 |   using namespace std;
 31 | #ifdef EXECUTION_POLICY
 32 |   using namespace std::experimental;
 33 | #endif
 34 | 
 35 |   const vector<int> v1{1,2,3,4,5,6,7,8,9,10,11,12};
 36 |   const vector<int> v2{1,2,3};
 37 | 
 38 |   auto elt = find_end(
 39 | #ifdef EXECUTION_POLICY
 40 |                           EXECUTION_POLICY,
 41 | #endif
 42 |                           begin(v1), end(v1), begin(v2), end(v2));
 43 | 
 44 |   EXPECT_EQ(0, distance(v1.begin(), elt));
 45 | }
 46 | 
 47 | TEST(find_end, Present_unique_last){
 48 |   using namespace std;
 49 | #ifdef EXECUTION_POLICY
 50 |   using namespace std::experimental;
 51 | #endif
 52 | 
 53 |   const vector<int> v1{1,2,3,4,5,6,7,8,9,10,11,12};
 54 |   const vector<int> v2{12};
 55 | 
 56 |   auto elt = find_end(
 57 | #ifdef EXECUTION_POLICY
 58 |                           EXECUTION_POLICY,
 59 | #endif
 60 |                           begin(v1), end(v1), begin(v2), end(v2));
 61 | 
 62 |   EXPECT_EQ(11, distance(v1.begin(), elt));
 63 | }
 64 | 
 65 | TEST(find_end, Present_multiple){
 66 |   using namespace std;
 67 | #ifdef EXECUTION_POLICY
 68 |   using namespace std::experimental;
 69 | #endif
 70 | 
 71 |   const vector<int> v1{1,2,3,4,5,6,7,8,9,10,11,12};
 72 |   const vector<int> v2{9,8,7};
 73 | 
 74 |   auto elt = find_end(
 75 | #ifdef EXECUTION_POLICY
 76 |                           EXECUTION_POLICY,
 77 | #endif
 78 |                           begin(v1), end(v1), begin(v2), end(v2),
 79 |                           [](const int &i1, const int &i2){return (i1<i2);});
 80 | 
 81 |   EXPECT_EQ(3, distance(v1.begin(), elt));
 82 | }
 83 | 
 84 | TEST(find_end, Missing){
 85 |   using namespace std;
 86 | #ifdef EXECUTION_POLICY
 87 |   using namespace std::experimental;
 88 | #endif
 89 | 
 90 |   const vector<int> v1{1,2,3,4,5,6,7,8,9,10,11,12};
 91 |   const vector<int> v2{8,9,11};
 92 | 
 93 |   auto elt = find_end(
 94 | #ifdef EXECUTION_POLICY
 95 |                           EXECUTION_POLICY,
 96 | #endif
 97 |                           begin(v1), end(v1), begin(v2), end(v2));
 98 | 
 99 |   EXPECT_EQ(v1.end(), elt);
100 | }
101 | 
102 | TEST(find_end, Empty_haystack){
103 |   using namespace std;
104 | #ifdef EXECUTION_POLICY
105 |   using namespace std::experimental;
106 | #endif
107 | 
108 |   const vector<int> v1;
109 |   const vector<int> v2{8,9,10};
110 | 
111 |   auto elt = find_end(
112 | #ifdef EXECUTION_POLICY
113 |                           EXECUTION_POLICY,
114 | #endif
115 |                           begin(v1), end(v1), begin(v2), end(v2));
116 | 
117 |   EXPECT_EQ(v1.end(), elt);
118 | }
119 | 
120 | TEST(find_end, Empty_needle){
121 |   using namespace std;
122 | 
123 |   const vector<int> v1{1,2,3,4,5,6,7,8,9,10,11,12};
124 |   const vector<int> v2;
125 | 
126 |   auto elt = find_end(
127 | #ifdef EXECUTION_POLICY
128 |                           EXECUTION_POLICY,
129 | #endif
130 |                           begin(v1), end(v1), begin(v2), end(v2));
131 | 
132 |   EXPECT_EQ(v1.end(), elt);
133 | }
134 | 
135 | TEST(find_end, Needle_bigger_than_haystack){
136 |   using namespace std;
137 | 
138 |   const vector<int> v2{1,2,3,4,5,6,7,8,9,10,11,12};
139 |   const vector<int> v1{8,9,10};
140 | 
141 |   auto elt = find_end(
142 | #ifdef EXECUTION_POLICY
143 |                           EXECUTION_POLICY,
144 | #endif
145 |                           begin(v1), end(v1), begin(v2), end(v2));
146 | 
147 |   EXPECT_EQ(v1.end(), elt);
148 | }
149 | 


--------------------------------------------------------------------------------
/test/alg.nonmodifying/alg.gen.find.first.of/find_first_of.cpp:
--------------------------------------------------------------------------------
  1 | #include "gtest/gtest.h"
  2 | 
  3 | #include <vector>
  4 | 
  5 | #ifdef EXECUTION_POLICY
  6 | #include <experimental/algorithm>
  7 | #else
  8 | #include <algorithm>
  9 | #endif
 10 | 
 11 | TEST(find_first_of, Present_unique){
 12 |   using namespace std;
 13 | #ifdef EXECUTION_POLICY
 14 |   using namespace std::experimental;
 15 | #endif
 16 |   
 17 |   const vector<int> v1{1,2,3,4,5,6,7,8,9,10,11,12};
 18 |   const vector<int> v2{8,27,42};
 19 |   
 20 |   auto elt = find_first_of(
 21 | #ifdef EXECUTION_POLICY
 22 |                           EXECUTION_POLICY,
 23 | #endif
 24 |                           begin(v1), end(v1), begin(v2), end(v2));
 25 | 
 26 |   EXPECT_EQ(7, distance(v1.begin(), elt));
 27 | }
 28 | 
 29 | TEST(find_first_of, Present_unique_first){
 30 |   using namespace std;
 31 | #ifdef EXECUTION_POLICY
 32 |   using namespace std::experimental;
 33 | #endif
 34 |   
 35 |   const vector<int> v1{1,2,3,4,5,6,7,8,9,10,11,12};
 36 |   const vector<int> v2{8,27,1};
 37 |   
 38 |   auto elt = find_first_of(
 39 | #ifdef EXECUTION_POLICY
 40 |                           EXECUTION_POLICY,
 41 | #endif
 42 |                           begin(v1), end(v1), begin(v2), end(v2));
 43 | 
 44 |   EXPECT_EQ(0, distance(v1.begin(), elt));
 45 | }
 46 | 
 47 | TEST(find_first_of, Present_unique_last){
 48 |   using namespace std;
 49 | #ifdef EXECUTION_POLICY
 50 |   using namespace std::experimental;
 51 | #endif
 52 |   
 53 |   const vector<int> v1{1,2,3,4,5,6,7,8,9,10,11,12};
 54 |   const vector<int> v2{12,27,42};
 55 |   
 56 |   auto elt = find_first_of(
 57 | #ifdef EXECUTION_POLICY
 58 |                           EXECUTION_POLICY,
 59 | #endif
 60 |                           begin(v1), end(v1), begin(v2), end(v2));
 61 | 
 62 |   EXPECT_EQ(11, distance(v1.begin(), elt));
 63 | }
 64 | 
 65 | TEST(find_first_of, Present_multiple){
 66 |   using namespace std;
 67 | #ifdef EXECUTION_POLICY
 68 |   using namespace std::experimental;
 69 | #endif
 70 |   
 71 |   const vector<int> v1{1,2,3,4,5,6,7,8,9,10,11,12};
 72 |   const vector<int> v2{2,3,4};
 73 |   
 74 |   auto elt = find_first_of(
 75 | #ifdef EXECUTION_POLICY
 76 |                           EXECUTION_POLICY,
 77 | #endif
 78 |                           begin(v1), end(v1), begin(v2), end(v2));
 79 | 
 80 |   EXPECT_EQ(1, distance(v1.begin(), elt));
 81 | }
 82 | 
 83 | TEST(find_first_of, Present_none){
 84 |   using namespace std;
 85 | #ifdef EXECUTION_POLICY
 86 |   using namespace std::experimental;
 87 | #endif
 88 |   
 89 |   const vector<int> v1{1,2,3,4,5,6,7,8,9,10,11,12};
 90 |   const vector<int> v2{42,43,44};
 91 |   
 92 |   auto elt = find_first_of(
 93 | #ifdef EXECUTION_POLICY
 94 |                           EXECUTION_POLICY,
 95 | #endif
 96 |                           begin(v1), end(v1), begin(v2), end(v2));
 97 | 
 98 |   EXPECT_EQ(end(v1), elt);
 99 | }
100 | 
101 | TEST(find_first_of, Empty_needle){
102 |   using namespace std;
103 | #ifdef EXECUTION_POLICY
104 |   using namespace std::experimental;
105 | #endif
106 |   
107 |   const vector<int> v1{1,2,3,4,5,6,7,8,9,10,11,12};
108 |   const vector<int> v2{};
109 |   
110 |   auto elt = find_first_of(
111 | #ifdef EXECUTION_POLICY
112 |                           EXECUTION_POLICY,
113 | #endif
114 |                           begin(v1), end(v1), begin(v2), end(v2));
115 | 
116 |   EXPECT_EQ(end(v1), elt);
117 | }
118 | 
119 | TEST(find_first_of, Empty_haystack){
120 |   using namespace std;
121 | #ifdef EXECUTION_POLICY
122 |   using namespace std::experimental;
123 | #endif
124 |   
125 |   const vector<int> v1{};
126 |   const vector<int> v2{2,3,4};
127 |   
128 |   auto elt = find_first_of(
129 | #ifdef EXECUTION_POLICY
130 |                           EXECUTION_POLICY,
131 | #endif
132 |                           begin(v1), end(v1), begin(v2), end(v2));
133 | 
134 |   EXPECT_EQ(end(v1), elt);
135 | }
136 | 


--------------------------------------------------------------------------------
/test/alg.nonmodifying/alg.gen.find/find.cpp:
--------------------------------------------------------------------------------
 1 | #include "gtest/gtest.h"
 2 | 
 3 | #include <vector>
 4 | 
 5 | #ifdef EXECUTION_POLICY
 6 | #include <experimental/algorithm>
 7 | #else
 8 | #include <algorithm>
 9 | #endif
10 | 
11 | TEST(find, Present_unique){
12 |   using namespace std;
13 | #ifdef EXECUTION_POLICY
14 |   using namespace std::experimental;
15 | #endif
16 |   
17 |   const vector<int> v{1,2,3,4,5,6,7,8,9,10,11,12};
18 | 
19 |   auto elt = find(
20 | #ifdef EXECUTION_POLICY
21 |                        EXECUTION_POLICY,
22 | #endif
23 |                        begin(v), end(v),
24 |                        7);
25 | 
26 |   EXPECT_EQ(6, distance(v.begin(), elt)); 
27 | }
28 | 
29 | TEST(find, Present_multiple){
30 |   using namespace std;
31 | #ifdef EXECUTION_POLICY
32 |   using namespace std::experimental;
33 | #endif
34 |   
35 |   const vector<int> v{1,2,3,4,5,6,7,8,9,10,7,7};
36 | 
37 |   auto elt = find(
38 | #ifdef EXECUTION_POLICY
39 |                        EXECUTION_POLICY,
40 | #endif
41 |                        begin(v), end(v),
42 |                        7);
43 | 
44 |   EXPECT_EQ(6, distance(v.begin(), elt)); 
45 | }
46 | 
47 | TEST(find, Missing){
48 |   using namespace std;
49 | #ifdef EXECUTION_POLICY
50 |   using namespace std::experimental;
51 | #endif
52 |   
53 |   const vector<int> v{1,2,3,4,5,6,7,8,9,10,11,12};
54 | 
55 |   auto elt = find(
56 | #ifdef EXECUTION_POLICY
57 |                        EXECUTION_POLICY,
58 | #endif
59 |                        begin(v), end(v),
60 |                        20);
61 | 
62 |   EXPECT_EQ(v.end(), elt); 
63 | }
64 | 
65 | TEST(find, Empty){
66 |   using namespace std;
67 | #ifdef EXECUTION_POLICY
68 |   using namespace std::experimental;
69 | #endif
70 |   
71 |   const vector<int> v;
72 | 
73 |   auto elt = find(
74 | #ifdef EXECUTION_POLICY
75 |                        EXECUTION_POLICY,
76 | #endif
77 |                        begin(v), end(v),
78 |                        0);
79 | 
80 |   EXPECT_EQ(v.end(), elt); 
81 | }
82 | 
83 | 


--------------------------------------------------------------------------------
/test/alg.nonmodifying/alg.gen.find/find_if.cpp:
--------------------------------------------------------------------------------
  1 | #include "gtest/gtest.h"
  2 | 
  3 | #include <vector>
  4 | 
  5 | #ifdef EXECUTION_POLICY
  6 | #include <experimental/algorithm>
  7 | #else
  8 | #include <algorithm>
  9 | #endif
 10 | 
 11 | TEST(find_if, Present_unique){
 12 |   using namespace std;
 13 | #ifdef EXECUTION_POLICY
 14 |   using namespace std::experimental;
 15 | #endif
 16 |   
 17 |   const vector<int> v{1,2,3,4,5,6,7,8,9,10,11,12};
 18 | 
 19 |   auto elt = find_if(
 20 | #ifdef EXECUTION_POLICY
 21 |                           EXECUTION_POLICY,
 22 | #endif
 23 |                           begin(v), end(v),
 24 |                           [](const int&i){return i == 7;});
 25 | 
 26 |   EXPECT_EQ(6, distance(v.begin(), elt)); 
 27 | }
 28 | 
 29 | TEST(find_if, Present_unique_first){
 30 |   using namespace std;
 31 | #ifdef EXECUTION_POLICY
 32 |   using namespace std::experimental;
 33 | #endif
 34 |   
 35 |   const vector<int> v{1,2,3,4,5,6,7,8,9,10,11,12};
 36 | 
 37 |   auto elt = find_if(
 38 | #ifdef EXECUTION_POLICY
 39 |                           EXECUTION_POLICY,
 40 | #endif
 41 |                           begin(v), end(v),
 42 |                           [](const int&i){return i == 1;});
 43 | 
 44 |   EXPECT_EQ(0, distance(v.begin(), elt)); 
 45 | }
 46 | 
 47 | TEST(find_if, Present_unique_last){
 48 |   using namespace std;
 49 | #ifdef EXECUTION_POLICY
 50 |   using namespace std::experimental;
 51 | #endif
 52 |   
 53 |   const vector<int> v{1,2,3,4,5,6,7,8,9,10,11,12};
 54 | 
 55 |   auto elt = find_if(
 56 | #ifdef EXECUTION_POLICY
 57 |                           EXECUTION_POLICY,
 58 | #endif
 59 |                           begin(v), end(v),
 60 |                           [](const int&i){return i == 12;});
 61 | 
 62 |   EXPECT_EQ(11, distance(v.begin(), elt)); 
 63 | }
 64 | 
 65 | TEST(find_if, Present_multiple){
 66 |   using namespace std;
 67 | #ifdef EXECUTION_POLICY
 68 |   using namespace std::experimental;
 69 | #endif
 70 |   
 71 |   const vector<int> v{1,2,3,4,5,6,7,8,9,10,7,7};
 72 | 
 73 |   auto elt = find_if(
 74 | #ifdef EXECUTION_POLICY
 75 |                           EXECUTION_POLICY,
 76 | #endif
 77 |                           begin(v), end(v),
 78 |                           [](const int&i){return i == 7;});
 79 | 
 80 |   EXPECT_EQ(6, distance(v.begin(), elt)); 
 81 | }
 82 | 
 83 | TEST(find_if, Missing){
 84 |   using namespace std;
 85 | #ifdef EXECUTION_POLICY
 86 |   using namespace std::experimental;
 87 | #endif
 88 |   
 89 |   const vector<int> v{1,2,3,4,5,6,7,8,9,10,11,12};
 90 | 
 91 |   auto elt = find_if(
 92 | #ifdef EXECUTION_POLICY
 93 |                           EXECUTION_POLICY,
 94 | #endif
 95 |                           begin(v), end(v),
 96 |                           [](const int&i){return i == 20;});
 97 | 
 98 |   EXPECT_EQ(v.end(), elt); 
 99 | }
100 | 
101 | TEST(find_if, Empty){
102 |   using namespace std;
103 | #ifdef EXECUTION_POLICY
104 |   using namespace std::experimental;
105 | #endif
106 |   
107 |   const vector<int> v;
108 | 
109 |   auto elt = find_if(
110 | #ifdef EXECUTION_POLICY
111 |                           EXECUTION_POLICY,
112 | #endif
113 |                           begin(v), end(v),
114 |                           [](const int&i){return true;});
115 | 
116 |   EXPECT_EQ(v.end(), elt); 
117 | }
118 | 
119 | 


--------------------------------------------------------------------------------
/test/alg.nonmodifying/alg.gen.find/find_if_not.cpp:
--------------------------------------------------------------------------------
 1 | #include "gtest/gtest.h"
 2 | 
 3 | #include <vector>
 4 | 
 5 | #ifdef EXECUTION_POLICY
 6 | #include <experimental/algorithm>
 7 | #else
 8 | #include <algorithm>
 9 | #endif
10 | 
11 | TEST(find_if_not, Present_unique){
12 |   using namespace std;
13 | #ifdef EXECUTION_POLICY
14 |   using namespace std::experimental;
15 | #endif
16 |   
17 |   const vector<int> v{1,2,3,4,5,6,7,8,9,10,11,12};
18 | 
19 |   auto elt = find_if_not(
20 | #ifdef EXECUTION_POLICY
21 |                           EXECUTION_POLICY,
22 | #endif
23 |                           begin(v), end(v),
24 |                           [](const int&i){return i != 7;});
25 | 
26 |   EXPECT_EQ(6, distance(v.begin(), elt)); 
27 | }
28 | 
29 | TEST(find_if_not, Present_multiple){
30 |   using namespace std;
31 | #ifdef EXECUTION_POLICY
32 |   using namespace std::experimental;
33 | #endif
34 |   
35 |   const vector<int> v{1,2,3,4,5,6,7,8,9,10,7,7};
36 | 
37 |   auto elt = find_if_not(
38 | #ifdef EXECUTION_POLICY
39 |                           EXECUTION_POLICY,
40 | #endif
41 |                           begin(v), end(v),
42 |                           [](const int&i){return i != 7;});
43 | 
44 |   EXPECT_EQ(6, distance(v.begin(), elt)); 
45 | }
46 | 
47 | TEST(find_if_not, Missing){
48 |   using namespace std;
49 | #ifdef EXECUTION_POLICY
50 |   using namespace std::experimental;
51 | #endif
52 |   
53 |   const vector<int> v{1,2,3,4,5,6,7,8,9,10,11,12};
54 | 
55 |   auto elt = find_if_not(
56 | #ifdef EXECUTION_POLICY
57 |                           EXECUTION_POLICY,
58 | #endif
59 |                           begin(v), end(v),
60 |                           [](const int&i){return i != 20;});
61 | 
62 |   EXPECT_EQ(v.end(), elt); 
63 | }
64 | 
65 | TEST(find_if_not, Empty){
66 |   using namespace std;
67 | #ifdef EXECUTION_POLICY
68 |   using namespace std::experimental;
69 | #endif
70 |   
71 |   const vector<int> v;
72 | 
73 |   auto elt = find_if_not(
74 | #ifdef EXECUTION_POLICY
75 |                           EXECUTION_POLICY,
76 | #endif
77 |                           begin(v), end(v),
78 |                           [](const int&i){return true;});
79 | 
80 |   EXPECT_EQ(v.end(), elt); 
81 | }
82 | 
83 | 


--------------------------------------------------------------------------------
/test/alg.nonmodifying/alg.gen.foreach/for_each.cpp:
--------------------------------------------------------------------------------
 1 | #include "gtest/gtest.h"
 2 | 
 3 | #include <vector>
 4 | 
 5 | #ifdef EXECUTION_POLICY
 6 | #include <experimental/algorithm>
 7 | #else
 8 | #include <algorithm>
 9 | #endif
10 | 
11 | TEST(for_each, Double){
12 |   using namespace std;
13 | #ifdef EXECUTION_POLICY
14 |   using namespace std::experimental;
15 | #endif
16 | 
17 |   vector<int> v{1,2,3,4,5,6,7,8,9,10,11,12};
18 |   const vector<int> golden{2,4,6,8,10,12,14,16,18,20,22,24};
19 | 
20 |   for_each(
21 | #ifdef EXECUTION_POLICY
22 |            EXECUTION_POLICY,
23 | #endif
24 |            begin(v), end(v),
25 |            [](int &i){ i*= 2; });
26 | 
27 |   EXPECT_TRUE(v == golden); 
28 | }
29 | 
30 | TEST(for_each, Empty){
31 |   using namespace std;
32 | #ifdef EXECUTION_POLICY
33 |   using namespace std::experimental;
34 | #endif
35 |   vector<int> v;
36 |   
37 |   for_each(
38 | #ifdef EXECUTION_POLICY
39 |            EXECUTION_POLICY,
40 | #endif
41 |            begin(v), end(v),
42 |            [](int &i){ i = 0; });
43 | 
44 |   EXPECT_TRUE(v.empty());
45 | }
46 | 
47 | 


--------------------------------------------------------------------------------
/test/alg.nonmodifying/alg.gen.foreach/for_each_n.cpp:
--------------------------------------------------------------------------------
 1 | #include "gtest/gtest.h"
 2 | 
 3 | #include <vector>
 4 | 
 5 | #ifdef EXECUTION_POLICY
 6 | #include <experimental/algorithm>
 7 | #else
 8 | #include <algorithm>
 9 | #endif
10 | 
11 | TEST(for_each_n, Double){
12 | #ifdef EXECUTION_POLICY
13 |   using namespace std;
14 | #ifdef EXECUTION_POLICY
15 |   using namespace std::experimental;
16 | #endif
17 |   
18 |   vector<int> v{1,2,3,4,5,6,7,8,9,10,11,12};
19 |   const vector<int> golden{2,4,6,8,10,6,7,8,9,10,11,12};
20 | 
21 |   for_each_n(
22 |                 EXECUTION_POLICY,
23 |                 begin(v), 5,
24 |                 [](int &i){ i*= 2; });
25 | 
26 |   EXPECT_TRUE(v == golden);
27 | #else
28 |   // not in current standard
29 |   EXPECT_TRUE(true);
30 | #endif 
31 | }
32 | 
33 | TEST(for_each_n, Empty){
34 | #ifdef EXECUTION_POLICY
35 |   using namespace std;
36 | #ifdef EXECUTION_POLICY
37 |   using namespace std::experimental;
38 | #endif
39 |   
40 |   vector<int> v;
41 |   
42 |   for_each_n(
43 |                 EXECUTION_POLICY,
44 |                 begin(v), 0,
45 |                 [](int &i){ i = 0; });
46 | 
47 |   EXPECT_TRUE(v.empty());
48 | #else
49 |   // not in current standard
50 |   EXPECT_TRUE(true);
51 | #endif
52 | }
53 | 
54 | TEST(for_each_n, Zero){
55 | #ifdef EXECUTION_POLICY
56 |   using namespace std;
57 | #ifdef EXECUTION_POLICY
58 |   using namespace std::experimental;
59 | #endif
60 |   
61 |   vector<int> v{1,2,3,4,5,6,7,8,9,10,11,12};
62 |   const vector<int> golden{1,2,3,4,5,6,7,8,9,10,11,12};
63 |   
64 |   for_each_n(
65 |                 EXECUTION_POLICY,
66 |                 begin(v), 0,
67 |                 [](int &i){ i = -1; });
68 | 
69 |   EXPECT_TRUE(v == golden);
70 | #else
71 |   // not in current standard
72 |   EXPECT_TRUE(true);
73 | #endif
74 | }
75 | 
76 | 
77 | 
78 | 
79 | 


--------------------------------------------------------------------------------
/test/alg.nonmodifying/alg.gen.heap/is_heap.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(is_heap, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.nonmodifying/alg.gen.heap/is_heap_until.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(is_heap_until, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.nonmodifying/alg.gen.mismatch/mismatch.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(mismatch, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.nonmodifying/alg.gen.none_of/none_of.cpp:
--------------------------------------------------------------------------------
 1 | #include "gtest/gtest.h"
 2 | 
 3 | #include <vector>
 4 | 
 5 | #ifdef EXECUTION_POLICY
 6 | #include <experimental/algorithm>
 7 | #else
 8 | #include <algorithm>
 9 | #endif
10 | 
11 | TEST(none_of, True) {
12 |   using namespace std;
13 | #ifdef EXECUTION_POLICY
14 |   using namespace std::experimental;
15 | #endif
16 |   
17 |   const vector<int> v{1,2,3,4,5,6,7,8,9};
18 | 
19 |   // everything is less than 10
20 |   EXPECT_TRUE(none_of(
21 | #ifdef EXECUTION_POLICY
22 |                           EXECUTION_POLICY,
23 | #endif
24 |                           begin(v), end(v),
25 |                           [](const int &i){ return i == 10; }));
26 | }
27 | 
28 | TEST(none_of, False) {
29 |   using namespace std;
30 | #ifdef EXECUTION_POLICY
31 |   using namespace std::experimental;
32 | #endif
33 |   
34 |   const vector<int> v{1,2,3,4,5,6,7,8,9};
35 | 
36 |   // not everything is 1
37 |   EXPECT_FALSE(none_of(
38 | #ifdef EXECUTION_POLICY
39 |                            EXECUTION_POLICY,
40 | #endif
41 |                            begin(v), end(v),
42 |                            [](const int &i){ return i == 1; }));
43 | }
44 | 
45 | TEST(none_of, Empty) {
46 |   using namespace std;
47 | #ifdef EXECUTION_POLICY
48 |   using namespace std::experimental;
49 | #endif
50 |   
51 |   const vector<int> v;
52 |   
53 |   // empty range should return true regardless of the predicate
54 |   EXPECT_TRUE(none_of(
55 | #ifdef EXECUTION_POLICY
56 |                           EXECUTION_POLICY,
57 | #endif
58 |                           begin(v), end(v),
59 |                           [](const int &i){ return false; }));
60 | }
61 | 
62 | 


--------------------------------------------------------------------------------
/test/alg.nonmodifying/alg.gen.search/search.cpp:
--------------------------------------------------------------------------------
  1 | #include "gtest/gtest.h"
  2 | 
  3 | #include <vector>
  4 | 
  5 | #ifdef EXECUTION_POLICY
  6 | #include <experimental/algorithm>
  7 | #else
  8 | #include <algorithm>
  9 | #endif
 10 | 
 11 | TEST(search, Present_unique){
 12 |   using namespace std;
 13 | #ifdef EXECUTION_POLICY
 14 |   using namespace std::experimental;
 15 | #endif
 16 | 
 17 |   const vector<int> v1{1,2,3,4,5,6,7,8,9,10,11,12};
 18 |   const vector<int> v2{8,9,10};
 19 | 
 20 |   auto elt = search(
 21 | #ifdef EXECUTION_POLICY
 22 |                           EXECUTION_POLICY,
 23 | #endif
 24 |                           begin(v1), end(v1), begin(v2), end(v2));
 25 | 
 26 |   EXPECT_EQ(7, distance(begin(v1), elt));
 27 | }
 28 | 
 29 | TEST(search, Present_unique_fist){
 30 |   using namespace std;
 31 | #ifdef EXECUTION_POLICY
 32 |   using namespace std::experimental;
 33 | #endif
 34 | 
 35 |   const vector<int> v1{1,2,3,4,5,6,7,8,9,10,11,12};
 36 |   const vector<int> v2{1,2,3};
 37 | 
 38 |   auto elt = search(
 39 | #ifdef EXECUTION_POLICY
 40 |                           EXECUTION_POLICY,
 41 | #endif
 42 |                           begin(v1), end(v1), begin(v2), end(v2));
 43 | 
 44 |   EXPECT_EQ(0, distance(begin(v1), elt));
 45 | }
 46 | 
 47 | TEST(search, Present_unique_last){
 48 |   using namespace std;
 49 | #ifdef EXECUTION_POLICY
 50 |   using namespace std::experimental;
 51 | #endif
 52 | 
 53 |   const vector<int> v1{1,2,3,4,5,6,7,8,9,10,11,12};
 54 |   const vector<int> v2{12};
 55 | 
 56 |   auto elt = search(
 57 | #ifdef EXECUTION_POLICY
 58 |                           EXECUTION_POLICY,
 59 | #endif
 60 |                           begin(v1), end(v1), begin(v2), end(v2));
 61 | 
 62 |   EXPECT_EQ(11, distance(begin(v1), elt));
 63 | }
 64 | 
 65 | TEST(search, Present_multiple){
 66 |   using namespace std;
 67 | #ifdef EXECUTION_POLICY
 68 |   using namespace std::experimental;
 69 | #endif
 70 | 
 71 |   const vector<int> v1{1,2,3,4,5,6,7,8,9,10,11,12};
 72 |   const vector<int> v2{9,8,7};
 73 | 
 74 |   auto elt = search(
 75 | #ifdef EXECUTION_POLICY
 76 |                           EXECUTION_POLICY,
 77 | #endif
 78 |                           begin(v1), end(v1), begin(v2), end(v2),
 79 |                           [](const int &i1, const int &i2){return (i1<i2);});
 80 | 
 81 |   EXPECT_EQ(0, distance(begin(v1), elt));
 82 | }
 83 | 
 84 | TEST(search, Missing){
 85 |   using namespace std;
 86 | #ifdef EXECUTION_POLICY
 87 |   using namespace std::experimental;
 88 | #endif
 89 | 
 90 |   const vector<int> v1{1,2,3,4,5,6,7,8,9,10,11,12};
 91 |   const vector<int> v2{8,9,11};
 92 | 
 93 |   auto elt = search(
 94 | #ifdef EXECUTION_POLICY
 95 |                           EXECUTION_POLICY,
 96 | #endif
 97 |                           begin(v1), end(v1), begin(v2), end(v2));
 98 | 
 99 |   EXPECT_EQ(end(v1), elt);
100 | }
101 | 
102 | TEST(search, Empty_haystack){
103 |   using namespace std;
104 | #ifdef EXECUTION_POLICY
105 |   using namespace std::experimental;
106 | #endif
107 | 
108 |   const vector<int> v1;
109 |   const vector<int> v2{8,9,10};
110 | 
111 |   auto elt = search(
112 | #ifdef EXECUTION_POLICY
113 |                           EXECUTION_POLICY,
114 | #endif
115 |                           begin(v1), end(v1), begin(v2), end(v2));
116 | 
117 |   EXPECT_EQ(end(v1), elt);
118 | }
119 | 
120 | TEST(search, Empty_needle){
121 |   using namespace std;
122 | #ifdef EXECUTION_POLICY
123 |   using namespace std::experimental;
124 | #endif
125 | 
126 |   const vector<int> v1{1,2,3,4,5,6,7,8,9,10,11,12};
127 |   const vector<int> v2;
128 | 
129 |   auto elt = search(
130 | #ifdef EXECUTION_POLICY
131 |                           EXECUTION_POLICY,
132 | #endif
133 |                           begin(v1), end(v1), begin(v2), end(v2));
134 | 
135 |   EXPECT_EQ(begin(v1), elt);
136 | }
137 | 
138 | TEST(search, Needle_bigger_than_haystack){
139 |   using namespace std;
140 | #ifdef EXECUTION_POLICY
141 |   using namespace std::experimental;
142 | #endif
143 | 
144 |   const vector<int> v2{1,2,3,4,5,6,7,8,9,10,11,12};
145 |   const vector<int> v1{8,9,10};
146 | 
147 |   auto elt = search(
148 | #ifdef EXECUTION_POLICY
149 |                           EXECUTION_POLICY,
150 | #endif
151 |                           begin(v1), end(v1), begin(v2), end(v2));
152 | 
153 |   EXPECT_EQ(end(v1), elt);
154 | }
155 | 


--------------------------------------------------------------------------------
/test/alg.nonmodifying/alg.gen.search/search_n.cpp:
--------------------------------------------------------------------------------
  1 | #include "gtest/gtest.h"
  2 | 
  3 | #include <vector>
  4 | 
  5 | #ifdef EXECUTION_POLICY
  6 | #include <experimental/algorithm>
  7 | #else
  8 | #include <algorithm>
  9 | #endif
 10 | 
 11 | TEST(search_n, Present_unique){
 12 |   using namespace std;
 13 | #ifdef EXECUTION_POLICY
 14 |   using namespace std::experimental;
 15 | #endif
 16 | 
 17 |   const vector<int> v{1,1,2,2,2,3,3,3,4,4,5,5};
 18 |   const int needle = 4;
 19 |   const size_t count = 2;
 20 | 
 21 |   auto elt = search_n(
 22 | #ifdef EXECUTION_POLICY
 23 |                           EXECUTION_POLICY,
 24 | #endif
 25 |                           begin(v), end(v), count, needle);
 26 | 
 27 |   EXPECT_EQ(8, distance(begin(v), elt));
 28 | }
 29 | 
 30 | TEST(search_n, Present_unique_fist){
 31 |   using namespace std;
 32 | #ifdef EXECUTION_POLICY
 33 |   using namespace std::experimental;
 34 | #endif
 35 | 
 36 |   const vector<int> v{1,1,2,2,2,3,3,3,4,4,5,5};
 37 |   const int needle = 1;
 38 |   const size_t count = 2;
 39 | 
 40 |   auto elt = search_n(
 41 | #ifdef EXECUTION_POLICY
 42 |                           EXECUTION_POLICY,
 43 | #endif
 44 |                           begin(v), end(v), count, needle);
 45 | 
 46 |   EXPECT_EQ(0, distance(begin(v), elt));
 47 | }
 48 | 
 49 | TEST(search_n, Present_unique_last){
 50 |   using namespace std;
 51 | #ifdef EXECUTION_POLICY
 52 |   using namespace std::experimental;
 53 | #endif
 54 | 
 55 |   const vector<int> v{1,1,2,2,2,3,3,3,4,4,5,5};
 56 |   const int needle = 5;
 57 |   const size_t count = 2;
 58 | 
 59 |   auto elt = search_n(
 60 | #ifdef EXECUTION_POLICY
 61 |                           EXECUTION_POLICY,
 62 | #endif
 63 |                           begin(v), end(v), count, needle);
 64 | 
 65 |   EXPECT_EQ(10, distance(begin(v), elt));
 66 | }
 67 | 
 68 | TEST(search_n, Present_multiple){
 69 |   using namespace std;
 70 | #ifdef EXECUTION_POLICY
 71 |   using namespace std::experimental;
 72 | #endif
 73 | 
 74 |   const vector<int> v{1,1,2,2,2,3,3,3,4,4,5,5};
 75 |   const int needle = 4;
 76 |   const size_t count = 3;
 77 | 
 78 |   auto elt = search_n(
 79 | #ifdef EXECUTION_POLICY
 80 |                           EXECUTION_POLICY,
 81 | #endif
 82 |                           begin(v), end(v), count, needle,
 83 |                           [](const int a, const int b){return (a<b);});
 84 | 
 85 |   EXPECT_EQ(0, distance(begin(v), elt));
 86 | }
 87 | 
 88 | TEST(search_n, Missing){
 89 |   using namespace std;
 90 | #ifdef EXECUTION_POLICY
 91 |   using namespace std::experimental;
 92 | #endif
 93 | 
 94 |   const vector<int> v{1,1,2,2,2,3,3,3,4,4,5,5};
 95 |   const int needle = 4;
 96 |   const size_t count = 3;
 97 | 
 98 |   auto elt = search_n(
 99 | #ifdef EXECUTION_POLICY
100 |                           EXECUTION_POLICY,
101 | #endif
102 |                           begin(v), end(v), count, needle);
103 | 
104 |   EXPECT_EQ(end(v), elt);
105 | }
106 | 
107 | TEST(search_n, Empty_haystack){
108 |   using namespace std;
109 | #ifdef EXECUTION_POLICY
110 |   using namespace std::experimental;
111 | #endif
112 | 
113 |   const vector<int> v{};
114 |   const int needle = 4;
115 |   const size_t count = 2;
116 | 
117 |   auto elt = search_n(
118 | #ifdef EXECUTION_POLICY
119 |                           EXECUTION_POLICY,
120 | #endif
121 |                           begin(v), end(v), count, needle);
122 | 
123 |   EXPECT_EQ(end(v), elt);
124 | }
125 | 
126 | TEST(search_n, Zero_repititions){
127 |   using namespace std;
128 | #ifdef EXECUTION_POLICY
129 |   using namespace std::experimental;
130 | #endif
131 | 
132 |   const vector<int> v{1,1,2,2,2,3,3,3,4,4,5,5};
133 |   const int needle = 4;
134 |   const size_t count = 0;
135 | 
136 |   auto elt = search_n(
137 | #ifdef EXECUTION_POLICY
138 |                           EXECUTION_POLICY,
139 | #endif
140 |                           begin(v), end(v), count, needle);
141 | 
142 |   EXPECT_EQ(begin(v), elt);
143 | }
144 | 
145 | TEST(search_n, Too_many_repititions){
146 |   using namespace std;
147 | #ifdef EXECUTION_POLICY
148 |   using namespace std::experimental;
149 | #endif
150 | 
151 |   const vector<int> v{1,1,2,2,2,3,3,3,4,4,5,5};
152 |   const int needle = 4;
153 |   const size_t count = 42;
154 | 
155 |   auto elt = search_n(
156 | #ifdef EXECUTION_POLICY
157 |                           EXECUTION_POLICY,
158 | #endif
159 |                           begin(v), end(v), count, needle);
160 | 
161 |   EXPECT_EQ(end(v), elt);
162 | }
163 | 


--------------------------------------------------------------------------------
/test/alg.nonmodifying/alg.numerics.inner.product/inner_product.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(inner_product, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.sorting/alg.gen.lex.comparison/lexicographical_compare.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(lexicographical_compare, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.sorting/alg.gen.merge/inplace_merge.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(inplace_merge, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.sorting/alg.gen.merge/merge.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(merge, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.sorting/alg.gen.nth.element/nth_element.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(nth_element, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.sorting/alg.gen.set.operations/includes/includes.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(includes, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.sorting/alg.gen.set.operations/set.difference/set_difference.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(set_difference, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.sorting/alg.gen.set.operations/set.intersection/set_intersection.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(set_intersection, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.sorting/alg.gen.set.operations/set.symmetric.difference/set_symmetric_difference.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(set_symmetric_difference, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.sorting/alg.gen.set.operations/set.union/set_union.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(set_union, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.sorting/alg.gen.sort/is.sorted/is_sorted.cpp:
--------------------------------------------------------------------------------
  1 | #include "gtest/gtest.h"
  2 | 
  3 | #include <vector>
  4 | 
  5 | #ifdef EXECUTION_POLICY
  6 | #include <experimental/algorithm>
  7 | #else
  8 | #include <algorithm>
  9 | #endif
 10 | 
 11 | TEST(is_sorted, Empty){
 12 |   using namespace std;
 13 | #ifdef EXECUTION_POLICY
 14 |   using namespace std::experimental;
 15 | #endif
 16 |   const vector<int> v;
 17 |   
 18 |   EXPECT_TRUE(is_sorted(
 19 | #ifdef EXECUTION_POLICY
 20 |                         EXECUTION_POLICY,
 21 | #endif
 22 |                         begin(v), end(v)));
 23 | }
 24 | 
 25 | TEST(is_sorted, Sorted) {
 26 |   using namespace std;
 27 | #ifdef EXECUTION_POLICY
 28 |   using namespace std::experimental;
 29 | #endif
 30 |   const vector<int> v = { 1,2,3,4,5,7,8,9};
 31 |   
 32 |   EXPECT_TRUE(is_sorted(
 33 | #ifdef EXECUTION_POLICY
 34 |                         EXECUTION_POLICY,
 35 | #endif
 36 |                         begin(v), end(v)));
 37 | }
 38 | 
 39 | TEST(is_sorted, SortedDuplicates){
 40 |   using namespace std;
 41 | #ifdef EXECUTION_POLICY
 42 |   using namespace std::experimental;
 43 | #endif
 44 |   const vector<int> v = { 1,2,3,4,4,4,5,5,7,8,8,9};
 45 |   
 46 |   EXPECT_TRUE(is_sorted(
 47 | #ifdef EXECUTION_POLICY
 48 |                         EXECUTION_POLICY,
 49 | #endif
 50 |                         begin(v), end(v)));
 51 | }
 52 | 
 53 | TEST(is_sorted, Unsorted){
 54 |   using namespace std;
 55 | #ifdef EXECUTION_POLICY
 56 |   using namespace std::experimental;
 57 | #endif
 58 |   const vector<int> v = { 8,4,6,7,1,5,9,4,57,2,1};
 59 |   
 60 |   EXPECT_FALSE(is_sorted(
 61 | #ifdef EXECUTION_POLICY
 62 |                          EXECUTION_POLICY,
 63 | #endif
 64 |                          begin(v), end(v)));
 65 | }
 66 | 
 67 | bool mySortingComp (int i,int j) { return i>j; }
 68 | 
 69 | TEST(is_sorted, EmptyComp){
 70 |   using namespace std;
 71 | #ifdef EXECUTION_POLICY
 72 |   using namespace std::experimental;
 73 | #endif
 74 |   const vector<int> v;
 75 |   
 76 |   EXPECT_TRUE(is_sorted(
 77 | #ifdef EXECUTION_POLICY
 78 |                         EXECUTION_POLICY,
 79 | #endif
 80 |                         begin(v), end(v), mySortingComp));
 81 | }
 82 | 
 83 | TEST(is_sorted, SortedComp) {
 84 |   using namespace std;
 85 | #ifdef EXECUTION_POLICY
 86 |   using namespace std::experimental;
 87 | #endif
 88 |   const vector<int> v = {9,8,7,6,5,4,3,2,1};
 89 |   
 90 |   EXPECT_TRUE(is_sorted(
 91 | #ifdef EXECUTION_POLICY
 92 |                         EXECUTION_POLICY,
 93 | #endif
 94 |                         begin(v), end(v), mySortingComp));
 95 | }
 96 | 
 97 | TEST(is_sorted, SortedDuplicatesComp){
 98 |   using namespace std;
 99 | #ifdef EXECUTION_POLICY
100 |   using namespace std::experimental;
101 | #endif
102 |   const vector<int> v = {9,8,8,7,6,6,6,5,4,4,3,2,2,2,1};
103 |   
104 |   EXPECT_TRUE(is_sorted(
105 | #ifdef EXECUTION_POLICY
106 |                         EXECUTION_POLICY,
107 | #endif
108 |                         begin(v), end(v), mySortingComp));
109 | }
110 | 
111 | TEST(is_sorted, UnsortedComp){
112 |   using namespace std;
113 | #ifdef EXECUTION_POLICY
114 |   using namespace std::experimental;
115 | #endif
116 |   const vector<int> v = { 8,4,6,7,1,5,9,4,57,2,1};
117 |   
118 |   EXPECT_FALSE(is_sorted(
119 | #ifdef EXECUTION_POLICY
120 |                          EXECUTION_POLICY,
121 | #endif
122 |                          begin(v), end(v), mySortingComp));
123 | }
124 | 
125 | 
126 | 


--------------------------------------------------------------------------------
/test/alg.sorting/alg.gen.sort/is.sorted/is_sorted_until.cpp:
--------------------------------------------------------------------------------
  1 | #include "gtest/gtest.h"
  2 | 
  3 | #include <vector>
  4 | 
  5 | #ifdef EXECUTION_POLICY
  6 | #include <experimental/algorithm>
  7 | #else
  8 | #include <algorithm>
  9 | #endif
 10 | 
 11 | TEST(is_sorted_until, Empty){
 12 |   using namespace std;
 13 | #ifdef EXECUTION_POLICY
 14 |   using namespace std::experimental;
 15 | #endif
 16 |   const vector<int> v;
 17 |   
 18 |   EXPECT_TRUE(is_sorted_until(
 19 | #ifdef EXECUTION_POLICY
 20 |                               EXECUTION_POLICY,
 21 | #endif
 22 |                               begin(v), end(v)) == end(v));
 23 | }
 24 | 
 25 | TEST(is_sorted_until, EmptyRange) {
 26 |   using namespace std;
 27 | #ifdef EXECUTION_POLICY
 28 |   using namespace std::experimental;
 29 | #endif
 30 |   const vector<int> v = {3,2,1,0};
 31 |   
 32 |   EXPECT_TRUE(is_sorted_until(
 33 | #ifdef EXECUTION_POLICY
 34 |                               EXECUTION_POLICY,
 35 | #endif
 36 |                               begin(v), begin(v)+1) == begin(v)+1);
 37 | }
 38 | 
 39 | 
 40 | TEST(is_sorted_until, Sorted) {
 41 |   using namespace std;
 42 | #ifdef EXECUTION_POLICY
 43 |   using namespace std::experimental;
 44 | #endif
 45 |   const vector<int> v = { 1,2,3,4,5,7,8,9};
 46 |   
 47 |   EXPECT_TRUE(is_sorted_until(
 48 | #ifdef EXECUTION_POLICY
 49 |                               EXECUTION_POLICY,
 50 | #endif
 51 |                               begin(v), end(v)) == end(v));
 52 | }
 53 | 
 54 | TEST(is_sorted_until, SortedDuplicates){
 55 |   using namespace std;
 56 | #ifdef EXECUTION_POLICY
 57 |   using namespace std::experimental;
 58 | #endif
 59 |   const vector<int> v = { 1,2,3,4,4,4,5,5,7,8,8,9};
 60 |   
 61 |   EXPECT_TRUE(is_sorted_until(
 62 | #ifdef EXECUTION_POLICY
 63 |                               EXECUTION_POLICY,
 64 | #endif
 65 |                               begin(v), end(v)) == end(v));
 66 | }
 67 | 
 68 | TEST(is_sorted_until, Unsorted){
 69 |   using namespace std;
 70 | #ifdef EXECUTION_POLICY
 71 |   using namespace std::experimental;
 72 | #endif
 73 |   const vector<int> v = { 1,4,6,7,1,5,9,4,57,2,1};
 74 |   
 75 |   auto it = is_sorted_until(
 76 | #ifdef EXECUTION_POLICY
 77 |                             EXECUTION_POLICY,
 78 | #endif
 79 |                             begin(v), end(v));
 80 | 
 81 |   EXPECT_TRUE(it - begin(v) == 4);
 82 | }
 83 | 
 84 | 
 85 | bool SortedUntilComp (int i,int j) { return (i>j); }
 86 | 
 87 | TEST(is_sorted_until, EmptyComp){
 88 |   using namespace std;
 89 | #ifdef EXECUTION_POLICY
 90 |   using namespace std::experimental;
 91 | #endif
 92 |   const vector<int> v;
 93 |   
 94 |   EXPECT_TRUE(is_sorted_until(
 95 | #ifdef EXECUTION_POLICY
 96 |                               EXECUTION_POLICY,
 97 | #endif
 98 |                               begin(v), end(v), SortedUntilComp) == end(v));
 99 | }
100 | 
101 | TEST(is_sorted_until, EmptyRangeComp) {
102 |   using namespace std;
103 | #ifdef EXECUTION_POLICY
104 |   using namespace std::experimental;
105 | #endif
106 |   const vector<int> v = {3,2,1,0};
107 |   
108 |   EXPECT_TRUE(is_sorted_until(
109 | #ifdef EXECUTION_POLICY
110 |                               EXECUTION_POLICY,
111 | #endif
112 |                               begin(v), begin(v)+1, SortedUntilComp) == begin(v)+1);
113 | }
114 | 
115 | 
116 | TEST(is_sorted_until, SortedComp) {
117 |   using namespace std;
118 | #ifdef EXECUTION_POLICY
119 |   using namespace std::experimental;
120 | #endif
121 |   const vector<int> v = { 9,8,7,6,5,4,3,2,1};
122 |   
123 |   EXPECT_TRUE(is_sorted_until(
124 | #ifdef EXECUTION_POLICY
125 |                               EXECUTION_POLICY,
126 | #endif
127 |                               begin(v), end(v), SortedUntilComp) == end(v));
128 | }
129 | 
130 | TEST(is_sorted_until, SortedDuplicatesComp){
131 |   using namespace std;
132 | #ifdef EXECUTION_POLICY
133 |   using namespace std::experimental;
134 | #endif
135 |   const vector<int> v = { 9,8,8,7,6,6,5,4,4,4,3,2,1,1,1};
136 |   
137 |   EXPECT_TRUE(is_sorted_until(
138 | #ifdef EXECUTION_POLICY
139 |                               EXECUTION_POLICY,
140 | #endif
141 |                               begin(v), end(v), SortedUntilComp) == end(v));
142 | }
143 | 
144 | TEST(is_sorted_until, UnsortedComp){
145 |   using namespace std;
146 | #ifdef EXECUTION_POLICY
147 |   using namespace std::experimental;
148 | #endif
149 |   const vector<int> v = { 6,5,4,4,1,5,9,4,57,2,1};
150 |   
151 |   auto it = is_sorted_until(
152 | #ifdef EXECUTION_POLICY
153 |                             EXECUTION_POLICY,
154 | #endif
155 |                             begin(v), end(v), SortedUntilComp);
156 | 
157 |   EXPECT_TRUE(it - begin(v) == 5);
158 | }
159 | 
160 | 
161 | 
162 | 


--------------------------------------------------------------------------------
/test/alg.sorting/alg.gen.sort/partial.sort.copy/partial_sort_copy.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(partial_sort_copy, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.sorting/alg.gen.sort/partial.sort/partial_sort.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | TEST(partial_sort, NotImplemented){
4 |    EXPECT_TRUE(false);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/alg.sorting/alg.gen.sort/stable.sort/stable_sort.cpp:
--------------------------------------------------------------------------------
  1 | #include "gtest/gtest.h"
  2 | 
  3 | #include <vector>
  4 | 
  5 | #ifdef EXECUTION_POLICY
  6 | #include <experimental/algorithm>
  7 | #else
  8 | #include <algorithm>
  9 | #endif
 10 | 
 11 | TEST(stable_sort, PlainSort){
 12 |   using namespace std;
 13 | #ifdef EXECUTION_POLICY
 14 |   using namespace std::experimental;
 15 | #endif
 16 | 
 17 |   vector<int> v{1,4,8,7,2,1,5,4,6,5,7,2,5,1,0};
 18 | 
 19 |   stable_sort(
 20 | #ifdef EXECUTION_POLICY
 21 |               EXECUTION_POLICY,
 22 | #endif
 23 |               begin(v), end(v));
 24 | 
 25 |   EXPECT_TRUE(is_sorted(begin(v), end(v)));
 26 | }
 27 | 
 28 | TEST(stable_sort, Sorted){
 29 |   using namespace std;
 30 | #ifdef EXECUTION_POLICY
 31 |   using namespace std::experimental;
 32 | #endif
 33 | 
 34 |   vector<int> v{1,2,3,4,5,6,7,8,9,10};
 35 | 
 36 |   stable_sort(
 37 | #ifdef EXECUTION_POLICY
 38 |               EXECUTION_POLICY,
 39 | #endif
 40 |               begin(v), end(v));
 41 | 
 42 |   EXPECT_TRUE(is_sorted(begin(v), end(v)));
 43 | }
 44 | 
 45 | 
 46 | TEST(stable_sort, Empty){
 47 |   using namespace std;
 48 | #ifdef EXECUTION_POLICY
 49 |   using namespace std::experimental;
 50 | #endif
 51 | 
 52 |   vector<int> v;
 53 | 
 54 |   stable_sort(
 55 | #ifdef EXECUTION_POLICY
 56 |               EXECUTION_POLICY,
 57 | #endif
 58 |               begin(v), end(v));
 59 | 
 60 |   EXPECT_TRUE(is_sorted(begin(v), end(v)));
 61 | }
 62 | 
 63 | TEST(stable_sort, StableSortComp){
 64 |   using namespace std;
 65 | #ifdef EXECUTION_POLICY
 66 |   using namespace std::experimental;
 67 | #endif
 68 | 
 69 |   vector<double> v{9.0, 8.5, 8.0, 7.75, 7.5, 7.25, 7.0, 6.5, 6.0, 5.5, 5.0};
 70 | 
 71 |   stable_sort(
 72 | #ifdef EXECUTION_POLICY
 73 |               EXECUTION_POLICY,
 74 | #endif
 75 |               begin(v), end(v),
 76 |               [](const double &a, const double &b){
 77 |                  return (int)a < (int)b;
 78 |               });
 79 | 
 80 |   EXPECT_TRUE(is_sorted(begin(v), end(v),
 81 |               [](const double &a, const double &b) {
 82 |                 return (int)a < (int)b || ((int)a == (int)b && a > b);
 83 |               }));
 84 | }
 85 | 
 86 | TEST(stable_sort, Sortable){
 87 |   using namespace std;
 88 | #ifdef EXECUTION_POLICY
 89 |   using namespace std::experimental;
 90 | #endif
 91 | 
 92 |   struct Sortable {
 93 |     int payload;
 94 |     bool operator < (const Sortable &other) const {
 95 |       return payload > other.payload;
 96 |     }
 97 |   };
 98 | 
 99 |   vector<Sortable> v{{1}, {3}, {2}, {6}, {4}, {5}};
100 | 
101 |   stable_sort(
102 | #ifdef EXECUTION_POLICY
103 |               EXECUTION_POLICY,
104 | #endif
105 |               begin(v), end(v));
106 | 
107 |   EXPECT_TRUE(is_sorted(begin(v), end(v)));
108 | }
109 | 
110 | 


--------------------------------------------------------------------------------