{"id":9992,"date":"2024-09-09T10:18:04","date_gmt":"2024-09-09T10:18:04","guid":{"rendered":"https:\/\/www.modernescpp.com\/?p=9992"},"modified":"2025-07-03T15:54:21","modified_gmt":"2025-07-03T15:54:21","slug":"an-overview-of-c26-the-library-math","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/an-overview-of-c26-the-library-math\/","title":{"rendered":"An Overview Of C++26: The Library – Math"},"content":{"rendered":"\n

The most interesting feature of the new C++26 standard library is its improved math support.<\/p>\n\n\n\n

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

std::submdspan<\/code><\/h2>\n\n\n\n

std::submdspan<\/code> is a subspan of an existing span std::mdspan (C++23). The subspan was not included in C++23 and was added with C++26.<\/p>\n\n\n\n

Before I continue with C++26, I need to make a brief detour to C++23. <\/p>\n\n\n\n

std::mdspan<\/h2>\n\n\n\n

A std::mdspan<\/code> is a non-owning multidimensional view of a contiguous sequence of objects. The contiguous sequence of objects can be a plain C-array, a pointer with a size, a std::array<\/code>, a std::vector<\/code>, or a std::string<\/code>. Often, this multidimensional view is referred to as a multidimensional array.<\/p>\n\n\n\n

The number of dimensions and the size of each dimension determine the shape of the multidimensional array. The number of dimensions is called rank, and the size of each dimension extension. The size of the std::mdspan<\/code> is the product of all dimensions that are not 0. You can access the elements of a std::mdspan<\/code> using the multidimensional index operator []<\/code>.<\/p>\n\n\n\n

Each dimension of a std::mdspan<\/code> can have a static <\/em>or dynamic extent<\/em>. static extent<\/em> means that its length is specified at compile time; dynamic extent<\/em> means that its length is specified at run time. <\/p>\n\n\n\n

Thanks to class template argument deduction (CTAG) in C++17, the compiler can often automatically deduce the template arguments from the types of initializers:<\/p>\n\n\n\n

\/\/ mdspan.cpp<\/span>\n\n#include <mdspan><\/span>\n#include <iostream><\/span>\n#include <vector><\/span>\n\nint<\/span> main<\/span>() {\n    \n    std::<\/span>vector myVec{1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>, 6<\/span>, 7<\/span>, 8<\/span>};          \/\/ (1)<\/span>\n\n    std::<\/span>mdspan m{myVec.data(), 2<\/span>, 4<\/span>};                  \/\/ (2)<\/span>\n    std::<\/span>cout <<<\/span> "m.rank(): "<\/span> <<<\/span> m.rank() <<<\/span> '\\n'<\/span>;      \/\/ (4)<\/span>\n\n    for<\/span> (std::<\/span>size_t<\/span> i =<\/span> 0<\/span>; i <<\/span> m.extent(0<\/span>); ++<\/span>i) {     \/\/ (6)<\/span>\n        for<\/span> (std::<\/span>size_t<\/span> j =<\/span> 0<\/span>; j <<\/span> m.extent(1<\/span>); ++<\/span>j) { \/\/ (7)<\/span>\n            std::<\/span>cout <<<\/span> m[i, j] <<<\/span> ' '<\/span>;                \/\/ (8)<\/span>\n        }\n        std::<\/span>cout <<<\/span> '\\n'<\/span>;\n    }\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n    std::<\/span>mdspan m2{myVec.data(), 4<\/span>, 2<\/span>};                 \/\/ (3)<\/span>\n    std::<\/span>cout <<<\/span> "m2.rank(): "<\/span> <<<\/span> m2.rank() <<<\/span> '\\n'<\/span>;    \/\/ (5)<\/span>\n\n    for<\/span> (std::<\/span>size_t<\/span> i =<\/span> 0<\/span>; i <<\/span> m2.extent(0<\/span>); ++<\/span>i) {\n        for<\/span> (std::<\/span>size_t<\/span> j =<\/span> 0<\/span>; j <<\/span> m2.extent(1<\/span>); ++<\/span>j) {\n        std::<\/span>cout <<<\/span> m2[i, j] <<<\/span> ' '<\/span>;  \n    }\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n  }\n\n}\n<\/pre><\/div>\n\n\n\n
I apply class template argument deduction three times in this example. Line (1) uses it for a std::vector<\/code>, and lines (2) and (3) for a std::mdspan<\/code>. The first 2-dimensional array m <\/code>has a shape of (2, 4), the second one m2 <\/code>a shape of (4, 2). Lines (4) and (5) display the ranks of both std::mdspan<\/code>. Thanks to the extent of each dimension (lines 6 and 7) and the index operator in line (8), it is straightforward to iterate through multidimensional arrays.<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Here ends my detour, and I continue with std::submdspan.<\/code><\/p>\n\n\n\n
std::submdspan<\/h2>\n\n\n\n
This function was considered critical for the overall functionality of mdspan<\/code>. However, due to review time constraints, it was removed in order for mdspan<\/code> to be included in C++23.<\/p>\n\n\n\n
Creating a std::submdspan<\/code> is straightforward. Its first parameter is an mdspan<\/code> x<\/code>. The remaining x.rank()<\/code> parameters are slice specifiers, one for each dimension of x<\/code>. The slice specifiers describe which elements of the range [0,x.extent(d)<\/code>) are part of the multidimensional index space of the returned mdspan<\/code>.<\/p>\n\n\n\n
This leads to the following fundamental signature:<\/p>\n\n\n\n
<\/a>template<class T, class E, class L, class A,\n<\/a>         class ... SliceArgs)\n<\/a>auto submdspan(mdspan<T,E,L,A> x, SliceArgs ... args);<\/code><\/pre>\n\n\n\n
where E.rank()<\/code> must be equal to sizeof...(SliceArgs)<\/code>.<\/p>\n\n\n\n
Proposal P2630R4 provides, in addition to the definition of a std::submdspan<\/code>, a few examples for a rank-1 mdspan<\/code>.<\/p>\n\n\n\n
int<\/span>*<\/span> ptr =<\/span> ...;\nint<\/span> N =<\/span> ...;\nmdspan a<\/span>(ptr, N);\n\n\/\/ subspan of a single element<\/span>\nauto<\/span> a_sub1 =<\/span> submdspan(a, 1<\/span>);\nstatic_assert(decltype(a_sub1)::<\/span>rank() ==<\/span> 0<\/span>);\nassert(&<\/span>a_sub1() ==<\/span> &<\/span>a(1<\/span>));\n\n\/\/ subrange<\/span>\nauto<\/span> a_sub2 =<\/span> submdspan(a, tuple{1<\/span>, 4<\/span>});\nstatic_assert(decltype(a_sub2)::<\/span>rank() ==<\/span> 1<\/span>);\nassert(&<\/span>a_sub2(0<\/span>) ==<\/span> &<\/span>a(1<\/span>));\nassert(a_sub2.extent(0<\/span>) ==<\/span> 3<\/span>);\n\n\/\/ subrange with stride<\/span>\nauto<\/span> a_sub3 =<\/span> submdspan(a, strided_slice{1<\/span>, 7<\/span>, 2<\/span>});\nstatic_assert(decltype(a_sub3)::<\/span>rank() ==<\/span> 1<\/span>);\nassert(&<\/span>a_sub3(0<\/span>) ==<\/span> &<\/span>a(1<\/span>));\nassert(&<\/span>a_sub3(3<\/span>) ==<\/span> &<\/span>a(7<\/span>));\nassert(a_sub3.extent(0<\/span>) ==<\/span> 4<\/span>);\n\n\/\/ full range<\/span>\nauto<\/span> a_sub4 =<\/span> submdspan(a, full_extent);\nstatic_assert(decltype(a_sub4)::<\/span>rank() ==<\/span> 1<\/span>);\nassert(a_sub4(0<\/span>) ==<\/span> a(0<\/span>));\nassert(a_sub4.extent(0<\/span>) ==<\/span> a.extent(0<\/span>));\n<\/pre><\/div>\n\n\n\n
 The same rules apply to the multi-dimensional use case.<\/p>\n\n\n\n
int<\/span>*<\/span> ptr =<\/span> ...;\nint<\/span> N0 =<\/span> ..., N1 =<\/span> ..., N2 =<\/span> ..., N3 =<\/span> ..., N4 =<\/span> ...;\nmdspan a<\/span>(ptr, N0, N1, N2, N3, N4);\n\nauto<\/span> a_sub =<\/span> submdspan(a,full_extent_t<\/span>(), 3<\/span>, strided_slice{2<\/span>,N2-<\/span>5<\/span>, 2<\/span>}, 4<\/span>, tuple{3<\/span>, N5-<\/span>5<\/span>});\n\n\/\/ two integral specifiers so the rank is reduced by 2<\/span>\nstatic_assert(decltype(a_sub) ==<\/span> 3<\/span>);\n\/\/ 1st dimension is taking the whole extent<\/span>\nassert(a_sub.extent(0<\/span>) ==<\/span> a.extent(0<\/span>));\n\/\/ the new 2nd dimension corresponds to the old 3rd dimension<\/span>\nassert(a_sub.extent(1<\/span>) ==<\/span> (a.extent(2<\/span>) -<\/span> 5<\/span>)\/<\/span>2<\/span>);\nassert(a_sub.stride(1<\/span>) ==<\/span> a.stride(2<\/span>)*<\/span>2<\/span>);\n\/\/ the new 3rd dimension corresponds to the old 5th dimension<\/span>\nassert(a_sub.extent(2<\/span>) ==<\/span> a.extent(4<\/span>)-<\/span>8<\/span>);\n\nassert(&<\/span>a_sub(1<\/span>,5<\/span>,7<\/span>) ==<\/span> &<\/span>a(1<\/span>, 3<\/span>, 2<\/span>+<\/span>5<\/span>*<\/span>2<\/span>, 4<\/span>, 3<\/span>+<\/span>7<\/span>));\n<\/pre><\/div>\n\n\n\n
 This is not the end of the support is C++26.<\/p>\n\n\n\n
<linalg>: <\/h2>\n\n\n\n
<linalg><\/a> is a free function linear algebra interface based on the BLAS.<\/p>\n\n\n\n
BLAS: Basic Linear Algebra Subprograms<\/strong> (BLAS<\/strong>) is a specification<\/a> that prescribes a set of low-level routines for performing common linear algebra<\/a> operations such as vector<\/a> addition, scalar multiplication<\/a>, dot products<\/a>, linear combinations, and matrix multiplication<\/a>. They are the de facto<\/a><\/em> standard low-level routines for linear algebra libraries … .(https:\/\/en.wikipedia.org\/wiki\/Basic_Linear_Algebra_Subprograms<\/a>)<\/p>\n\n\n\n
Proposal P1673R13<\/a> proposes a C++ Standard Library dense linear algebra interface based on the dense Basic Linear Algebra Subroutines (BLAS). This corresponds to a subset of the BLAS Standard<\/a>. <\/p>\n\n\n\n
Linear algebra was long missed in the C++ community. According to the proposal, the following code snippet is the hello world of linear algebra. It scales the elements of a 1-D mdspan<\/code> by a constant factor, first sequentially, then in parallel.<\/p>\n\n\n\n
  constexpr size_t<\/span> N =<\/span> 40<\/span>;\n  std::<\/span>vector<<\/span>double<\/span>><\/span> x_vec(N);\n\n  mdspan x<\/span>(x_vec.data(), N);\n  for<\/span>(size_t<\/span> i =<\/span> 0<\/span>; i <<\/span> N; ++<\/span>i) {\n    x[i] =<\/span> double<\/span>(i);\n  }\n\n  linalg::<\/span>scale(2.0<\/span>, x); \/\/ x = 2.0 * x<\/span>\n  linalg::<\/span>scale(std::<\/span>execution::<\/span>par_unseq, 3.0<\/span>, x);\n  for<\/span>(size_t<\/span> i =<\/span> 0<\/span>; i <<\/span> N; ++<\/span>i) {\n    assert(x[i] ==<\/span> 6.0<\/span> *<\/span> double<\/span>(i));\n  }\n<\/pre><\/div>\n\n\n\n
 What’s next?<\/h2>\n\n\n\n
I’m still not done with C++26. In my next post, I will discuss saturation arithmetic and the concurrency support in C++26.<\/p>\n\n\n\n
<\/p>\n\n\n\n
<\/p>\n\n\n\n
<\/p>\n\n\n\n
<\/p>\n\n\n\n
<\/p>\n","protected":false},"excerpt":{"rendered":"
The most interesting feature of the new C++26 standard library is its improved math support. std::submdspan std::submdspan is a subspan of an existing span std::mdspan (C++23). The subspan was not included in C++23 and was added with C++26. Before I continue with C++26, I need to make a brief detour to C++23. std::mdspan A std::mdspan […]<\/p>\n","protected":false},"author":21,"featured_media":10028,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[559],"tags":[],"class_list":["post-9992","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c26-blog"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/9992","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=9992"}],"version-history":[{"count":18,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/9992\/revisions"}],"predecessor-version":[{"id":10849,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/9992\/revisions\/10849"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/10028"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=9992"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=9992"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=9992"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}