Skip to content

Commit 47092c1

Browse files
jgopeljgopel
committed
Implement iterate algorithms
Problem: - There is no algorithm that generalizes `std::iota`. Filling a range 2 elements at a time is hard, more complex patterns are increasingly difficult. Solution: - Implement `iterate` and `iterate_n` which fill a range based on the execution of a binary operation which takes the previous value.
1 parent dbf91f4 commit 47092c1

File tree

4 files changed

+261
-0
lines changed

4 files changed

+261
-0
lines changed

‎doc/algorithm.qbk

+10
Original file line numberDiff line numberDiff line change
@@ -224,6 +224,16 @@ Write a sequence of n increasing values to an output iterator
224224
Raise a value to an integral power ([^constexpr] since C++14)
225225
[endsect:power]
226226

227+
[section:iterate iterate ]
228+
[*[^[link header.boost.algorithm.iterate_hpp iterate] ] ]
229+
Store the result of a unary function to each element of a range. This is a generalization of iota.
230+
[endsect:iterate]
231+
232+
[section:iterate iterate ]
233+
[*[^[link header.boost.algorithm.iterate_hpp iterate] ] ]
234+
Store the result of a unary function to n element of a range. This is a generalization of iota.
235+
[endsect:iterate]
236+
227237
[endsect:misc_inner_algorithms]
228238

229239
[endsect:Misc]

‎include/boost/algorithm/iterate.hpp

+89
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,89 @@
1+
/*
2+
Copyright (c) Jonathan Gopel 2022.
3+
4+
Distributed under the Boost Software License, Version 1.0. (See accompanying
5+
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6+
*/
7+
8+
#ifndef BOOST_ALGORITHM_ITERATE_HPP
9+
#define BOOST_ALGORITHM_ITERATE_HPP
10+
11+
#include <boost/config.hpp>
12+
#include <boost/range/begin.hpp>
13+
#include <boost/range/end.hpp>
14+
15+
#include <utility>
16+
17+
namespace boost {
18+
namespace algorithm {
19+
20+
/// \fn iterate ( ForwardIterator first, ForwardIterator last, TInit init, UnaryOperation op )
21+
/// \brief Fills a range by applying op to the previous result of op. The nth
22+
/// element of the range is calculated by applying op to init n times. IE: The
23+
/// 0th element is init, the 1st element is op(init), the 2nd element is
24+
/// op(op(init)) and so on.
25+
/// \return The final value of init
26+
///
27+
/// \param first The start of the input range
28+
/// \param last The end of the input range
29+
/// \param init The initial value of the output range
30+
/// \param op The function to apply to generate subsequent elements of the
31+
/// range. Note that the input type and output type of this
32+
/// function must be TInit.
33+
template <class ForwardIterator, class TInit, class UnaryOperation>
34+
BOOST_CXX14_CONSTEXPR TInit iterate(ForwardIterator first, ForwardIterator last,
35+
TInit init,
36+
UnaryOperation op) // TODO: BOOST_NOEXCEPT?
37+
{
38+
for (; first != last; (void)++first, init = op(init)) {
39+
*first = init;
40+
}
41+
return init;
42+
}
43+
44+
/// \fn iterate ( Range& r, TInit init, UnaryOperation op )
45+
/// \brief Fills a range by applying op to the previous result of op. The nth
46+
/// element of the range is calculated by applying op to init n times. IE: The
47+
/// 0th element is init, the 1st element is op(init), the 2nd element is
48+
/// op(op(init)) and so on.
49+
/// \return The final value of init
50+
///
51+
/// \param first The start of the input range
52+
/// \param last The end of the input range
53+
/// \param init The initial value of the output range
54+
/// \param op The function to apply to generate subsequent elements of the
55+
/// range. Note that the input type and output type of this
56+
/// function must be TInit.
57+
template <class Range, class TInit, class UnaryOperation>
58+
BOOST_CXX14_CONSTEXPR TInit iterate(Range &r, TInit init, UnaryOperation op) {
59+
return iterate(boost::begin(r), boost::end(r), init, op);
60+
}
61+
62+
/// \fn iterate ( ForwardIterator first, Size n, TInit init, UnaryOperation op )
63+
/// \brief Fills n elements of a range by applying op to the previous result
64+
/// of op. The nth element of the range is calculated by applying op to init
65+
/// n times. IE: The 0th element is init, the 1st element is op(init), the 2nd
66+
/// element is op(op(init)) and so on.
67+
/// \return The updated output iterator and the final value of init
68+
///
69+
/// \param first The start of the input range
70+
/// \param n The number of elements to fill
71+
/// \param init The initial value of the output range
72+
/// \param op The function to apply to generate subsequent elements of the
73+
/// range. Note that the input type and output type of this
74+
/// function must be TInit.
75+
template <class OutputIterator, class Size, class TInit, class UnaryOperation>
76+
BOOST_CXX14_CONSTEXPR std::pair<OutputIterator, TInit>
77+
iterate(OutputIterator first, Size n, TInit init,
78+
UnaryOperation op) // TODO: BOOST_NOEXCEPT?
79+
{
80+
for (; n > 0; --n, (void)++first, init = op(init)) {
81+
*first = init;
82+
}
83+
return std::make_pair(first, init);
84+
}
85+
86+
} // namespace algorithm
87+
} // namespace boost
88+
89+
#endif // BOOST_ALGORITHM_ITERATE_HPP

‎test/Jamfile.v2

+2
Original file line numberDiff line numberDiff line change
@@ -90,6 +90,8 @@ alias unit_test_framework
9090
# Find tests
9191
[ run find_not_test.cpp unit_test_framework : : : : find_not_test ]
9292
[ run find_backward_test.cpp unit_test_framework : : : : find_backward_test ]
93+
# Iterate tests
94+
[ run iterate_test.cpp unit_test_framework : : : : iterate_test ]
9395
;
9496
}
9597

‎test/iterate_test.cpp

+160
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,160 @@
1+
/*
2+
Copyright (c) Jonathan Gopel 2022.
3+
4+
Distributed under the Boost Software License, Version 1.0. (See accompanying
5+
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6+
*/
7+
8+
#include <boost/algorithm/iterate.hpp>
9+
10+
#include "iterator_test.hpp"
11+
12+
#include <boost/config.hpp>
13+
14+
#define BOOST_TEST_MAIN
15+
#include <boost/test/unit_test.hpp>
16+
17+
#include <boost/algorithm/cxx14/equal.hpp>
18+
19+
#include <algorithm>
20+
#include <array>
21+
#include <functional>
22+
#include <vector>
23+
24+
typedef int data_t;
25+
26+
static const int NUM_ELEMENTS = 4;
27+
28+
BOOST_CONSTEXPR data_t add_one(const data_t value) { return value + 1; }
29+
30+
BOOST_CONSTEXPR data_t add_two(const data_t value) { return value + 2; }
31+
32+
void test_iterate() {
33+
{ // iota
34+
std::vector<data_t> actual(NUM_ELEMENTS);
35+
36+
boost::algorithm::iterate(actual.begin(), actual.end(), 15, add_one);
37+
38+
std::vector<data_t> expected(NUM_ELEMENTS);
39+
expected.at(0) = 15;
40+
expected.at(1) = 16;
41+
expected.at(2) = 17;
42+
expected.at(3) = 18;
43+
BOOST_CHECK(actual.size() == expected.size());
44+
BOOST_CHECK(std::equal(actual.begin(), actual.end(), expected.begin()));
45+
}
46+
{ // striding
47+
std::vector<data_t> actual(NUM_ELEMENTS);
48+
49+
boost::algorithm::iterate(actual.begin(), actual.end(), 15, add_two);
50+
51+
std::vector<data_t> expected(NUM_ELEMENTS);
52+
expected.at(0) = 15;
53+
expected.at(1) = 17;
54+
expected.at(2) = 19;
55+
expected.at(3) = 21;
56+
BOOST_CHECK(std::equal(actual.begin(), actual.end(), expected.begin()));
57+
}
58+
}
59+
60+
void test_iterate_range() {
61+
{ // iota
62+
std::vector<data_t> actual(NUM_ELEMENTS);
63+
64+
boost::algorithm::iterate(actual, 15, add_one);
65+
66+
std::vector<data_t> expected(NUM_ELEMENTS);
67+
expected.at(0) = 15;
68+
expected.at(1) = 16;
69+
expected.at(2) = 17;
70+
expected.at(3) = 18;
71+
BOOST_CHECK(actual.size() == expected.size());
72+
BOOST_CHECK(std::equal(actual.begin(), actual.end(), expected.begin()));
73+
}
74+
{ // striding
75+
std::vector<data_t> actual(NUM_ELEMENTS);
76+
77+
boost::algorithm::iterate(actual, 15, add_two);
78+
79+
std::vector<data_t> expected(NUM_ELEMENTS);
80+
expected.at(0) = 15;
81+
expected.at(1) = 17;
82+
expected.at(2) = 19;
83+
expected.at(3) = 21;
84+
BOOST_CHECK(std::equal(actual.begin(), actual.end(), expected.begin()));
85+
}
86+
}
87+
88+
void test_iterate_n() {
89+
{ // iota
90+
std::vector<data_t> actual(NUM_ELEMENTS);
91+
92+
boost::algorithm::iterate(actual.begin(), actual.size(), 15, add_one);
93+
94+
std::vector<data_t> expected(NUM_ELEMENTS);
95+
expected.at(0) = 15;
96+
expected.at(1) = 16;
97+
expected.at(2) = 17;
98+
expected.at(3) = 18;
99+
BOOST_CHECK(actual.size() == expected.size());
100+
BOOST_CHECK(std::equal(actual.begin(), actual.end(), expected.begin()));
101+
}
102+
{ // striding
103+
std::vector<data_t> actual(NUM_ELEMENTS);
104+
105+
boost::algorithm::iterate(actual.begin(), actual.size(), 15, add_two);
106+
107+
std::vector<data_t> expected(NUM_ELEMENTS);
108+
expected.at(0) = 15;
109+
expected.at(1) = 17;
110+
expected.at(2) = 19;
111+
expected.at(3) = 21;
112+
BOOST_CHECK(actual.size() == expected.size());
113+
BOOST_CHECK(std::equal(actual.begin(), actual.end(), expected.begin()));
114+
}
115+
}
116+
117+
BOOST_CXX14_CONSTEXPR inline bool constexpr_test_iterate() {
118+
int actual[] = {0, 0, 0, 0};
119+
120+
boost::algorithm::iterate(input_iterator<int *>(actual),
121+
input_iterator<int *>(actual + NUM_ELEMENTS), 15,
122+
add_one);
123+
124+
int expected[] = {15, 16, 17, 18};
125+
return boost::algorithm::equal(
126+
input_iterator<int *>(actual),
127+
input_iterator<int *>(actual + NUM_ELEMENTS),
128+
input_iterator<int *>(expected),
129+
input_iterator<int *>(expected + NUM_ELEMENTS));
130+
}
131+
132+
BOOST_CXX14_CONSTEXPR inline bool constexpr_test_iterate_n() {
133+
int actual[] = {0, 0, 0, 0};
134+
135+
boost::algorithm::iterate(input_iterator<int *>(actual), NUM_ELEMENTS, 15,
136+
add_one);
137+
138+
int expected[] = {15, 16, 17, 18};
139+
return boost::algorithm::equal(
140+
input_iterator<int *>(actual),
141+
input_iterator<int *>(actual + NUM_ELEMENTS),
142+
input_iterator<int *>(expected),
143+
input_iterator<int *>(expected + NUM_ELEMENTS));
144+
}
145+
146+
BOOST_AUTO_TEST_CASE(test_main) {
147+
test_iterate();
148+
test_iterate_range();
149+
test_iterate_n();
150+
151+
{
152+
BOOST_CXX14_CONSTEXPR bool result = constexpr_test_iterate();
153+
BOOST_CHECK(result);
154+
}
155+
156+
{
157+
BOOST_CXX14_CONSTEXPR bool result = constexpr_test_iterate_n();
158+
BOOST_CHECK(result);
159+
}
160+
}

0 commit comments

Comments
 (0)