整理

include/boost/algorithm/cxx17/exclusive_scan.hpp

@@ -0,0 +1,53 @@
+/*
+   Copyright (c) Marshall Clow 2017.
+
+   Distributed under the Boost Software License, Version 1.0. (See accompanying
+   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+/// \file  exclusive_scan.hpp
+/// \brief ???
+/// \author Marshall Clow
+
+#ifndef BOOST_ALGORITHM_EXCLUSIVE_SCAN_HPP
+#define BOOST_ALGORITHM_EXCLUSIVE_SCAN_HPP
+
+#include <functional>     // for std::plus
+#include <iterator>       // for std::iterator_traits
+
+#include <boost/config.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/value_type.hpp>
+
+namespace boost { namespace algorithm {
+
+template<class InputIterator, class OutputIterator, class T, class BinaryOperation>
+OutputIterator exclusive_scan(InputIterator first, InputIterator last,
+                              OutputIterator result, T init, BinaryOperation bOp)
+{
+    if (first != last)
+    {
+        T saved = init;
+        do
+        {
+            init = bOp(init, *first);
+            *result = saved;
+            saved = init;
+            ++result;
+        } while (++first != last);
+    }
+    return result;
+}
+
+template<class InputIterator, class OutputIterator, class T>
+OutputIterator exclusive_scan(InputIterator first, InputIterator last,
+                              OutputIterator result, T init)
+{
+	typedef typename std::iterator_traits<InputIterator>::value_type VT;
+    return boost::algorithm::exclusive_scan(first, last, result, init, std::plus<VT>());
+}
+
+}} // namespace boost and algorithm
+
+#endif // BOOST_ALGORITHM_EXCLUSIVE_SCAN_HPP

include/boost/algorithm/cxx17/for_each_n.hpp

@@ -0,0 +1,39 @@
+/*
+   Copyright (c) Marshall Clow 2017.
+
+   Distributed under the Boost Software License, Version 1.0. (See accompanying
+   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+/// \file  for_each_n.hpp
+/// \brief Apply a functor to the elements of a sequence
+/// \author Marshall Clow
+
+#ifndef BOOST_ALGORITHM_FOR_EACH_N_HPP
+#define BOOST_ALGORITHM_FOR_EACH_N_HPP
+
+#include <utility>      // for std::pair
+
+#include <boost/config.hpp>
+
+namespace boost { namespace algorithm {
+
+/// \fn for_each_n(InputIterator first, Size n, Function f);
+/// \return first + n
+///
+/// \param first    The start of the first range.
+/// \param n        One past the end of the first range.
+/// \param f        A functor to apply to the elements of the sequence
+/// \note           If f returns a result, the result is ignored.
+template<class InputIterator, class Size, class Function>
+InputIterator for_each_n(InputIterator first, Size n, Function f)
+{
+    for ( ; n > 0; --n, ++first )
+        f(*first);
+
+    return first;
+}
+
+}} // namespace boost and algorithm
+
+#endif // BOOST_ALGORITHM_FOR_EACH_N_HPP

include/boost/algorithm/cxx17/inclusive_scan.hpp

@@ -0,0 +1,61 @@
+/*
+   Copyright (c) Marshall Clow 2017.
+
+   Distributed under the Boost Software License, Version 1.0. (See accompanying
+   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+/// \file  transform_reduce.hpp
+/// \brief Combine the (transformed) elements of a sequence (or two) into a single value.
+/// \author Marshall Clow
+
+#ifndef BOOST_ALGORITHM_INCLUSIVE_SCAN_HPP
+#define BOOST_ALGORITHM_INCLUSIVE_SCAN_HPP
+
+#include <functional>     // for std::plus
+#include <iterator>       // for std::iterator_traits
+
+#include <boost/config.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/value_type.hpp>
+
+namespace boost { namespace algorithm {
+
+template<class InputIterator, class OutputIterator, class T, class BinaryOperation>
+OutputIterator inclusive_scan(InputIterator first, InputIterator last,
+                              OutputIterator result, BinaryOperation bOp, T init)
+{
+    for (; first != last; ++first, (void) ++result) {
+        init = bOp(init, *first);
+        *result = init;
+        }
+    return result;
+}
+
+
+template<class InputIterator, class OutputIterator, class BinaryOperation>
+OutputIterator inclusive_scan(InputIterator first, InputIterator last,
+                              OutputIterator result, BinaryOperation bOp)
+{
+    if (first != last) {
+        typename std::iterator_traits<InputIterator>::value_type init = *first;
+        *result++ = init;
+        if (++first != last)
+            return boost::algorithm::inclusive_scan(first, last, result, bOp, init);
+        }
+
+    return result;
+}
+
+template<class InputIterator, class OutputIterator>
+OutputIterator inclusive_scan(InputIterator first, InputIterator last,
+                   OutputIterator result)
+{
+    typedef typename std::iterator_traits<InputIterator>::value_type VT;
+    return boost::algorithm::inclusive_scan(first, last, result, std::plus<VT>());
+}
+
+}} // namespace boost and algorithm
+
+#endif // BOOST_ALGORITHM_INCLUSIVE_SCAN_HPP

include/boost/algorithm/cxx17/reduce.hpp

@@ -0,0 +1,73 @@
+/*
+   Copyright (c) Marshall Clow 2017.
+
+   Distributed under the Boost Software License, Version 1.0. (See accompanying
+   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+/// \file  reduce.hpp
+/// \brief Combine the elements of a sequence into a single value
+/// \author Marshall Clow
+
+#ifndef BOOST_ALGORITHM_REDUCE_HPP
+#define BOOST_ALGORITHM_REDUCE_HPP
+
+#include <functional>     // for std::plus
+#include <iterator>       // for std::iterator_traits
+
+#include <boost/config.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/value_type.hpp>
+
+namespace boost { namespace algorithm {
+
+template<class InputIterator, class T, class BinaryOperation>
+T reduce(InputIterator first, InputIterator last, T init, BinaryOperation bOp)
+{
+    ;
+    for (; first != last; ++first)
+        init = bOp(init, *first);
+    return init;
+}
+
+template<class InputIterator, class T>
+T reduce(InputIterator first, InputIterator last, T init)
+{
+	typedef typename std::iterator_traits<InputIterator>::value_type VT;
+    return boost::algorithm::reduce(first, last, init, std::plus<VT>());
+}
+
+template<class InputIterator>
+typename std::iterator_traits<InputIterator>::value_type
+reduce(InputIterator first, InputIterator last)
+{
+    return boost::algorithm::reduce(first, last,
+       typename std::iterator_traits<InputIterator>::value_type());
+}
+
+template<class Range>
+typename boost::range_value<Range>::type
+reduce(const Range &r)
+{
+    return boost::algorithm::reduce(boost::begin(r), boost::end(r));
+}
+
+//	Not sure that this won't be ambiguous (1)
+template<class Range, class T>
+T reduce(const Range &r, T init)
+{
+    return boost::algorithm::reduce(boost::begin (r), boost::end (r), init);
+}
+
+
+//	Not sure that this won't be ambiguous (2)
+template<class Range, class T, class BinaryOperation>
+T reduce(const Range &r, T init, BinaryOperation bOp)
+{
+    return boost::algorithm::reduce(boost::begin(r), boost::end(r), init, bOp);
+}
+
+}} // namespace boost and algorithm
+
+#endif // BOOST_ALGORITHM_REDUCE_HPP

include/boost/algorithm/cxx17/transform_exclusive_scan.hpp

@@ -0,0 +1,62 @@
+/*
+   Copyright (c) Marshall Clow 2017.
+
+   Distributed under the Boost Software License, Version 1.0. (See accompanying
+   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+/// \file  transform_exclusive_scan.hpp
+/// \brief ????
+/// \author Marshall Clow
+
+#ifndef BOOST_ALGORITHM_TRANSFORM_EXCLUSIVE_SCAN_HPP
+#define BOOST_ALGORITHM_TRANSFORM_EXCLUSIVE_SCAN_HPP
+
+#include <functional>     // for std::plus
+#include <iterator>       // for std::iterator_traits
+
+#include <boost/config.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/value_type.hpp>
+
+namespace boost { namespace algorithm {
+
+/// \fn transform_exclusive_scan ( InputIterator first, InputIterator last, OutputIterator result, BinaryOperation bOp, UnaryOperation uOp, T init )
+/// \brief Transforms elements from the input range with uOp and then combines
+/// those transformed elements with bOp such that the n-1th element and the nth
+/// element are combined. Exclusivity means that the nth element is not
+/// included in the nth combination.
+/// \return The updated output iterator
+///
+/// \param first  The start of the input sequence
+/// \param last   The end of the input sequence
+/// \param result The output iterator to write the results into
+/// \param bOp    The operation for combining transformed input elements
+/// \param uOp    The operation for transforming input elements
+/// \param init   The initial value
+///
+/// \note This function is part of the C++17 standard library
+template<class InputIterator, class OutputIterator, class T,
+         class BinaryOperation, class UnaryOperation>
+OutputIterator transform_exclusive_scan(InputIterator first, InputIterator last,
+                                        OutputIterator result, T init,
+                                        BinaryOperation bOp, UnaryOperation uOp)
+{
+    if (first != last)
+    {
+        T saved = init;
+        do
+        {
+            init = bOp(init, uOp(*first));
+            *result = saved;
+            saved = init;
+            ++result;
+        } while (++first != last);
+    }
+    return result;
+}
+
+}} // namespace boost and algorithm
+
+#endif // BOOST_ALGORITHM_TRANSFORM_EXCLUSIVE_SCAN_HPP

include/boost/algorithm/cxx17/transform_inclusive_scan.hpp

@@ -0,0 +1,89 @@
+/*
+   Copyright (c) Marshall Clow 2017.
+
+   Distributed under the Boost Software License, Version 1.0. (See accompanying
+   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+/// \file  transform_reduce.hpp
+/// \brief Combine the (transformed) elements of a sequence (or two) into a single value.
+/// \author Marshall Clow
+
+#ifndef BOOST_ALGORITHM_TRANSFORM_REDUCE_HPP
+#define BOOST_ALGORITHM_TRANSFORM_REDUCE_HPP
+
+#include <functional>     // for std::plus
+#include <iterator>       // for std::iterator_traits
+
+#include <boost/config.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/value_type.hpp>
+
+namespace boost { namespace algorithm {
+
+/// \fn transform_inclusive_scan ( InputIterator first, InputIterator last, OutputIterator result, BinaryOperation bOp, UnaryOperation uOp, T init )
+/// \brief Transforms elements from the input range with uOp and then combines
+/// those transformed elements with bOp such that the n-1th element and the nth
+/// element are combined. Inclusivity means that the nth element is included in
+/// the nth combination.
+/// \return The updated output iterator
+///
+/// \param first  The start of the input sequence
+/// \param last   The end of the input sequence
+/// \param result The output iterator to write the results into
+/// \param bOp    The operation for combining transformed input elements
+/// \param uOp    The operation for transforming input elements
+/// \param init   The initial value
+///
+/// \note This function is part of the C++17 standard library
+template<class InputIterator, class OutputIterator,
+         class BinaryOperation, class UnaryOperation, class T>
+OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
+                                        OutputIterator result,
+                                        BinaryOperation bOp, UnaryOperation uOp,
+                                        T init)
+{
+    for (; first != last; ++first, (void) ++result) {
+        init = bOp(init, uOp(*first));
+        *result = init;
+        }
+
+    return result;
+}
+
+/// \fn transform_inclusive_scan ( InputIterator first, InputIterator last, OutputIterator result, BinaryOperation bOp, UnaryOperation uOp, T init )
+/// \brief Transforms elements from the input range with uOp and then combines
+/// those transformed elements with bOp such that the n-1th element and the nth
+/// element are combined. Inclusivity means that the nth element is included in
+/// the nth combination. The first value will be used as the init.
+/// \return The updated output iterator
+///
+/// \param first  The start of the input sequence
+/// \param last   The end of the input sequence
+/// \param result The output iterator to write the results into
+/// \param bOp    The operation for combining transformed input elements
+/// \param uOp    The operation for transforming input elements
+///
+/// \note This function is part of the C++17 standard library
+template<class InputIterator, class OutputIterator,
+         class BinaryOperation, class UnaryOperation>
+OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
+                                        OutputIterator result,
+                                        BinaryOperation bOp, UnaryOperation uOp)
+{
+    if (first != last) {
+        typename std::iterator_traits<InputIterator>::value_type init = uOp(*first);
+        *result++ = init;
+        if (++first != last)
+            return boost::algorithm::transform_inclusive_scan
+                                              (first, last, result, bOp, uOp, init);
+        }
+
+    return result;
+}
+
+
+}} // namespace boost and algorithm
+
+#endif // BOOST_ALGORITHM_TRANSFORM_REDUCE_HPP

include/boost/algorithm/cxx17/transform_reduce.hpp

@@ -0,0 +1,56 @@
+/*
+   Copyright (c) Marshall Clow 2017.
+
+   Distributed under the Boost Software License, Version 1.0. (See accompanying
+   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+/// \file  transform_reduce.hpp
+/// \brief Combine the (transformed) elements of a sequence (or two) into a single value.
+/// \author Marshall Clow
+
+#ifndef BOOST_ALGORITHM_TRANSFORM_REDUCE_HPP
+#define BOOST_ALGORITHM_TRANSFORM_REDUCE_HPP
+
+#include <functional>     // for std::plus
+#include <iterator>       // for std::iterator_traits
+
+#include <boost/config.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/value_type.hpp>
+
+namespace boost { namespace algorithm {
+
+template<class InputIterator1, class InputIterator2, class T,
+         class BinaryOperation1, class BinaryOperation2>
+T transform_reduce(InputIterator1 first1, InputIterator1 last1,
+                   InputIterator2 first2, T init,
+                 BinaryOperation1 bOp1, BinaryOperation2 bOp2)
+{
+    for (; first1 != last1; ++first1, (void) ++first2)
+        init = bOp1(init, bOp2(*first1, *first2));
+    return init;
+}
+
+template<class InputIterator, class T,
+         class BinaryOperation, class UnaryOperation>
+T transform_reduce(InputIterator first, InputIterator last,
+                   T init, BinaryOperation bOp, UnaryOperation uOp)
+{
+    for (; first != last; ++first)
+        init = bOp(init, uOp(*first));
+    return init;
+}
+
+template<class InputIterator1, class InputIterator2, class T>
+T transform_reduce(InputIterator1 first1, InputIterator1 last1,
+                   InputIterator2 first2, T init)
+{
+    return boost::algorithm::transform_reduce(first1, last1, first2, init,
+                            std::plus<T>(), std::multiplies<T>());
+}
+
+}} // namespace boost and algorithm
+
+#endif // BOOST_ALGORITHM_TRANSFORM_REDUCE_HPP