{"id":10907,"date":"2025-08-11T08:45:45","date_gmt":"2025-08-11T08:45:45","guid":{"rendered":"https:\/\/www.modernescpp.com\/?p=10907"},"modified":"2025-08-11T16:20:24","modified_gmt":"2025-08-11T16:20:24","slug":"data-parallel-types-algorithms","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/data-parallel-types-algorithms\/","title":{"rendered":"Data-Parallel Types: Algorithms"},"content":{"rendered":"\n

The data-parallel types library has four special algorithms for SIMD vectors.<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n

The four special algorithms are min, max, minmax<\/code>, and clamp<\/code>.<\/p>\n\n\n\n

min, max, <\/code>and minmax<\/code><\/h2>\n\n\n\n

The two algorithms min <\/code>and max <\/code>have in common that they each accept two SIMD vectors and return a SIMD vector. This contains the element-wise minimum or maximum of the input vectors. The minmax <\/code>algorithm also takes two SIMD vectors and returns a pair of SIMD vectors. The first vector in the pair contains the element-wise minimum, the second the element-wise maximum of the input vectors.<\/p>\n\n\n\n

The following example shows the three algorithms in action:<\/p>\n\n\n\n

\/\/ minmax.cpp<\/span>\n\n#include <experimental\/simd><\/span>\n#include <iomanip><\/span>\n#include <iostream><\/span>\n\nnamespace<\/span> stdx =<\/span> std::<\/span>experimental;\n \nvoid<\/span> println<\/span>(auto<\/span> rem, auto<\/span> const<\/span> v) {\n    std::<\/span>cout <<<\/span> rem <<<\/span> ": "<\/span>;\n    for<\/span> (std::<\/span>size_t<\/span> i =<\/span> 0<\/span>; i !=<\/span> v.size(); ++<\/span>i)\n        std::<\/span>cout <<<\/span> std::<\/span>setw(2<\/span>) <<<\/span> v[i] <<<\/span> ' '<\/span>;\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n}\n\nvoid<\/span> printPairs<\/span>(auto<\/span> rem, auto<\/span> const<\/span> v1) {\n    std::<\/span>cout <<<\/span> rem <<<\/span> ": "<\/span>;\n    for<\/span> (std::<\/span>size_t<\/span> i =<\/span> 0<\/span>; i !=<\/span> v1.first.size(); ++<\/span>i)\n        std::<\/span>cout <<<\/span> '('<\/span> <<<\/span> v1.first[i] <<<\/span> ", "<\/span> <<<\/span> v1.second[i] <<<\/span> ')'<\/span> <<<\/span> ' '<\/span>;\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n}\n\nint<\/span> main<\/span>() {\n\n    stdx::<\/span>fixed_size_simd<<\/span>int<\/span>, 8<\/span>><\/span> a{[](int<\/span> i) {\n        static<\/span> constexpr auto<\/span> c =<\/span> {10<\/span>, 9<\/span>, 8<\/span>, 7<\/span>, 6<\/span>, 5<\/span>, 4<\/span>, 3<\/span>};\n        return<\/span> c.begin()[i];\n    }};\n    println("a"<\/span>, a);\n    \n    stdx::<\/span>fixed_size_simd<<\/span>int<\/span>, 8<\/span>><\/span> b{[](int<\/span> i) {\n        static<\/span> constexpr auto<\/span> c =<\/span> {3<\/span>, 4<\/span>, 5<\/span>, 6<\/span>, 7<\/span>, 8<\/span>, 9<\/span>, 10<\/span>,};\n        return<\/span> c.begin()[i];\n    }};\n    println("b"<\/span>, b);\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n   auto<\/span> minimum =<\/span> stdx::<\/span>min(a, b);\n   println("minimum"<\/span>, minimum);\n\n   auto<\/span> maximum =<\/span> stdx::<\/span>max(a, b);\n   println("maximum"<\/span>, maximum);\n\n   \/*<\/span>\n   auto minmax = stdx::minmax(a, b);<\/span>\n   printPairs("minmax", minmax);<\/span>\n   *\/<\/span>\n\n}\n<\/pre><\/div>\n\n\n\n
I use the SIMD vectors a <\/code>and b <\/code>as input vectors. These are initialized specially. To do this, I create an initialization list c <\/code>in the lambda function that returns an iterator to it.
The following screenshot shows the output of the program:<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
You may be wondering why I commented out the use of the minmax algorithm. The reason is simple. I couldn’t compile the line stdx::minmax(a, b) <\/code>with either the GCC or clang compilers.<\/p>\n\n\n\n
clamp<\/code><\/h2>\n\n\n\n
std::datapar::clamp <\/code>applies the std::clamp <\/a><\/code>function to the SIMD vector element by element. Each element is clamped to a minimum and maximum limit.
The following program is based on an example from cppreference:<\/p>\n\n\n\n
\/\/ clamp.cpp<\/span>\n\n#include <cstddef><\/span>\n#include <cstdint><\/span>\n#include <experimental\/simd><\/span>\n#include <iomanip><\/span>\n#include <iostream><\/span>\n\nnamespace<\/span> stdx =<\/span> std::<\/span>experimental;\n \nvoid<\/span> println<\/span>(auto<\/span> rem, auto<\/span> const<\/span> v) {\n    std::<\/span>cout <<<\/span> rem <<<\/span> ": "<\/span>;\n    for<\/span> (std::<\/span>size_t<\/span> i =<\/span> 0<\/span>; i !=<\/span> v.size(); ++<\/span>i)\n        std::<\/span>cout <<<\/span> std::<\/span>setw(4<\/span>) <<<\/span> v[i] <<<\/span> ' '<\/span>;\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n}\n \nint<\/span> main<\/span>() {\n\n    std::<\/span>cout <<<\/span> "INT8_MIN: "<\/span> <<<\/span> INT8_MIN <<<\/span> '\\n'<\/span>;\n    std::<\/span>cout <<<\/span> "INT8_MAX: "<\/span> <<<\/span> INT8_MAX <<<\/span> '\\n'<\/span>;\n    std::<\/span>cout <<<\/span> "UINT8_MAX: "<\/span> <<<\/span> UINT8_MAX <<<\/span> '\\n'<\/span>;\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n    stdx::<\/span>fixed_size_simd<<\/span>int<\/span>, 8<\/span>><\/span> a{[](int<\/span> i) {\n        static<\/span> constexpr auto<\/span> c =<\/span> {-<\/span>129<\/span>, -<\/span>128<\/span>, -<\/span>1<\/span>, 0<\/span>, 42<\/span>, 127<\/span>, 128<\/span>, 255<\/span>};\n        return<\/span> c.begin()[i];\n    }};\n    println("a"<\/span>, a);\n \n    stdx::<\/span>fixed_size_simd<<\/span>int<\/span>, 8<\/span>><\/span> lo1{INT8_MIN};\n    stdx::<\/span>fixed_size_simd<<\/span>int<\/span>, 8<\/span>><\/span> hi1{INT8_MAX};\n    const<\/span> auto<\/span> b =<\/span> stdx::<\/span>clamp(a, lo1, hi1);\n    println("b"<\/span>, b);\n \n    stdx::<\/span>fixed_size_simd<<\/span>int<\/span>, 8<\/span>><\/span> lo2{0<\/span>};\n    stdx::<\/span>fixed_size_simd<<\/span>int<\/span>, 8<\/span>><\/span> hi2{UINT8_MAX};\n    const<\/span> auto<\/span> c =<\/span> stdx::<\/span>clamp(a, lo2, hi2);\n    println("c"<\/span>, c);\n\n}\n<\/pre><\/div>\n\n\n\n
\"\"<\/figure>\n\n\n\n
It is nice to see in the output of the SIMD vector b <\/code>how the values of the SIMD vector a <\/code>are mapped to the boundary values INT8_MIN <\/code>and INT8_MAX<\/code>. In SIMD vector c<\/code>, on the other hand, the boundary values 0 <\/code>and UINT8_MAX <\/code>are used.<\/p>\n\n\n\n
What’s Next?<\/h2>\n\n\n\n
Now it’s time for my second iteration through the new C++26 standard. I will focus primarily on the features that I did not cover in detail in my first iteration. I will start with contracts.<\/p>\n\n\n\n
<\/p>\n","protected":false},"excerpt":{"rendered":"
The data-parallel types library has four special algorithms for SIMD vectors. The four special algorithms are min, max, minmax, and clamp. min, max, and minmax The two algorithms min and max have in common that they each accept two SIMD vectors and return a SIMD vector. This contains the element-wise minimum or maximum of the […]<\/p>\n","protected":false},"author":21,"featured_media":10788,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[559],"tags":[566],"class_list":["post-10907","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c26-blog","tag-data-parallel-types"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/10907","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=10907"}],"version-history":[{"count":7,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/10907\/revisions"}],"predecessor-version":[{"id":11013,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/10907\/revisions\/11013"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/10788"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=10907"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=10907"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=10907"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}