King_DuckZ/Sprout
1
0
Fork 0
mirror of https://github.com/bolero-MURAKAMI/Sprout synced 2025-08-03 12:49:50 +00:00
Code Issues Releases Wiki Activity

fix coding-style

Browse source
This commit is contained in:
bolero-MURAKAMI 2012-10-06 13:53:07 +09:00
parent df3023db30
commit 5ce2cb023c
196 changed files with 1180 additions and 1787 deletions
Download patch file Download diff file Expand all files Collapse all files

3
sprout/range/algorithm/all_of.hpp
View file

@ -11,7 +11,8 @@ namespace sprout {
// 25.2.1 All of
template<typename Range, typename Predicate>
inline SPROUT_CONSTEXPR bool all_of(Range const& range, Predicate pred) {
inline SPROUT_CONSTEXPR bool
all_of(Range const& range, Predicate pred) {
return sprout::all_of(sprout::begin(range), sprout::end(range), pred);
}
} // namespace range

3
sprout/range/algorithm/any_of.hpp
View file

@ -11,7 +11,8 @@ namespace sprout {
// 25.2.2 Any of
template<typename Range, typename Predicate>
inline SPROUT_CONSTEXPR bool any_of(Range const& range, Predicate pred) {
inline SPROUT_CONSTEXPR bool
any_of(Range const& range, Predicate pred) {
return sprout::any_of(sprout::begin(range), sprout::end(range), pred);
}
} // namespace range

6
sprout/range/algorithm/binary_search.hpp
View file

@ -11,12 +11,14 @@ namespace sprout {
// 25.4.3.4 binary_search
template<typename Range, typename T>
inline SPROUT_CONSTEXPR bool binary_search(Range const& range, T const& value) {
inline SPROUT_CONSTEXPR bool
binary_search(Range const& range, T const& value) {
return sprout::binary_search(sprout::begin(range), sprout::end(range), value);
}
template<typename Range, typename T, typename Compare>
inline SPROUT_CONSTEXPR bool binary_search(Range const& range, T const& value, Compare comp) {
inline SPROUT_CONSTEXPR bool
binary_search(Range const& range, T const& value, Compare comp) {
return sprout::binary_search(sprout::begin(range), sprout::end(range), value, comp);
}
} // namespace range

6
sprout/range/algorithm/equal.hpp
View file

@ -11,12 +11,14 @@ namespace sprout {
// 25.2.11 Equal
template<typename Range1, typename Range2>
inline SPROUT_CONSTEXPR bool equal(Range1 const& range1, Range2 const& range2) {
inline SPROUT_CONSTEXPR bool
equal(Range1 const& range1, Range2 const& range2) {
return sprout::equal(sprout::begin(range1), sprout::end(range1), sprout::begin(range2));
}
template<typename Range1, typename Range2, typename BinaryPredicate>
inline SPROUT_CONSTEXPR bool equal(Range1 const& range1, Range2 const& range2, BinaryPredicate pred) {
inline SPROUT_CONSTEXPR bool
equal(Range1 const& range1, Range2 const& range2, BinaryPredicate pred) {
return sprout::equal(sprout::begin(range1), sprout::end(range1), sprout::begin(range2), pred);
}
} // namespace range

7
sprout/range/algorithm/fit/copy.hpp
View file

@ -14,11 +14,8 @@ namespace sprout {
// copy
//
template<typename Input, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type copy(
Input const& input,
Result const& result
)
{
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
copy(Input const& input, Result const& result) {
return sprout::fit::copy(sprout::begin(input), sprout::end(input), result);
}
} // namespace fit

7
sprout/range/algorithm/fit/copy_backward.hpp
View file

@ -14,11 +14,8 @@ namespace sprout {
// copy_backward
//
template<typename Input, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type copy_backward(
Input const& input,
Result const& result
)
{
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
copy_backward(Input const& input, Result const& result) {
return sprout::fit::copy_backward(sprout::begin(input), sprout::end(input), result);
}
} // namespace fit

11
sprout/range/algorithm/fit/copy_if.hpp
View file

@ -13,13 +13,10 @@ namespace sprout {
//
// copy_if
//
template<typename Input, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type copy_if(
Input const& input,
Result const& result
)
{
return sprout::fit::copy_if(sprout::begin(input), sprout::end(input), result);
template<typename Input, typename Result, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
copy_if(Input const& input, Result const& result, Predicate pred) {
return sprout::fit::copy_if(sprout::begin(input), sprout::end(input), result, pred);
}
} // namespace fit
} // namespace range

21
sprout/range/algorithm/fit/merge.hpp
View file

@ -14,26 +14,13 @@ namespace sprout {
// merge
//
template<typename Input1, typename Input2, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type merge(
Input1 const& input1,
Input2 const& input2,
Result const& result,
Compare comp
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
merge(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
return sprout::fit::merge(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
}
//
// merge
//
template<typename Input1, typename Input2, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type merge(
Input1 const& input1,
Input2 const& input2,
Result const& result
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
merge(Input1 const& input1, Input2 const& input2, Result const& result) {
return sprout::fit::merge(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
}
} // namespace fit

8
sprout/range/algorithm/fit/partition_copy.hpp
View file

@ -14,12 +14,8 @@ namespace sprout {
// partition_copy
//
template<typename Input, typename Result, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type partition_copy(
Input const& input,
Result const& result,
Predicate pred
)
{
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
partition_copy(Input const& input, Result const& result, Predicate pred) {
return sprout::fit::partition_copy(sprout::begin(input), sprout::end(input), result, pred);
}
} // namespace fit

8
sprout/range/algorithm/fit/remove_copy.hpp
View file

@ -14,12 +14,8 @@ namespace sprout {
// remove_copy
//
template<typename Input, typename Result, typename T>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type remove_copy(
Input const& input,
Result const& result,
T const& value
)
{
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
remove_copy(Input const& input, Result const& result, T const& value) {
return sprout::fit::remove_copy(sprout::begin(input), sprout::end(input), result, value);
}
} // namespace fit

8
sprout/range/algorithm/fit/remove_copy_if.hpp
View file

@ -14,12 +14,8 @@ namespace sprout {
// remove_copy_if
//
template<typename Input, typename Result, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type remove_copy_if(
Input const& input,
Result const& result,
Predicate pred
)
{
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
remove_copy_if(Input const& input, Result const& result, Predicate pred) {
return sprout::fit::remove_copy_if(sprout::begin(input), sprout::end(input), result, pred);
}
} // namespace fit

9
sprout/range/algorithm/fit/replace_copy.hpp
View file

@ -14,13 +14,8 @@ namespace sprout {
// replace_copy
//
template<typename Input, typename Result, typename T>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type replace_copy(
Input const& input,
Result const& result,
T const& old_value,
T const& new_value
)
{
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
replace_copy(Input const& input, Result const& result, T const& old_value, T const& new_value) {
return sprout::fit::replace_copy(sprout::begin(input), sprout::end(input), result, old_value, new_value);
}
} // namespace fit

9
sprout/range/algorithm/fit/replace_copy_if.hpp
View file

@ -14,13 +14,8 @@ namespace sprout {
// replace_copy_if
//
template<typename Input, typename Result, typename T, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type replace_copy_if(
Input const& input,
Result const& result,
Predicate pred,
T const& new_value
)
{
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
replace_copy_if(Input const& input, Result const& result, Predicate pred, T const& new_value) {
return sprout::fit::replace_copy_if(sprout::begin(input), sprout::end(input), result, pred, new_value);
}
} // namespace fit

7
sprout/range/algorithm/fit/reverse_copy.hpp
View file

@ -14,11 +14,8 @@ namespace sprout {
// reverse_copy
//
template<typename Input, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type reverse_copy(
Input const& input,
Result const& result
)
{
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
reverse_copy(Input const& input, Result const& result) {
return sprout::fit::reverse_copy(sprout::begin(input), sprout::end(input), result);
}
} // namespace fit

6
sprout/range/algorithm/fit/rotate_copy.hpp
View file

@ -14,9 +14,9 @@ namespace sprout {
// rotate_copy
//
template<typename Input, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type rotate_copy(
Input const& input,
typename sprout::container_traits<Input>::const_iterator middle,
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
rotate_copy(
Input const& input, typename sprout::container_traits<Input>::const_iterator middle,
Result const& result
)
{

21
sprout/range/algorithm/fit/set_difference.hpp
View file

@ -14,26 +14,13 @@ namespace sprout {
// set_difference
//
template<typename Input1, typename Input2, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type set_difference(
Input1 const& input1,
Input2 const& input2,
Result const& result,
Compare comp
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_difference(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
return sprout::fit::set_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
}
//
// set_difference
//
template<typename Input1, typename Input2, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type set_difference(
Input1 const& input1,
Input2 const& input2,
Result const& result
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_difference(Input1 const& input1, Input2 const& input2, Result const& result) {
return sprout::fit::set_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
}
} // namespace fit

21
sprout/range/algorithm/fit/set_intersection.hpp
View file

@ -14,26 +14,13 @@ namespace sprout {
// set_intersection
//
template<typename Input1, typename Input2, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type set_intersection(
Input1 const& input1,
Input2 const& input2,
Result const& result,
Compare comp
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_intersection(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
return sprout::fit::set_intersection(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
}
//
// set_intersection
//
template<typename Input1, typename Input2, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type set_intersection(
Input1 const& input1,
Input2 const& input2,
Result const& result
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_intersection(Input1 const& input1, Input2 const& input2, Result const& result) {
return sprout::fit::set_intersection(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
}
} // namespace fit

21
sprout/range/algorithm/fit/set_symmetric_difference.hpp
View file

@ -14,26 +14,13 @@ namespace sprout {
// set_symmetric_difference
//
template<typename Input1, typename Input2, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type set_symmetric_difference(
Input1 const& input1,
Input2 const& input2,
Result const& result,
Compare comp
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_symmetric_difference(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
return sprout::fit::set_symmetric_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
}
//
// set_symmetric_difference
//
template<typename Input1, typename Input2, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type set_symmetric_difference(
Input1 const& input1,
Input2 const& input2,
Result const& result
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_symmetric_difference(Input1 const& input1, Input2 const& input2, Result const& result) {
return sprout::fit::set_symmetric_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
}
} // namespace fit

21
sprout/range/algorithm/fit/set_union.hpp
View file

@ -14,26 +14,13 @@ namespace sprout {
// set_union
//
template<typename Input1, typename Input2, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type set_union(
Input1 const& input1,
Input2 const& input2,
Result const& result,
Compare comp
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_union(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
return sprout::fit::set_union(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
}
//
// set_union
//
template<typename Input1, typename Input2, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type set_union(
Input1 const& input1,
Input2 const& input2,
Result const& result
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_union(Input1 const& input1, Input2 const& input2, Result const& result) {
return sprout::fit::set_union(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
}
} // namespace fit

8
sprout/range/algorithm/fit/stable_partition_copy.hpp
View file

@ -14,12 +14,8 @@ namespace sprout {
// stable_partition_copy
//
template<typename Input, typename Result, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type stable_partition_copy(
Input const& input,
Result const& result,
Predicate pred
)
{
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
stable_partition_copy(Input const& input, Result const& result, Predicate pred) {
return sprout::fit::stable_partition_copy(sprout::begin(input), sprout::end(input), result, pred);
}
} // namespace fit

6
sprout/range/algorithm/fit/swap_element_copy.hpp
View file

@ -14,9 +14,9 @@ namespace sprout {
// swap_element_copy
//
template<typename Input, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type swap_element_copy(
Input const& input,
Result const& result,
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
swap_element_copy(
Input const& input, Result const& result,
typename sprout::container_traits<Input>::const_iterator pos1,
typename sprout::container_traits<Input>::const_iterator pos2
)

21
sprout/range/algorithm/fit/transform.hpp
View file

@ -14,26 +14,13 @@ namespace sprout {
// transform
//
template<typename Input, typename Result, typename UnaryOperation>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type transform(
Input const& input,
Result const& result,
UnaryOperation op
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
transform(Input const& input, Result const& result, UnaryOperation op) {
return sprout::fit::transform(sprout::begin(input), sprout::end(input), result, op);
}
//
// transform
//
template<typename Input1, typename Input2, typename Result, typename BinaryOperation>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type transform(
Input1 const& input1,
Input2 const& input2,
Result const& result,
BinaryOperation op
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
transform(Input1 const& input1, Input2 const& input2, Result const& result, BinaryOperation op) {
return sprout::fit::transform(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), result, op);
}
} // namespace fit

19
sprout/range/algorithm/fit/unique_copy.hpp
View file

@ -14,24 +14,13 @@ namespace sprout {
// unique_copy
//
template<typename Input, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type unique_copy(
Input const& input,
Result const& result
)
{
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
unique_copy(Input const& input, Result const& result) {
return sprout::fit::unique_copy(sprout::begin(input), sprout::end(input), result);
}
//
// unique_copy
//
template<typename Input, typename Result, typename BinaryPredicate>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type unique_copy(
Input const& input,
Result const& result,
BinaryPredicate pred
)
{
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
unique_copy(Input const& input, Result const& result, BinaryPredicate pred) {
return sprout::fit::unique_copy(sprout::begin(input), sprout::end(input), result, pred);
}
} // namespace fit

7
sprout/range/algorithm/fixed/copy.hpp
View file

@ -14,11 +14,8 @@ namespace sprout {
// copy
//
template<typename Input, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type copy(
Input const& input,
Result const& result
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
copy(Input const& input, Result const& result) {
return sprout::fixed::copy(sprout::begin(input), sprout::end(input), result);
}
} // namespace fixed

7
sprout/range/algorithm/fixed/copy_backward.hpp
View file

@ -14,11 +14,8 @@ namespace sprout {
// copy_backward
//
template<typename Input, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type copy_backward(
Input const& input,
Result const& result
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
copy_backward(Input const& input, Result const& result) {
return sprout::fixed::copy_backward(sprout::begin(input), sprout::end(input), result);
}
} // namespace fixed

9
sprout/range/algorithm/fixed/copy_if.hpp
View file

@ -13,12 +13,9 @@ namespace sprout {
//
// copy_if
//
template<typename Input, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type copy_if(
Input const& input,
Result const& result
)
{
template<typename Input, typename Result, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
copy_if(Input const& input, Result const& result, Predicate pred) {
return sprout::fixed::copy_if(sprout::begin(input), sprout::end(input), result);
}
} // namespace fixed

21
sprout/range/algorithm/fixed/merge.hpp
View file

@ -14,26 +14,13 @@ namespace sprout {
// merge
//
template<typename Input1, typename Input2, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type merge(
Input1 const& input1,
Input2 const& input2,
Result const& result,
Compare comp
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
merge(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
return sprout::fixed::merge(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
}
//
// merge
//
template<typename Input1, typename Input2, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type merge(
Input1 const& input1,
Input2 const& input2,
Result const& result
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
merge(Input1 const& input1, Input2 const& input2, Result const& result) {
return sprout::fixed::merge(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
}
} // namespace fixed

8
sprout/range/algorithm/fixed/partition_copy.hpp
View file

@ -14,12 +14,8 @@ namespace sprout {
// partition_copy
//
template<typename Input, typename Result, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type partition_copy(
Input const& input,
Result const& result,
Predicate pred
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
partition_copy(Input const& input, Result const& result, Predicate pred) {
return sprout::fixed::partition_copy(sprout::begin(input), sprout::end(input), result, pred);
}
} // namespace fixed

8
sprout/range/algorithm/fixed/remove_copy.hpp
View file

@ -14,12 +14,8 @@ namespace sprout {
// remove_copy
//
template<typename Input, typename Result, typename T>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type remove_copy(
Input const& input,
Result const& result,
T const& value
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
remove_copy(Input const& input, Result const& result, T const& value) {
return sprout::fixed::remove_copy(sprout::begin(input), sprout::end(input), result, value);
}
} // namespace fixed

8
sprout/range/algorithm/fixed/remove_copy_if.hpp
View file

@ -14,12 +14,8 @@ namespace sprout {
// remove_copy_if
//
template<typename Input, typename Result, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type remove_copy_if(
Input const& input,
Result const& result,
Predicate pred
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
remove_copy_if(Input const& input, Result const& result, Predicate pred) {
return sprout::fixed::remove_copy_if(sprout::begin(input), sprout::end(input), result, pred);
}
} // namespace fixed

9
sprout/range/algorithm/fixed/replace_copy.hpp
View file

@ -14,13 +14,8 @@ namespace sprout {
// replace_copy
//
template<typename Input, typename Result, typename T>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type replace_copy(
Input const& input,
Result const& result,
T const& old_value,
T const& new_value
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
replace_copy(Input const& input, Result const& result, T const& old_value, T const& new_value) {
return sprout::fixed::replace_copy(sprout::begin(input), sprout::end(input), result, old_value, new_value);
}
} // namespace fixed

9
sprout/range/algorithm/fixed/replace_copy_if.hpp
View file

@ -14,13 +14,8 @@ namespace sprout {
// replace_copy_if
//
template<typename Input, typename Result, typename T, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type replace_copy_if(
Input const& input,
Result const& result,
Predicate pred,
T const& new_value
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
replace_copy_if(Input const& input, Result const& result, Predicate pred, T const& new_value) {
return sprout::fixed::replace_copy_if(sprout::begin(input), sprout::end(input), result, pred, new_value);
}
} // namespace fixed

7
sprout/range/algorithm/fixed/reverse_copy.hpp
View file

@ -14,11 +14,8 @@ namespace sprout {
// reverse_copy
//
template<typename Input, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type reverse_copy(
Input const& input,
Result const& result
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
reverse_copy(Input const& input, Result const& result) {
return sprout::fixed::reverse_copy(sprout::begin(input), sprout::end(input), result);
}
} // namespace fixed

6
sprout/range/algorithm/fixed/rotate_copy.hpp
View file

@ -14,9 +14,9 @@ namespace sprout {
// rotate_copy
//
template<typename Input, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type rotate_copy(
Input const& input,
typename sprout::container_traits<Input>::const_iterator middle,
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
rotate_copy(
Input const& input, typename sprout::container_traits<Input>::const_iterator middle,
Result const& result
)
{

21
sprout/range/algorithm/fixed/set_difference.hpp
View file

@ -14,26 +14,13 @@ namespace sprout {
// set_difference
//
template<typename Input1, typename Input2, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type set_difference(
Input1 const& input1,
Input2 const& input2,
Result const& result,
Compare comp
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_difference(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
return sprout::fixed::set_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
}
//
// set_difference
//
template<typename Input1, typename Input2, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type set_difference(
Input1 const& input1,
Input2 const& input2,
Result const& result
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_difference(Input1 const& input1, Input2 const& input2, Result const& result) {
return sprout::fixed::set_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
}
} // namespace fixed

21
sprout/range/algorithm/fixed/set_intersection.hpp
View file

@ -14,26 +14,13 @@ namespace sprout {
// set_intersection
//
template<typename Input1, typename Input2, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type set_intersection(
Input1 const& input1,
Input2 const& input2,
Result const& result,
Compare comp
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_intersection(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
return sprout::fixed::set_intersection(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
}
//
// set_intersection
//
template<typename Input1, typename Input2, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type set_intersection(
Input1 const& input1,
Input2 const& input2,
Result const& result
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_intersection(Input1 const& input1, Input2 const& input2, Result const& result) {
return sprout::fixed::set_intersection(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
}
} // namespace fixed

21
sprout/range/algorithm/fixed/set_symmetric_difference.hpp
View file

@ -14,26 +14,13 @@ namespace sprout {
// set_symmetric_difference
//
template<typename Input1, typename Input2, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type set_symmetric_difference(
Input1 const& input1,
Input2 const& input2,
Result const& result,
Compare comp
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_symmetric_difference(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
return sprout::fixed::set_symmetric_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
}
//
// set_symmetric_difference
//
template<typename Input1, typename Input2, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type set_symmetric_difference(
Input1 const& input1,
Input2 const& input2,
Result const& result
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_symmetric_difference(Input1 const& input1, Input2 const& input2, Result const& result) {
return sprout::fixed::set_symmetric_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
}
} // namespace fixed

21
sprout/range/algorithm/fixed/set_union.hpp
View file

@ -14,26 +14,13 @@ namespace sprout {
// set_union
//
template<typename Input1, typename Input2, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type set_union(
Input1 const& input1,
Input2 const& input2,
Result const& result,
Compare comp
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_union(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
return sprout::fixed::set_union(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
}
//
// set_union
//
template<typename Input1, typename Input2, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type set_union(
Input1 const& input1,
Input2 const& input2,
Result const& result
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_union(Input1 const& input1, Input2 const& input2, Result const& result) {
return sprout::fixed::set_union(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
}
} // namespace fixed

8
sprout/range/algorithm/fixed/stable_partition_copy.hpp
View file

@ -14,12 +14,8 @@ namespace sprout {
// stable_partition_copy
//
template<typename Input, typename Result, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type stable_partition_copy(
Input const& input,
Result const& result,
Predicate pred
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
stable_partition_copy(Input const& input, Result const& result, Predicate pred) {
return sprout::fixed::stable_partition_copy(sprout::begin(input), sprout::end(input), result, pred);
}
} // namespace fixed

6
sprout/range/algorithm/fixed/swap_element_copy.hpp
View file

@ -14,9 +14,9 @@ namespace sprout {
// swap_element_copy
//
template<typename Input, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type swap_element_copy(
Input const& input,
Result const& result,
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
swap_element_copy(
Input const& input, Result const& result,
typename sprout::container_traits<Input>::const_iterator pos1,
typename sprout::container_traits<Input>::const_iterator pos2
)

21
sprout/range/algorithm/fixed/transform.hpp
View file

@ -14,26 +14,13 @@ namespace sprout {
// transform
//
template<typename Input, typename Result, typename UnaryOperation>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type transform(
Input const& input,
Result const& result,
UnaryOperation op
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
transform(Input const& input, Result const& result, UnaryOperation op) {
return sprout::fixed::transform(sprout::begin(input), sprout::end(input), result, op);
}
//
// transform
//
template<typename Input1, typename Input2, typename Result, typename BinaryOperation>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type transform(
Input1 const& input1,
Input2 const& input2,
Result const& result,
BinaryOperation op
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
transform(Input1 const& input1, Input2 const& input2, Result const& result, BinaryOperation op) {
return sprout::fixed::transform(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), result, op);
}
} // namespace fixed

25
sprout/range/algorithm/fixed/unique_copy.hpp
View file

@ -10,30 +10,19 @@
namespace sprout {
namespace range {
namespace fixed {
//
// unique_copy
//
template<typename Input, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type unique_copy(
Input const& input,
Result const& result
)
{
return sprout::fixed::unique_copy(sprout::begin(input), sprout::end(input), result);
}
//
// unique_copy
//
template<typename Input, typename Result, typename BinaryPredicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type unique_copy(
Input const& input,
Result const& result,
BinaryPredicate pred
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
unique_copy(Input const& input, Result const& result, BinaryPredicate pred) {
return sprout::fixed::unique_copy(sprout::begin(input), sprout::end(input), result, pred);
}
template<typename Input, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
unique_copy(Input const& input, Result const& result) {
return sprout::fixed::unique_copy(sprout::begin(input), sprout::end(input), result);
}
} // namespace fixed
using sprout::range::fixed::unique_copy;

6
sprout/range/algorithm/includes.hpp
View file

@ -11,12 +11,14 @@ namespace sprout {
// 25.4.5.1 includes
template<typename Range1, typename Range2>
inline SPROUT_CONSTEXPR bool includes(Range1 const& range1, Range2 const& range2) {
inline SPROUT_CONSTEXPR bool
includes(Range1 const& range1, Range2 const& range2) {
return sprout::includes(sprout::begin(range1), sprout::end(range1), sprout::begin(range2), sprout::end(range2));
}
template<typename Range1, typename Range2, typename Compare>
inline SPROUT_CONSTEXPR bool includes(Range1 const& range1, Range2 const& range2, Compare comp) {
inline SPROUT_CONSTEXPR bool
includes(Range1 const& range1, Range2 const& range2, Compare comp) {
return sprout::includes(sprout::begin(range1), sprout::end(range1), sprout::begin(range2), sprout::end(range2), comp);
}
} // namespace range

6
sprout/range/algorithm/is_heap.hpp
View file

@ -11,12 +11,14 @@ namespace sprout {
// 25.4.6.5 is_heap
template<typename Range>
inline SPROUT_CONSTEXPR bool is_heap(Range const& range) {
inline SPROUT_CONSTEXPR bool
is_heap(Range const& range) {
return sprout::is_heap(sprout::begin(range), sprout::end(range));
}
template<typename Range, typename Compare>
inline SPROUT_CONSTEXPR bool is_heap(Range const& range, Compare comp) {
inline SPROUT_CONSTEXPR bool
is_heap(Range const& range, Compare comp) {
return sprout::is_heap(sprout::begin(range), sprout::end(range), comp);
}
} // namespace range

3
sprout/range/algorithm/is_partitioned.hpp
View file

@ -11,7 +11,8 @@ namespace sprout {
// 25.3.13 partitions
template<typename Range, typename Predicate>
inline SPROUT_CONSTEXPR bool is_partitioned(Range const& range, Predicate pred) {
inline SPROUT_CONSTEXPR bool
is_partitioned(Range const& range, Predicate pred) {
return sprout::is_partitioned(sprout::begin(range), sprout::end(range), pred);
}
} // namespace range

6
sprout/range/algorithm/is_permutation.hpp
View file

@ -11,12 +11,14 @@ namespace sprout {
// 25.2.12 Is permutation
template<typename Range1, typename Range2>
inline SPROUT_CONSTEXPR bool is_permutation(Range1 const& range1, Range2 const& range2) {
inline SPROUT_CONSTEXPR bool
is_permutation(Range1 const& range1, Range2 const& range2) {
return sprout::is_permutation(sprout::begin(range1), sprout::end(range1), sprout::begin(range2));
}
template<typename Range1, typename Range2, typename BinaryPredicate>
inline SPROUT_CONSTEXPR bool is_permutation(Range1 const& range1, Range2 const& range2, BinaryPredicate pred) {
inline SPROUT_CONSTEXPR bool
is_permutation(Range1 const& range1, Range2 const& range2, BinaryPredicate pred) {
return sprout::is_permutation(sprout::begin(range1), sprout::end(range1), sprout::begin(range2), pred);
}
} // namespace range

6
sprout/range/algorithm/is_sorted.hpp
View file

@ -11,12 +11,14 @@ namespace sprout {
// 25.4.1.5 is_sorted
template<typename Range>
inline SPROUT_CONSTEXPR bool is_sorted(Range const& range) {
inline SPROUT_CONSTEXPR bool
is_sorted(Range const& range) {
return sprout::is_sorted(sprout::begin(range), sprout::end(range));
}
template<typename Range, typename Compare>
inline SPROUT_CONSTEXPR bool is_sorted(Range const& range, Compare comp) {
inline SPROUT_CONSTEXPR bool
is_sorted(Range const& range, Compare comp) {
return sprout::is_sorted(sprout::begin(range), sprout::end(range), comp);
}
} // namespace range

14
sprout/range/algorithm/lexicographical_compare.hpp
View file

@ -11,13 +11,19 @@ namespace sprout {
// 25.4.8 Lexicographical comparison
template<typename Range1, typename Range2>
inline SPROUT_CONSTEXPR bool lexicographical_compare(Range1 const& range1, Range2 const& range2) {
return sprout::lexicographical_compare(sprout::begin(range1), sprout::end(range1), sprout::begin(range2), sprout::end(range2));
inline SPROUT_CONSTEXPR bool
lexicographical_compare(Range1 const& range1, Range2 const& range2) {
return sprout::lexicographical_compare(
sprout::begin(range1), sprout::end(range1), sprout::begin(range2), sprout::end(range2)
);
}
template<typename Range1, typename Range2, typename Compare>
inline SPROUT_CONSTEXPR bool lexicographical_compare(Range1 const& range1, Range2 const& range2, Compare comp) {
return sprout::lexicographical_compare(sprout::begin(range1), sprout::end(range1), sprout::begin(range2), sprout::end(range2), comp);
inline SPROUT_CONSTEXPR bool
lexicographical_compare(Range1 const& range1, Range2 const& range2, Compare comp) {
return sprout::lexicographical_compare(
sprout::begin(range1), sprout::end(range1), sprout::begin(range2), sprout::end(range2), comp
);
}
} // namespace range
} // namespace sprout

3
sprout/range/algorithm/none_of.hpp
View file

@ -11,7 +11,8 @@ namespace sprout {
// 25.2.3 None of
template<typename Range, typename Predicate>
inline SPROUT_CONSTEXPR bool none_of(Range const& range, Predicate pred) {
inline SPROUT_CONSTEXPR bool
none_of(Range const& range, Predicate pred) {
return sprout::none_of(sprout::begin(range), sprout::end(range), pred);
}
} // namespace range

22
sprout/range/numeric/accumulate.hpp
View file

@ -5,16 +5,20 @@
#include <sprout/numeric/accumulate.hpp>
namespace sprout {
// 26.7.2 Accumulate
template<typename Range, typename T, typename BinaryOperation>
inline SPROUT_CONSTEXPR T accumulate(Range const& range, T init, BinaryOperation binary_op) {
return sprout::accumulate(sprout::begin(range), sprout::end(range), init, binary_op);
}
namespace range {
// 26.7.2 Accumulate
template<typename Range, typename T, typename BinaryOperation>
inline SPROUT_CONSTEXPR T
accumulate(Range const& range, T init, BinaryOperation binary_op) {
return sprout::accumulate(sprout::begin(range), sprout::end(range), init, binary_op);
}
template<typename Range, typename T>
inline SPROUT_CONSTEXPR T accumulate(Range const& range, T init) {
return sprout::accumulate(sprout::begin(range), sprout::end(range), init);
}
template<typename Range, typename T>
inline SPROUT_CONSTEXPR T
accumulate(Range const& range, T init) {
return sprout::accumulate(sprout::begin(range), sprout::end(range), init);
}
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_NUMERIC_ACCUMLATE_HPP

7
sprout/range/numeric/dft/fit/amplitude_spectrum.hpp
View file

@ -14,11 +14,8 @@ namespace sprout {
// amplitude_spectrum
//
template<typename Input, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type amplitude_spectrum(
Input const& input,
Result const& result
)
{
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
amplitude_spectrum(Input const& input, Result const& result) {
return sprout::fit::amplitude_spectrum(sprout::begin(input), sprout::end(input), result);
}
} // namespace fit

7
sprout/range/numeric/dft/fit/dft.hpp
View file

@ -14,11 +14,8 @@ namespace sprout {
// dft
//
template<typename Input, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type dft(
Input const& input,
Result const& result
)
{
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
dft(Input const& input, Result const& result) {
return sprout::fit::dft(sprout::begin(input), sprout::end(input), result);
}
} // namespace fit

7
sprout/range/numeric/dft/fit/idft.hpp
View file

@ -14,11 +14,8 @@ namespace sprout {
// idft
//
template<typename Input, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type idft(
Input const& input,
Result const& result
)
{
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
idft(Input const& input, Result const& result) {
return sprout::fit::idft(sprout::begin(input), sprout::end(input), result);
}
} // namespace fit

7
sprout/range/numeric/dft/fit/phase_spectrum.hpp
View file

@ -14,11 +14,8 @@ namespace sprout {
// phase_spectrum
//
template<typename Input, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type phase_spectrum(
Input const& input,
Result const& result
)
{
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
phase_spectrum(Input const& input, Result const& result) {
return sprout::fit::phase_spectrum(sprout::begin(input), sprout::end(input), result);
}
} // namespace fit

7
sprout/range/numeric/dft/fit/spectrum.hpp
View file

@ -14,11 +14,8 @@ namespace sprout {
// spectrum
//
template<typename Input, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type spectrum(
Input const& input,
Result const& result
)
{
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
spectrum(Input const& input, Result const& result) {
return sprout::fit::spectrum(sprout::begin(input), sprout::end(input), result);
}
} // namespace fit

6
sprout/range/numeric/dft/fixed/amplitude_spectrum.hpp
View file

@ -15,11 +15,7 @@ namespace sprout {
//
template<typename Input, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
amplitude_spectrum(
Input const& input,
Result const& result
)
{
amplitude_spectrum(Input const& input, Result const& result) {
return sprout::fixed::amplitude_spectrum(sprout::begin(input), sprout::end(input), result);
}
} // namespace fixed

6
sprout/range/numeric/dft/fixed/dft.hpp
View file

@ -15,11 +15,7 @@ namespace sprout {
//
template<typename Input, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
dft(
Input const& input,
Result const& result
)
{
dft(Input const& input, Result const& result) {
return sprout::fixed::dft(sprout::begin(input), sprout::end(input), result);
}
} // namespace fixed

6
sprout/range/numeric/dft/fixed/idft.hpp
View file

@ -15,11 +15,7 @@ namespace sprout {
//
template<typename Input, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
idft(
Input const& input,
Result const& result
)
{
idft(Input const& input, Result const& result) {
return sprout::fixed::idft(sprout::begin(input), sprout::end(input), result);
}
} // namespace fixed

6
sprout/range/numeric/dft/fixed/phase_spectrum.hpp
View file

@ -15,11 +15,7 @@ namespace sprout {
//
template<typename Input, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
phase_spectrum(
Input const& input,
Result const& result
)
{
phase_spectrum(Input const& input, Result const& result) {
return sprout::fixed::phase_spectrum(sprout::begin(input), sprout::end(input), result);
}
} // namespace fixed

6
sprout/range/numeric/dft/fixed/spectrum.hpp
View file

@ -15,11 +15,7 @@ namespace sprout {
//
template<typename Input, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
spectrum(
Input const& input,
Result const& result
)
{
spectrum(Input const& input, Result const& result) {
return sprout::fixed::spectrum(sprout::begin(input), sprout::end(input), result);
}
} // namespace fixed

18
sprout/range/numeric/fit/adjacent_difference.hpp
View file

@ -14,23 +14,13 @@ namespace sprout {
// adjacent_difference
//
template<typename Input, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type adjacent_difference(
Input const& input,
Result const& result
)
{
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
adjacent_difference(Input const& input, Result const& result) {
return sprout::fit::adjacent_difference(sprout::begin(input), sprout::end(input), result);
}
//
// adjacent_difference
//
template<typename Input, typename Result, typename BinaryOperation>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type adjacent_difference(
Input const& input,
Result const& result,
BinaryOperation binary_op
)
{
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
adjacent_difference(Input const& input, Result const& result, BinaryOperation binary_op) {
return sprout::fit::adjacent_difference(sprout::begin(input), sprout::end(input), result, binary_op);
}
} // namespace fit

18
sprout/range/numeric/fit/partial_sum.hpp
View file

@ -14,23 +14,13 @@ namespace sprout {
// partial_sum
//
template<typename Input, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type partial_sum(
Input const& input,
Result const& result
)
{
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
partial_sum(Input const& input, Result const& result) {
return sprout::fit::partial_sum(sprout::begin(input), sprout::end(input), result);
}
//
// partial_sum
//
template<typename Input, typename Result, typename BinaryOperation>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type partial_sum(
Input const& input,
Result const& result,
BinaryOperation binary_op
)
{
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
partial_sum(Input const& input, Result const& result, BinaryOperation binary_op) {
return sprout::fit::partial_sum(sprout::begin(input), sprout::end(input), result, binary_op);
}
} // namespace fit

18
sprout/range/numeric/fixed/adjacent_difference.hpp
View file

@ -14,23 +14,13 @@ namespace sprout {
// adjacent_difference
//
template<typename Input, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type adjacent_difference(
Input const& input,
Result const& result
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
adjacent_difference(Input const& input, Result const& result) {
return sprout::fixed::adjacent_difference(sprout::begin(input), sprout::end(input), result);
}
//
// adjacent_difference
//
template<typename Input, typename Result, typename BinaryOperation>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type adjacent_difference(
Input const& input,
Result const& result,
BinaryOperation binary_op
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
adjacent_difference(Input const& input, Result const& result, BinaryOperation binary_op) {
return sprout::fixed::adjacent_difference(sprout::begin(input), sprout::end(input), result, binary_op);
}
} // namespace fixed

18
sprout/range/numeric/fixed/partial_sum.hpp
View file

@ -14,23 +14,13 @@ namespace sprout {
// partial_sum
//
template<typename Input, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type partial_sum(
Input const& input,
Result const& result
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
partial_sum(Input const& input, Result const& result) {
return sprout::fixed::partial_sum(sprout::begin(input), sprout::end(input), result);
}
//
// partial_sum
//
template<typename Input, typename Result, typename BinaryOperation>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type partial_sum(
Input const& input,
Result const& result,
BinaryOperation binary_op
)
{
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
partial_sum(Input const& input, Result const& result,BinaryOperation binary_op) {
return sprout::fixed::partial_sum(sprout::begin(input), sprout::end(input), result, binary_op);
}
} // namespace fixed

38
sprout/range/numeric/inner_product.hpp
View file

@ -5,28 +5,24 @@
#include <sprout/numeric/inner_product.hpp>
namespace sprout {
// 26.7.3 Inner product
template<typename Range1, typename Range2, typename T, typename BinaryOperation1, typename BinaryOperation2>
inline SPROUT_CONSTEXPR T inner_product(
Range1 const& range1,
Range2 const& range2,
T init,
BinaryOperation1 binary_op1,
BinaryOperation2 binary_op2
)
{
return sprout::inner_product(sprout::begin(range1), sprout::end(range1), sprout::begin(range2), init, binary_op1, binary_op2);
}
namespace range {
// 26.7.3 Inner product
template<typename Range1, typename Range2, typename T, typename BinaryOperation1, typename BinaryOperation2>
inline SPROUT_CONSTEXPR T
inner_product(
Range1 const& range1, Range2 const& range2, T init,
BinaryOperation1 binary_op1, BinaryOperation2 binary_op2
)
{
return sprout::inner_product(sprout::begin(range1), sprout::end(range1), sprout::begin(range2), init, binary_op1, binary_op2);
}
template<typename Range1, typename Range2, typename T>
inline SPROUT_CONSTEXPR T inner_product(
Range1 const& range1,
Range2 const& range2,
T init
)
{
return sprout::inner_product(sprout::begin(range1), sprout::end(range1), sprout::begin(range2), init);
}
template<typename Range1, typename Range2, typename T>
inline SPROUT_CONSTEXPR T
inner_product(Range1 const& range1, Range2 const& range2, T init) {
return sprout::inner_product(sprout::begin(range1), sprout::end(range1), sprout::begin(range2), init);
}
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_NUMERIC_INNER_PRODUCT_HPP