Add experimental::sample and experimental::shuffle from N4531

The additions to <experimental/random> were added in 2015 but the new
algorithms in <experimental/algorithm> were not. This adds them.

	* include/experimental/algorithm (sample, shuffle): Add new overloads
	using per-thread random number engine.
	* testsuite/experimental/algorithm/sample.cc: Simpify and reduce
	dependencies by using __gnu_test::test_container.
	* testsuite/experimental/algorithm/sample-2.cc: New.
	* testsuite/experimental/algorithm/shuffle.cc: New.

From-SVN: r262024

libstdc++-v3/ChangeLog

+2018-06-25  Jonathan Wakely  <jwakely@redhat.com>
+
+	* include/experimental/algorithm (sample, shuffle): Add new overloads
+	using per-thread random number engine.
+	* testsuite/experimental/algorithm/sample.cc: Simpify and reduce
+	dependencies by using __gnu_test::test_container.
+	* testsuite/experimental/algorithm/sample-2.cc: New.
+	* testsuite/experimental/algorithm/shuffle.cc: New.
+
 2018-06-22  Jonathan Wakely  <jwakely@redhat.com>
 
 	* config/abi/pre/gnu.ver: Fix __cxx11::basic_string patterns for

libstdc++-v3/include/experimental/algorithm

@@ -35,6 +35,7 @@
 
 #include <algorithm>
 #include <experimental/bits/lfts_config.h>
+#include <experimental/random>
 
 namespace std _GLIBCXX_VISIBILITY(default)
 {
@@ -42,7 +43,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
 namespace experimental
 {
-inline namespace fundamentals_v1
+inline namespace fundamentals_v2
 {
   template<typename _ForwardIterator, typename _Searcher>
     inline _ForwardIterator
@@ -79,7 +80,23 @@ inline namespace fundamentals_v1
 			   __d,
 			   std::forward<_UniformRandomNumberGenerator>(__g));
     }
-} // namespace fundamentals_v1
+
+  template<typename _PopulationIterator, typename _SampleIterator,
+           typename _Distance>
+    inline _SampleIterator
+    sample(_PopulationIterator __first, _PopulationIterator __last,
+	   _SampleIterator __out, _Distance __n)
+    {
+      return experimental::sample(__first, __last, __out, __n,
+				  _S_randint_engine());
+    }
+
+  template<typename _RandomAccessIterator>
+    inline void
+    shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    { return std::shuffle(__first, __last, _S_randint_engine()); }
+
+} // namespace fundamentals_v2
 } // namespace experimental
 
 _GLIBCXX_END_NAMESPACE_VERSION

libstdc++-v3/testsuite/experimental/algorithm/sample-2.cc

+// Copyright (C) 2018 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-do run { target c++14 } }
+
+#include <experimental/algorithm>
+#include <algorithm>
+#include <testsuite_hooks.h>
+#include <testsuite_iterators.h>
+
+using __gnu_test::test_container;
+using __gnu_test::input_iterator_wrapper;
+using __gnu_test::output_iterator_wrapper;
+using __gnu_test::forward_iterator_wrapper;
+
+void
+test01()
+{
+  const int pop[] = { 1, 2 };
+  int samp[10] = { };
+
+  // population smaller than desired sample size
+  auto it = std::experimental::sample(pop, pop + 2, samp, 10);
+  VERIFY( it == samp + 2 );
+  VERIFY( std::accumulate(samp, samp + 10, 0) == 3 );
+}
+
+void
+test02()
+{
+  const int pop[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
+  int samp[10] = { };
+
+  auto it = std::experimental::sample(pop, std::end(pop), samp, 10);
+  VERIFY( it == samp + 10 );
+
+  std::sort(samp, it);
+  auto it2 = std::unique(samp, it);
+  VERIFY( it2 == it );
+}
+
+void
+test03()
+{
+  const int pop[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, };
+  int samp[5] = { };
+
+  // input iterator for population
+  test_container<const int, input_iterator_wrapper> pop_in{pop};
+  auto it = std::experimental::sample(pop_in.begin(), pop_in.end(), samp, 5);
+  VERIFY( it == samp + 5 );
+
+  std::sort(samp, it);
+  auto it2 = std::unique(samp, it);
+  VERIFY( it2 == it );
+}
+
+void
+test04()
+{
+  const int pop[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+  int samp[5] = { };
+
+  // forward iterator for population and output iterator for result
+  test_container<const int, forward_iterator_wrapper> pop_fwd{pop};
+  test_container<int, output_iterator_wrapper> samp_out{samp};
+  auto it = std::experimental::sample(pop_fwd.begin(), pop_fwd.end(),
+				      samp_out.begin(), 5);
+
+  VERIFY( std::distance(samp, it.ptr) == 5 );
+
+  std::sort(samp, it.ptr);
+  auto it2 = std::unique(samp, it.ptr);
+  VERIFY( it2 == it.ptr );
+}
+
+int
+main()
+{
+  test01();
+  test02();
+  test03();
+  test04();
+}

libstdc++-v3/testsuite/experimental/algorithm/sample.cc

@@ -18,18 +18,16 @@
 // { dg-do run { target c++14 } }
 
 #include <experimental/algorithm>
-#include <iterator>
-#include <sstream>
-#include <forward_list>
-#include <vector>
 #include <random>
-#include <algorithm>
 #include <testsuite_hooks.h>
+#include <testsuite_iterators.h>
 
-std::mt19937 rng;
+using __gnu_test::test_container;
+using __gnu_test::input_iterator_wrapper;
+using __gnu_test::output_iterator_wrapper;
+using __gnu_test::forward_iterator_wrapper;
 
-using std::istream_iterator;
-using std::ostream_iterator;
+std::mt19937 rng;
 
 void
 test01()
@@ -60,11 +58,12 @@ test02()
 void
 test03()
 {
-  std::istringstream pop("0 1 2 3 4 5 6 7 8 9");
+  const int pop[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, };
   int samp[5] = { };
 
   // input iterator for population
-  auto it = std::experimental::sample(istream_iterator<int>{pop}, {},
+  test_container<const int, input_iterator_wrapper> pop_in{pop};
+  auto it = std::experimental::sample(pop_in.begin(), pop_in.end(),
                                       samp,
                                       5, rng);
   VERIFY( it == samp + 5 );
@@ -77,21 +76,20 @@ test03()
 void
 test04()
 {
-  std::forward_list<int> pop{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
-  std::stringstream samp;
+  const int pop[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+  int samp[5] = { };
 
   // forward iterator for population and output iterator for result
-  std::experimental::sample(pop.begin(), pop.end(),
-                            ostream_iterator<int>{samp, " "},
-                            5, rng);
+  test_container<const int, forward_iterator_wrapper> pop_fwd{pop};
+  test_container<int, output_iterator_wrapper> samp_out{samp};
+  auto it = std::experimental::sample(pop_fwd.begin(), pop_fwd.end(),
+				      samp_out.begin(), 5, rng);
 
-  // samp.rdbuf()->pubseekoff(0, std::ios::beg);
-  std::vector<int> v(istream_iterator<int>{samp}, {});
-  VERIFY( v.size() == 5 );
+  VERIFY( std::distance(samp, it.ptr) == 5 );
 
-  std::sort(v.begin(), v.end());
-  auto it = std::unique(v.begin(), v.end());
-  VERIFY( it == v.end() );
+  std::sort(samp, it.ptr);
+  auto it2 = std::unique(samp, it.ptr);
+  VERIFY( it2 == it.ptr );
 }
 
 int

libstdc++-v3/testsuite/experimental/algorithm/shuffle.cc

+// { dg-do run { target c++14 } }
+
+// Derived from: 2010-03-19  Paolo Carlini  <paolo.carlini@oracle.com>
+
+// Copyright (C) 2010-2018 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <experimental/algorithm>
+#include <vector>
+#include <testsuite_hooks.h>
+
+void test01()
+{
+  for (unsigned size = 0; size < 50; ++size)
+    {
+      std::vector<int> vref(size);
+      std::iota(vref.begin(), vref.end(), 0);
+      std::vector<int> v1(vref), v2(vref);
+
+      std::experimental::shuffle(v1.begin(), v1.end());
+      std::experimental::shuffle(v2.begin(), v2.end());
+
+      if (size >= 10)
+	{
+	  VERIFY( !std::equal(v1.begin(), v1.end(), vref.begin()) );
+	  VERIFY( !std::equal(v2.begin(), v2.end(), vref.begin()) );
+	  VERIFY( !std::equal(v1.begin(), v1.end(), v2.begin()) );
+	}
+
+      for (unsigned ind = 0; ind < size; ++ind)
+	{
+	  auto it1 = std::find(v1.begin(), v1.end(), vref[ind]);
+	  auto it2 = std::find(v2.begin(), v2.end(), vref[ind]);
+	  VERIFY( it1 != v1.end() );
+	  VERIFY( it2 != v2.end() );
+	  v1.erase(it1);
+	  v2.erase(it2);
+	}
+      VERIFY( v1.empty() );
+      VERIFY( v2.empty() );
+    }
+}
+
+int main()
+{
+  test01();
+}