{"id":5860,"date":"2020-03-06T06:44:12","date_gmt":"2020-03-06T06:44:12","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/c-20-more-pythonic-with-the-ranges-library\/"},"modified":"2023-09-27T16:54:16","modified_gmt":"2023-09-27T16:54:16","slug":"c-20-more-pythonic-with-the-ranges-library","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/c-20-more-pythonic-with-the-ranges-library\/","title":{"rendered":"C++20: Pythons range Function, the Second"},"content":{"rendered":"

In my last post, C++20: Pythonic with the Ranges Library<\/a>, I started my experiment to implement the beloved Python functions range<\/span> and filter<\/span> in C++. Due to two very interesting comments to my last post, I revisit the function range<\/span>.<\/p>\n

<\/p>\n

\"\"<\/p>\n

Admittedly, it took me quite a time to become comfortable with the ranges library, but the effort paid off. You will see why.<\/p>\n

I got a few fascinating remarks about my range implementation in my last post. Therefore, I have to visit it once more.<\/p>\n

range<\/span><\/h2>\n

As a short reminder, the call range(begin, end, step)<\/span> generates in Python 2 a list of all integers from begin<\/span> to end<\/span> in stepsize<\/span> steps. begin<\/span> is inclusive, and the end is exclusive. step<\/span> is per default 1.<\/p>\n

Over-Engineering<\/h3>\n

My last range<\/span> implementation of the last was over-engineered, as one of my German readers remarked. The following code snippet shows the over-engineered and the improved version.<\/p>\n

<\/p>\n

\n
std::<\/span>vector<<\/span>int<\/span>><\/span> range(int<\/span> begin, int<\/span> end, int<\/span> stepsize =<\/span> 1<\/span>) {\n    std::<\/span>vector<<\/span>int<\/span>><\/span> result{};\n    if<\/span> (begin <<\/span> end) {                                     \n        auto<\/span> boundary =<\/span> [end](int<\/span> i){ return<\/span> i <<\/span> end; };    \n        for<\/span> (int<\/span> i:<\/span> ranges::<\/span>views::<\/span>iota(begin)               \/\/ (2)<\/span>\n                  |<\/span> ranges::<\/span>views::<\/span>stride(stepsize) \n                  |<\/span> ranges::<\/span>views::<\/span>take_while(boundary)) {   \/\/ (1)<\/span>\n            result.push_back(i);\n        }\n    }\n    else<\/span> {                                                \n        begin++<\/span>;\n        end++<\/span>;\n        stepsize *=<\/span> -<\/span>1<\/span>;\n        auto<\/span> boundary =<\/span> [begin](int<\/span> i){ return<\/span> i <<\/span> begin; }; \n        for<\/span> (int<\/span> i:<\/span> ranges::<\/span>views::<\/span>iota(end)                \n                  |<\/span> ranges::<\/span>views::<\/span>take_while(boundary)      \n                  |<\/span> ranges::<\/span>views::<\/span>reverse \n                  |<\/span> ranges::<\/span>views::<\/span>stride(stepsize)) {\n            result.push_back(i);\n        }\n    }\n    return<\/span> result;\n}  \n\nstd::<\/span>vector<<\/span>int<\/span>><\/span> range(int<\/span> begin, int<\/span> end, int<\/span> stepsize =<\/span> 1<\/span>) {\n    std::<\/span>vector<<\/span>int<\/span>><\/span> result{};\n    if<\/span> (begin <<\/span> end) {\n        for<\/span> (int<\/span> i:<\/span> ranges::<\/span>views::<\/span>iota(begin, end)         \/\/ (3)<\/span>\n                 |<\/span> ranges::<\/span>views::<\/span>stride(stepsize)) {\n            result.push_back(i);\n        }\n    }\n    else<\/span> {\n        begin++<\/span>;\n        end++<\/span>;\n        stepsize *=<\/span> -<\/span>1<\/span>;\n        for<\/span> (int<\/span> i:<\/span> ranges::<\/span>views::<\/span>iota(end, begin)         \n                  |<\/span> ranges::<\/span>views::<\/span>reverse \n                  |<\/span> ranges::<\/span>views::<\/span>stride(stepsize)) {\n            result.push_back(i);\n        }\n    }\n    return<\/span> result;\n}\n<\/pre>\n<\/div>\n
I removed the boundary condition (line 1) in the first implementation and changed the infinite number generator ranges::views::iota(begin)<\/span> (line 2) to a finite number generator ranges::view::iota(begin, end)<\/span> (line 3). Consequentially, I did the same in the else<\/span> branch.<\/p>\n
From range<\/span> to xrange<\/span><\/h3>\n
The presented range<\/span> function is eager.\u00a0It generates a std::vector<int><\/span>. \u00a0Aleksei Guzev reminded me that Python 2 also has a lazy\u00a0xrange<\/span> function which corresponds to the Python 3 range<\/span> function. He is right. I’m sufficiently comfortable with the ranges library to apply functional concepts to C++. If you are puzzled by the terms eager and lazy, read my previous post, C++20: Functional Patterns with the Ranges Library<\/a>.<\/p>\n
The following example shows a lazy range variant, which I called, consequentially, xrange<\/span>.<\/p>\n
<\/p>\n
\n
\/\/ xrange.hpp<\/span>\n\n#include <range\/v3\/all.hpp><\/span>\n\ntemplate<\/span> <<\/span>long<\/span> long<\/span> Begin, long<\/span> long<\/span> End><\/span>           \/\/ (3)<\/span>\nauto<\/span> xrange(int<\/span> stepsize =<\/span> 1<\/span>) {\n    if<\/span> constexpr (Begin <<\/span> End) {                    \/\/ (2)<\/span>\n        return<\/span> ranges::<\/span>views::<\/span>iota(Begin, End)      \/\/ (1)<\/span>\n               |<\/span> ranges::<\/span>views::<\/span>stride(stepsize); \n    }\n    else<\/span> {\n        long<\/span> long<\/span> end  =<\/span> End +<\/span> 1<\/span>;                   \/\/ (4)<\/span>\n        long<\/span> long<\/span> begin =<\/span> Begin +<\/span> 1<\/span>;                \/\/ (4)<\/span>\n        stepsize *=<\/span> -<\/span>1<\/span>; \n        return<\/span> ranges::<\/span>views::<\/span>iota(end, begin)      \/\/ (1)<\/span>\n               |<\/span> ranges::<\/span>views::<\/span>reverse \n               |<\/span> ranges::<\/span>views::<\/span>stride(stepsize);\n    }\n}\n<\/pre>\n<\/div>\n
Implementing the lazy xrange<\/span> function is way more complicated than the previous eager range<\/span> function. But the added complexity pays off. The following numbers correspond to the numbers in the source code snippet.<\/p>\n
    \n
  1. The xrange<\/span> function returns not a std::vector<int><\/span> but a composition of views. I let the compiler deduce the return type with auto to ease my job. OK, but the return type caused the first challenge. The return types of the if<\/span> and else<\/span> branch diver.\u00a0A function with different return types is not valid in C++.<\/li>\n
  2. To overcome this issue, I used a C++17 feature: constexpr if.<\/span>\u00a0constexpr if<\/span><\/a> allows conditional compilation. When the expression if constexpr (Begin < End))<\/span> becomes true, the if<\/span> branch is compiled; if not, the else<\/span> branch. To be valid, Begin<\/span> and End<\/span> have to be constant expressions.<\/li>\n
  3. Begin<\/span> and End<\/span> are now non-type template parameters which makes it possible to use them in a constexpr if<\/span> (line 2) expression. I used a non-type template parameter of type long long<\/span> to deal with big numbers. You read in a few sentences why.<\/li>\n
  4. Constant expressions such as Begin<\/span> and End<\/span> can not be modified. Consequentially, I introduced the variables end<\/span> and begin<\/span> to adapt the boundaries for the ranges::views::iota<\/span> call.<\/li>\n<\/ol>\n
    Let’s try it out.<\/p>\n
    <\/p>\n
    \n
    \/\/ range.cpp<\/span>\n\n#include \"xrange.hpp\"<\/span>\n\n#include <iostream><\/span>\n#include <range\/v3\/all.hpp><\/span>\n#include <vector><\/span>\n\n        \nint<\/span> main<\/span>() {\n    \n    std::<\/span>cout <<<\/span> std::<\/span>endl;\n\n    auto<\/span> res =<\/span> xrange<<\/span>1<\/span>, 10<\/span>><\/span>();                    \/\/ (1)<\/span>\n    for<\/span> (auto<\/span> i:<\/span> res) std::<\/span>cout <<<\/span> i <<<\/span> \" \"<\/span>;\n    \n    std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\n    \n    res =<\/span> xrange<<\/span>1<\/span>, 50<\/span>><\/span>(5<\/span>);                        \/\/ (2)<\/span>\n    for<\/span> (auto<\/span> i:<\/span> res) std::<\/span>cout <<<\/span> i <<<\/span> \" \"<\/span>;\n    \n    std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\n    \n    auto<\/span> res2 =<\/span> xrange<<\/span>20<\/span>, 10<\/span>><\/span>(-<\/span>1<\/span>);                \/\/ (3)<\/span>\n    for<\/span> (auto<\/span> i:<\/span> res2) std::<\/span>cout <<<\/span> i <<<\/span> \" \"<\/span>;\n    \n    std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\n    \n    res2 =<\/span> xrange<<\/span>50<\/span>, 10<\/span>><\/span>(-<\/span>5<\/span>);                     \/\/ (4)<\/span>\n    for<\/span> (auto<\/span> i:<\/span> res2) std::<\/span>cout <<<\/span> i <<<\/span> \" \"<\/span>;\n    \n    std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\n    \n    res =<\/span> xrange<<\/span>1<\/span>, 1'<\/span>000'<\/span>000'<\/span>000'<\/span>000'<\/span>000'<\/span>000<\/span>><\/span>();  \/\/ (5)<\/span>\n    \/\/ for (auto i: res) std::cout << i << \" \";    \/\/ (6)<\/span>\n    \n    \n                                                   \/\/ (7)<\/span>\n    for<\/span> (auto<\/span> i:<\/span> res |<\/span> ranges::<\/span>views::<\/span>take(10<\/span>)) std::<\/span>cout <<<\/span> i <<<\/span> \" \"<\/span>;\n    \n    std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\n    \n                                                  \/\/ (8)<\/span>\n    for<\/span> (auto<\/span> i:<\/span> res |<\/span> ranges::<\/span>views::<\/span>drop_while([](int<\/span> i){ return<\/span> i <<\/span> 1'<\/span>000'<\/span>000<\/span>; })\n                     |<\/span> ranges::<\/span>views::<\/span>take_while([](int<\/span> i){ return<\/span> i <<\/span> 1'<\/span>000'<\/span>010<\/span>; })) {\n        std::<\/span>cout <<<\/span> i <<<\/span> \" \"<\/span>;\n    }\n    \n    std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\n    \n}\n<\/pre>\n<\/div>\n
    Lines (1) – (4) show that the xrange<\/span> function works as the previous range<\/span> function. The only difference is that the function arguments become template arguments. I have to kill the program when I want to have all numbers up to a quintillion (line 6).<\/p>\n
    \"xrangeBreak\"<\/p>\n
    Using tics for numbers (1’000’000’000’000’000’000<\/span>) (line 5) is valid since C++14 and makes the big numbers easier to read. I should not be so eager but lazy. If I ask only for ten numbers (line 7) or between 1’000’000<\/span> and 1’000’010<\/span> (line 8) the program works like a charm. Only the numbers are generated that are requested.<\/p>\n
    \"xrange\"<\/h2>\n
    What’s next?<\/h2>\n
    As I already promised in my last post C++20: Pythonic with the Ranges Library<\/a>, I present in my next post<\/a> Python’s map<\/span> function. map<\/span> empowers you to apply a function to sequences. For convenience reasons, I combine the map<\/span> and filter<\/span> functions into one function.<\/p>\n","protected":false},"excerpt":{"rendered":"
    In my last post, C++20: Pythonic with the Ranges Library, I started my experiment to implement the beloved Python functions range and filter in C++. Due to two very interesting comments to my last post, I revisit the function range.<\/p>\n","protected":false},"author":21,"featured_media":8380,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[375],"tags":[412,413],"class_list":["post-5860","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c-20","tag-python","tag-ranges"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5860","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=5860"}],"version-history":[{"count":3,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5860\/revisions"}],"predecessor-version":[{"id":8388,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5860\/revisions\/8388"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/8380"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5860"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5860"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5860"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}